GitHub

endpoint

API reference for endpoint.

HTTP API endpoints (Effect's HttpApiEndpoint): a method, a path and the schemas of a request and its responses.

get("getUser", "/users/:id", params=..., success=..., error=...) makes one. An endpoint is HttpApiEndpoint[P, Q, B, CB, H, S, CS, E, M]: the decoded params, query, payload (as the handler gets it and as a client sends it), headers, success (as the handler returns it and as a client gets it), errors and middleware classes (a last parameter repeats M so that the builder can read both the middleware and what it provides; leave it out). A slot the endpoint does not declare is None. Declared on a group class, an endpoint read from the class is the endpoint; read from a client's group it is the client method.

Types

TypeDefinitionDescription
HttpMethodtype HttpMethod = Literal['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'QUERY', 'HEAD']

The methods of endpoints.

PayloadEntrytype PayloadEntry = BufferedPayload | StreamPayload
PayloadMaptype PayloadMap = Mapping[str, PayloadEntry]

The payload schemas by normalized content type.

AnyEndpointtype AnyEndpoint = HttpApiEndpoint[Any, Any, Any, Any, Any, Any, Any, Any, Any, Any]

Classes

Functions

success_schemas

success_schemas(endpoint) -> tuple[Top, ...]

The success schemas; NoContent when none were declared.

ParameterTypeDescription
endpointAnyEndpoint

Returns tuple[Top, ...]

def success_schemas(endpoint: AnyEndpoint) -> tuple[Top, ...]:
    """The success schemas; ``NoContent`` when none were declared."""
    return endpoint.success or (api_schema.NoContent,)

error_schemas

error_schemas(endpoint) -> tuple[Top, ...]

The error schemas, the middleware's included.

ParameterTypeDescription
endpointAnyEndpoint

Returns tuple[Top, ...]

def error_schemas(endpoint: AnyEndpoint) -> tuple[Top, ...]:
    """The error schemas, the middleware's included."""
    schemas: dict[int, Top] = {id(s): s for s in endpoint.error}
    for middleware in endpoint.middlewares:
        for schema in middleware.errors():
            transformed = schema if endpoint.disable_codecs else transform_response(schema)
            schemas.setdefault(id(transformed), transformed)
    return tuple(schemas.values())

payload_schemas

payload_schemas(endpoint) -> tuple[Top, ...]
ParameterTypeDescription
endpointAnyEndpoint

Returns tuple[Top, ...]

def payload_schemas(endpoint: AnyEndpoint) -> tuple[Top, ...]:
    out: list[Top] = []
    for entry in endpoint.payload.values():
        out.extend(entry.schemas if isinstance(entry, BufferedPayload) else (entry.schema,))
    return tuple(out)

make

make(method, identifier, path, *, params=None, query=None, headers=None, payload=None, success=None, error=None, disable_codecs=False) -> AnyEndpoint

An endpoint; the schemas are checked here (ValueError): a stream is a success or payload of a method with a body, at most one upgrade and no stream beside it, response headers once per status, ...

ParameterTypeDescription
methodHttpMethod
identifierstr
pathstr
paramsTop | None = None
queryTop | None = None
headersTop | None = None
payloadTop | tuple[Top, ...] | None = None
successTop | tuple[Top, ...] | None = None
errorTop | tuple[Top, ...] | None = None
disable_codecsbool = False

Returns AnyEndpoint

def make(
    method: HttpMethod,
    identifier: str,
    path: str,
    *,
    params: Top | None = None,
    query: Top | None = None,
    headers: Top | None = None,
    payload: Top | tuple[Top, ...] | None = None,
    success: Top | tuple[Top, ...] | None = None,
    error: Top | tuple[Top, ...] | None = None,
    disable_codecs: bool = False,
) -> AnyEndpoint:
    """An endpoint; the schemas are checked here (``ValueError``): a
    stream is a success or payload of a method with a body, at most one
    upgrade and no stream beside it, response headers once per status, ..."""
    properties: Callable[[Top], Top] = _same if disable_codecs else to_codec_http_properties
    payload_map = _payload(payload, method, disable_codecs)
    return HttpApiEndpoint(
        identifier,
        method,
        path,
        params=None if params is None else properties(params),
        query=None if query is None else properties(query),
        headers=None if headers is None else properties(headers),
        payload=payload_map,
        success=_success(success, method, payload_map, disable_codecs),
        error=_error(error, disable_codecs),
        disable_codecs=disable_codecs,
    )

to_codec_http_properties

to_codec_http_properties(schema) -> Top

schema read from strings: a URL's params and query, headers.

ParameterTypeDescription
schemaTop

Returns Top

def to_codec_http_properties(schema: Top) -> Top:
    """``schema`` read from strings: a URL's params and query, headers."""
    return to_codec_string_tree(schema)

transform_response

transform_response(schema) -> Top

A response schema with its wire codec: JSON or string tree by its encoding, its headers read from strings. The same schema always gives the same codec, so an error a middleware repeats is one response.

ParameterTypeDescription
schemaTop

Returns Top

@cache
def transform_response(schema: Top) -> Top:
    """A response schema with its wire codec: JSON or string tree by its
    encoding, its headers read from strings. The same schema always gives
    the same codec, so an error a middleware repeats is one response."""
    if api_schema.is_stream_schema(schema):
        return schema
    if api_schema.is_upgrade(schema):
        if schema.headers is None:
            return schema
        return replace(schema, headers=to_codec_http_properties(schema.headers))
    if api_schema.is_with_headers(schema):
        inner = schema.schema
        if not api_schema.is_stream_schema(inner):
            inner = _apply_encoding(inner, api_schema.get_response_encoding_schema(schema))
        return api_schema.rebuild_with_headers(
            schema, inner, to_codec_http_properties(schema.headers)
        )
    node = schema.__codec__().ast
    encoding = api_schema.get_response_encoding(node)
    annotation = api_schema.get_with_headers_annotation(node)
    if annotation is None:
        return _apply_encoding(schema, encoding)
    return schema.__codec__().annotate(
        http_api_with_headers=replace(
            annotation,
            body_codec=_apply_encoding(annotation.body, encoding),
            headers_codec=to_codec_http_properties(annotation.headers),
        )
    )

get

get[S, CS, P = None, Q = None, H = None, B = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None, success: _Success[S, CS], error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, B, H, S, CS, E]
get[P = None, Q = None, H = None, B = None, S = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None, success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None, error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, B, H, S, S, E]

A GET endpoint (see make).

ParameterTypeDescription
identifier
path
options= {}
@overload
def get[S, CS, P = None, Q = None, H = None, B = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None,
    success: _Success[S, CS],
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, B, H, S, CS, E]: ...
@overload
def get[P = None, Q = None, H = None, B = None, S = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None,
    success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None,
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, B, H, S, S, E]: ...
def get(identifier: str, path: str, **options: Any) -> AnyEndpoint:
    """A ``GET`` endpoint (see ``make``)."""
    return make("GET", identifier, path, **options)
head[S, CS, P = None, Q = None, H = None, B = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None, success: _Success[S, CS], error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, B, H, S, CS, E]
head[P = None, Q = None, H = None, B = None, S = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None, success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None, error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, B, H, S, S, E]

A HEAD endpoint (see make).

ParameterTypeDescription
identifier
path
options= {}
@overload
def head[S, CS, P = None, Q = None, H = None, B = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None,
    success: _Success[S, CS],
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, B, H, S, CS, E]: ...
@overload
def head[P = None, Q = None, H = None, B = None, S = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None,
    success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None,
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, B, H, S, S, E]: ...
def head(identifier: str, path: str, **options: Any) -> AnyEndpoint:
    """A ``HEAD`` endpoint (see ``make``)."""
    return make("HEAD", identifier, path, **options)

options

options[S, CS, P = None, Q = None, H = None, B = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None, success: _Success[S, CS], error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, B, H, S, CS, E]
options[P = None, Q = None, H = None, B = None, S = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None, success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None, error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, B, H, S, S, E]

A OPTIONS endpoint (see make).

ParameterTypeDescription
identifier
path
options= {}
@overload
def options[S, CS, P = None, Q = None, H = None, B = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None,
    success: _Success[S, CS],
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, B, H, S, CS, E]: ...
@overload
def options[P = None, Q = None, H = None, B = None, S = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None,
    success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None,
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, B, H, S, S, E]: ...
def options(identifier: str, path: str, **options: Any) -> AnyEndpoint:
    """A ``OPTIONS`` endpoint (see ``make``)."""
    return make("OPTIONS", identifier, path, **options)

post

post[B, CB, S, CS, P = None, Q = None, H = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: _Payload[B, CB], success: _Success[S, CS], error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, CB, H, S, CS, E]
post[B, CB, P = None, Q = None, H = None, S = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: _Payload[B, CB], success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None, error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, CB, H, S, S, E]
post[S, CS, P = None, Q = None, H = None, B = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None, success: _Success[S, CS], error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, B, H, S, CS, E]
post[P = None, Q = None, H = None, B = None, S = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None, success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None, error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, B, H, S, S, E]

A POST endpoint (see make).

ParameterTypeDescription
identifier
path
options= {}
@overload
def post[B, CB, S, CS, P = None, Q = None, H = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: _Payload[B, CB],
    success: _Success[S, CS],
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, CB, H, S, CS, E]: ...
@overload
def post[B, CB, P = None, Q = None, H = None, S = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: _Payload[B, CB],
    success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None,
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, CB, H, S, S, E]: ...
@overload
def post[S, CS, P = None, Q = None, H = None, B = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None,
    success: _Success[S, CS],
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, B, H, S, CS, E]: ...
@overload
def post[P = None, Q = None, H = None, B = None, S = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None,
    success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None,
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, B, H, S, S, E]: ...
def post(identifier: str, path: str, **options: Any) -> AnyEndpoint:
    """A ``POST`` endpoint (see ``make``)."""
    return make("POST", identifier, path, **options)

put

put[B, CB, S, CS, P = None, Q = None, H = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: _Payload[B, CB], success: _Success[S, CS], error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, CB, H, S, CS, E]
put[B, CB, P = None, Q = None, H = None, S = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: _Payload[B, CB], success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None, error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, CB, H, S, S, E]
put[S, CS, P = None, Q = None, H = None, B = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None, success: _Success[S, CS], error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, B, H, S, CS, E]
put[P = None, Q = None, H = None, B = None, S = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None, success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None, error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, B, H, S, S, E]

A PUT endpoint (see make).

ParameterTypeDescription
identifier
path
options= {}
@overload
def put[B, CB, S, CS, P = None, Q = None, H = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: _Payload[B, CB],
    success: _Success[S, CS],
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, CB, H, S, CS, E]: ...
@overload
def put[B, CB, P = None, Q = None, H = None, S = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: _Payload[B, CB],
    success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None,
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, CB, H, S, S, E]: ...
@overload
def put[S, CS, P = None, Q = None, H = None, B = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None,
    success: _Success[S, CS],
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, B, H, S, CS, E]: ...
@overload
def put[P = None, Q = None, H = None, B = None, S = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None,
    success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None,
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, B, H, S, S, E]: ...
def put(identifier: str, path: str, **options: Any) -> AnyEndpoint:
    """A ``PUT`` endpoint (see ``make``)."""
    return make("PUT", identifier, path, **options)

patch

patch[B, CB, S, CS, P = None, Q = None, H = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: _Payload[B, CB], success: _Success[S, CS], error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, CB, H, S, CS, E]
patch[B, CB, P = None, Q = None, H = None, S = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: _Payload[B, CB], success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None, error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, CB, H, S, S, E]
patch[S, CS, P = None, Q = None, H = None, B = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None, success: _Success[S, CS], error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, B, H, S, CS, E]
patch[P = None, Q = None, H = None, B = None, S = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None, success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None, error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, B, H, S, S, E]

A PATCH endpoint (see make).

ParameterTypeDescription
identifier
path
options= {}
@overload
def patch[B, CB, S, CS, P = None, Q = None, H = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: _Payload[B, CB],
    success: _Success[S, CS],
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, CB, H, S, CS, E]: ...
@overload
def patch[B, CB, P = None, Q = None, H = None, S = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: _Payload[B, CB],
    success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None,
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, CB, H, S, S, E]: ...
@overload
def patch[S, CS, P = None, Q = None, H = None, B = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None,
    success: _Success[S, CS],
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, B, H, S, CS, E]: ...
@overload
def patch[P = None, Q = None, H = None, B = None, S = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None,
    success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None,
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, B, H, S, S, E]: ...
def patch(identifier: str, path: str, **options: Any) -> AnyEndpoint:
    """A ``PATCH`` endpoint (see ``make``)."""
    return make("PATCH", identifier, path, **options)

delete

delete[B, CB, S, CS, P = None, Q = None, H = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: _Payload[B, CB], success: _Success[S, CS], error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, CB, H, S, CS, E]
delete[B, CB, P = None, Q = None, H = None, S = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: _Payload[B, CB], success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None, error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, CB, H, S, S, E]
delete[S, CS, P = None, Q = None, H = None, B = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None, success: _Success[S, CS], error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, B, H, S, CS, E]
delete[P = None, Q = None, H = None, B = None, S = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None, success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None, error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, B, H, S, S, E]

A DELETE endpoint (see make).

ParameterTypeDescription
identifier
path
options= {}
@overload
def delete[B, CB, S, CS, P = None, Q = None, H = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: _Payload[B, CB],
    success: _Success[S, CS],
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, CB, H, S, CS, E]: ...
@overload
def delete[B, CB, P = None, Q = None, H = None, S = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: _Payload[B, CB],
    success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None,
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, CB, H, S, S, E]: ...
@overload
def delete[S, CS, P = None, Q = None, H = None, B = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None,
    success: _Success[S, CS],
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, B, H, S, CS, E]: ...
@overload
def delete[P = None, Q = None, H = None, B = None, S = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None,
    success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None,
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, B, H, S, S, E]: ...
def delete(identifier: str, path: str, **options: Any) -> AnyEndpoint:
    """A ``DELETE`` endpoint (see ``make``)."""
    return make("DELETE", identifier, path, **options)

query

query[B, CB, S, CS, P = None, Q = None, H = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: _Payload[B, CB], success: _Success[S, CS], error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, CB, H, S, CS, E]
query[B, CB, P = None, Q = None, H = None, S = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: _Payload[B, CB], success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None, error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, CB, H, S, S, E]
query[S, CS, P = None, Q = None, H = None, B = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None, success: _Success[S, CS], error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, B, H, S, CS, E]
query[P = None, Q = None, H = None, B = None, S = None, E = Never](identifier: str, path: str, *, params: Codec[P, Any, Never, Never] | None = None, query: Codec[Q, Any, Never, Never] | None = None, headers: Codec[H, Any, Never, Never] | None = None, payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None, success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None, error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None, disable_codecs: bool = False) -> HttpApiEndpoint[P, Q, B, B, H, S, S, E]

A QUERY endpoint (see make).

ParameterTypeDescription
identifier
path
options= {}
@overload
def query[B, CB, S, CS, P = None, Q = None, H = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: _Payload[B, CB],
    success: _Success[S, CS],
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, CB, H, S, CS, E]: ...
@overload
def query[B, CB, P = None, Q = None, H = None, S = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: _Payload[B, CB],
    success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None,
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, CB, H, S, S, E]: ...
@overload
def query[S, CS, P = None, Q = None, H = None, B = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None,
    success: _Success[S, CS],
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, B, H, S, CS, E]: ...
@overload
def query[P = None, Q = None, H = None, B = None, S = None, E = Never](
    identifier: str,
    path: str,
    *,
    params: Codec[P, Any, Never, Never] | None = None,
    query: Codec[Q, Any, Never, Never] | None = None,
    headers: Codec[H, Any, Never, Never] | None = None,
    payload: Codec[B, Any, Never, Never] | tuple[Codec[B, Any, Never, Never], ...] | None = None,
    success: Codec[S, Any, Never, Never] | tuple[Codec[S, Any, Never, Never], ...] | None = None,
    error: Codec[E, Any, Never, Never] | tuple[Codec[E, Any, Never, Never], ...] | None = None,
    disable_codecs: bool = False,
) -> HttpApiEndpoint[P, Q, B, B, H, S, S, E]: ...
def query(identifier: str, path: str, **options: Any) -> AnyEndpoint:
    """A ``QUERY`` endpoint (see ``make``)."""
    return make("QUERY", identifier, path, **options)