# tenchi
AppError (re-export of tenchi.errors.AppError)
Client (re-export of tenchi.client.Client)
ClientResponse (re-export of tenchi.client.ClientResponse)
ConfigurationError (re-export of tenchi.errors.ConfigurationError)
Contract (re-export of tenchi.contracts.Contract)
ErrorDef (re-export of tenchi.errors.ErrorDef)
ExecutionError (re-export of tenchi.execution.ExecutionError)
OutcomeObserver = collections.abc.Callable[[tenchi.server.RequestOutcome], typing.Any]
Page (re-export of tenchi.pagination.Page)
PageQuery (re-export of tenchi.pagination.PageQuery)
PresentedResponse (re-export of tenchi.responses.PresentedResponse)
RequestInfo (re-export of tenchi.server.RequestInfo)
RequestOutcome (re-export of tenchi.server.RequestOutcome)
ResponseDef (re-export of tenchi.responses.ResponseDef)
Route (re-export of tenchi.routes.Route)
RouteGroup (re-export of tenchi.routes.RouteGroup)
TenchiError (re-export of tenchi.errors.TenchiError)
UnexpectedResponseError (re-export of tenchi.client.UnexpectedResponseError)
contract (re-export of tenchi.contracts.contract)
create_app (re-export of tenchi.server.create_app)
execute (re-export of tenchi.execution.execute)
health_route (re-export of tenchi.health.health_route)
openapi_route (re-export of tenchi.openapi.openapi_route)
openapi_schema (re-export of tenchi.openapi.openapi_schema)
page (re-export of tenchi.pagination.page)
present (re-export of tenchi.responses.present)
response (re-export of tenchi.responses.response)
route (re-export of tenchi.routes.route)
route_group (re-export of tenchi.routes.route_group)

# tenchi.client
class Client
    def __init__(self, *, base_url: 'str | None' = None, headers: 'Mapping[str, str] | None' = None, transport: 'httpx.AsyncBaseTransport | None' = None, http: 'httpx.AsyncClient | None' = None, errors: 'Sequence[ErrorDef]' = ()) -> 'None'
    def aclose(self) -> 'None'
    def call(self, contract: 'Contract[ResponseT, ResponseHeadersT]', *, params: 'Any' = None, query: 'Any' = None, headers: 'Any' = None, request: 'Any' = UNSET) -> 'ResponseT'
    def call_with_response(self, contract: 'Contract[ResponseT, ResponseHeadersT]', *, params: 'Any' = None, query: 'Any' = None, headers: 'Any' = None, request: 'Any' = UNSET) -> 'ClientResponse[ResponseT, ResponseHeadersT]'
class ClientResponse(Generic)
    body: BodyT
    headers: HeadersT
    http_response: httpx.Response
    definition: ResponseDef[Any, Any] | None = None
    def __init__(self, body: 'BodyT', headers: 'HeadersT', http_response: 'httpx.Response', definition: 'ResponseDef[Any, Any] | None' = None) -> None
class UnexpectedResponseError(TenchiError)
    def __init__(self, *, contract_name: 'str', status_code: 'int', body: 'Any', reason: 'str | None' = None) -> 'None'

# tenchi.compatibility
class CompatibilityChange
    severity: ChangeSeverity
    location: str
    message: str
    def __init__(self, severity: 'ChangeSeverity', location: 'str', message: 'str') -> None
class CompatibilityReport
    changes: tuple[CompatibilityChange, ...]
    def __init__(self, changes: 'tuple[CompatibilityChange, ...]') -> None
    def as_dict(self) -> 'dict[str, object]'
    property compatible(self) -> 'bool'
    def count(self, severity: 'ChangeSeverity') -> 'int'
    property status(self) -> 'CompatibilityStatus'
def analyze_openapi_compatibility(baseline: 'object', current: 'object') -> 'CompatibilityReport'
def render_compatibility_report(report: 'CompatibilityReport', *, baseline_path: 'str') -> 'str'

# tenchi.contracts
class Contract(Generic)
    method: str
    path: str
    request: type[Any] | UnionType | None = None
    params: type[Any] | UnionType | None = None
    query: type[Any] | UnionType | None = None
    headers: type[Any] | UnionType | None = None
    response: type[ResponseT] | UnionType | None = None
    response_headers: type[ResponseHeadersT] | UnionType | None = None
    status: int = 200
    errors: tuple[ErrorDef, ...] = ()
    name: str = ''
    request_media_type: str = 'application/json'
    response_media_type: str = 'application/json'
    summary: str | None = None
    description: str | None = None
    tags: tuple[str, ...] = ()
    public: bool = False
    deprecated: bool | datetime = False
    sunset: datetime | None = None
    max_request_bytes: int | None = None
    responses: tuple[ResponseDef[Any, Any], ...] = ()
    timeout: float | None = None
    def __init__(self, method: 'str', path: 'str', request: 'type[Any] | UnionType | None' = None, params: 'type[Any] | UnionType | None' = None, query: 'type[Any] | UnionType | None' = None, headers: 'type[Any] | UnionType | None' = None, response: 'type[ResponseT] | UnionType | None' = None, response_headers: 'type[ResponseHeadersT] | UnionType | None' = None, status: 'int' = 200, errors: 'tuple[ErrorDef, ...]' = (), name: 'str' = '', request_media_type: 'str' = 'application/json', response_media_type: 'str' = 'application/json', summary: 'str | None' = None, description: 'str | None' = None, tags: 'tuple[str, ...]' = (), public: 'bool' = False, deprecated: 'bool | datetime' = False, sunset: 'datetime | None' = None, max_request_bytes: 'int | None' = None, responses: 'tuple[ResponseDef[Any, Any], ...]' = (), timeout: 'float | None' = None) -> None
    def declares_error(self, definition: 'ErrorDef') -> 'bool'
def contract(*, method: 'str', path: 'str', request: 'type[Any] | UnionType | None' = None, params: 'type[Any] | UnionType | None' = None, query: 'type[Any] | UnionType | None' = None, headers: 'type[Any] | UnionType | None' = None, response: 'type[ResponseT] | UnionType | None' = None, response_headers: 'type[ResponseHeadersT] | UnionType | None' = None, status: 'int' = 200, errors: 'Sequence[ErrorDef]' = (), name: 'str | None' = None, request_media_type: 'str' = 'application/json', response_media_type: 'str' = 'application/json', summary: 'str | None' = None, description: 'str | None' = None, tags: 'Sequence[str]' = (), public: 'bool' = False, deprecated: 'bool | datetime' = False, sunset: 'datetime | None' = None, max_request_bytes: 'int | None' = None, responses: 'Sequence[ResponseDef[Any, Any]]' = (), timeout: 'float | None' = None) -> 'Contract[ResponseT, ResponseHeadersT]'

# tenchi.errors
class AppError(TenchiError)
    def __init__(self, definition: 'ErrorDef', *, message: 'str | None' = None, details: 'Any' = None, headers: 'Mapping[str, str] | None' = None) -> 'None'
    property code(self) -> 'str'
    property message(self) -> 'str'
    property status(self) -> 'int'
class ConfigurationError(TenchiError, ValueError)
ERROR_SOURCE_HEADER = 'x-tenchi-error-source'
class ErrorDef
    code: str
    status: int
    message: str
    headers: tuple[str, ...] = ()
    def __init__(self, code: 'str', status: 'int', message: 'str', headers: 'tuple[str, ...]' = ()) -> None
REQUEST_ID_HEADER = 'x-request-id'
class TenchiError(Exception)
def error_body(*, code: 'str', message: 'str', details: 'Any' = None, request_id: 'str | None' = None) -> 'dict[str, Any]'

# tenchi.execution
class ExecutionError(TenchiError, TypeError)
def execute(use_case: 'Callable[..., Awaitable[ResultT]]', *, context: 'Any', request: 'Any' = UNSET, request_json: 'bytes | str | None' = None) -> 'ResultT'
def open_context(source: 'Any') -> 'AsyncGenerator[Any]'

# tenchi.health
HealthCheck = collections.abc.Callable[[typing.Any], typing.Any]
class HealthReport(BaseModel)
    status: str = 'ok'
    checks: dict[str, str] = {}
def health_route(*, path: 'str' = '/health', checks: 'Mapping[str, HealthCheck] | None' = None, check_timeout: 'float' = 5.0, public: 'bool' = True) -> 'Route'

# tenchi.openapi
def openapi_route(routes: 'RouteGroup', *, title: 'str', version: 'str', description: 'str | None' = None, security: 'Mapping[str, Mapping[str, Any]] | None' = None, path: 'str' = '/openapi.json', tags: 'Sequence[str]' = ('docs',), public: 'bool' = True) -> 'Route'
def openapi_schema(routes: 'RouteGroup', *, title: 'str', version: 'str', description: 'str | None' = None, security: 'Mapping[str, Mapping[str, Any]] | None' = None) -> 'dict[str, Any]'

# tenchi.pagination
class Page(BaseModel, Generic)
    items: list[ItemT]
    total: int
    limit: int
    offset: int
class PageQuery(BaseModel)
    limit: int = 20
    offset: int = 0
def page(items: collections.abc.Sequence[ItemT], *, total: int, query: tenchi.pagination.PageQuery) -> tenchi.pagination.Page[TypeVar]

# tenchi.routes
class Route
    contract: Contract[Any, Any]
    use_case: UseCase
    call_kwargs: tuple[str, ...]
    response_headers: Callable[[Any], Any] | None = None
    presenter: Callable[[Any], PresentedResponse] | None = None
    def __init__(self, contract: 'Contract[Any, Any]', use_case: 'UseCase', call_kwargs: 'tuple[str, ...]', response_headers: 'Callable[[Any], Any] | None' = None, presenter: 'Callable[[Any], PresentedResponse] | None' = None) -> None
class RouteBindingError(ConfigurationError, TypeError)
class RouteGroup
    routes: tuple[Route, ...]
    def __init__(self, routes: 'tuple[Route, ...]') -> None
UseCase = collections.abc.Callable[..., collections.abc.Awaitable[typing.Any]]
def route(contract: 'Contract[Any, Any]', use_case: 'UseCase', *, response_headers: 'Callable[[Any], Any] | None' = None, present: 'Callable[[Any], PresentedResponse] | None' = None) -> 'Route'
def route_group(*items: 'Route | RouteGroup | Sequence[Route]', prefix: 'str' = '', errors: 'Sequence[ErrorDef]' = ()) -> 'RouteGroup'

# tenchi.responses
class PresentedResponse
    definition: ResponseDef[Any, Any]
    body: Any = UNSET
    headers: Any = UNSET
    response: Response | None = None
    def __init__(self, definition: 'ResponseDef[Any, Any]', body: 'Any' = UNSET, headers: 'Any' = UNSET, response: 'Response | None' = None) -> None
class ResponseDef(Generic)
    body: type[BodyT] | UnionType | None
    status: int
    headers: type[HeadersT] | None = None
    media_type: str | None = 'application/json'
    description: str = 'Successful response'
    passthrough: bool = False
    def __init__(self, body: 'type[BodyT] | UnionType | None', status: 'int', headers: 'type[HeadersT] | None' = None, media_type: 'str | None' = 'application/json', description: 'str' = 'Successful response', passthrough: 'bool' = False) -> None
def present(definition: 'ResponseDef[Any, Any]', body: 'Any' = UNSET, /, *, headers: 'Any' = UNSET, response: 'Response | None' = None) -> 'PresentedResponse'
def response(body: 'type[Any] | UnionType | None', /, *body_alternatives: 'type[Any]', status: 'int', headers: 'type[Any] | None' = None, media_type: 'str | None' = 'application/json', description: 'str' = 'Successful response', passthrough: 'bool' = False) -> 'ResponseDef[Any, Any]'

# tenchi.server
ContextFactory = collections.abc.Callable[..., typing.Any]
DEFAULT_MAX_REQUEST_BYTES = 1048576
ERROR_SOURCE_HEADER = 'x-tenchi-error-source'
Hook = collections.abc.Callable[[tenchi.server.RequestInfo, typing.Any], typing.Any]
Lifespan = collections.abc.Callable[[], contextlib.AbstractAsyncContextManager[typing.Any]]
OutcomeObserver = collections.abc.Callable[[tenchi.server.RequestOutcome], typing.Any]
REQUEST_ID_HEADER = 'x-request-id'
class RequestInfo
    method: str
    path: str
    headers: Mapping[str, str]
    contract: Contract[Any, Any]
    request_id: str
    def __init__(self, method: 'str', path: 'str', headers: 'Mapping[str, str]', contract: 'Contract[Any, Any]', request_id: 'str') -> None
class RequestOutcome
    request: RequestInfo
    status_code: int
    duration_seconds: float
    error_source: Literal['app', 'framework'] | None
    def __init__(self, request: 'RequestInfo', status_code: 'int', duration_seconds: 'float', error_source: "Literal['app', 'framework'] | None") -> None
def create_app(*, routes: 'RouteGroup', context_factory: 'ContextFactory', lifespan: 'Lifespan | None' = None, hooks: 'Sequence[Hook]' = (), middleware: 'Sequence[Middleware]' = (), observers: 'Sequence[OutcomeObserver]' = (), max_request_bytes: 'int | None' = 1048576) -> 'Starlette'

# tenchi.testing
ASGIApp = collections.abc.Callable[..., collections.abc.Awaitable[None]]
def open_client(app: 'ASGIApp', *, headers: 'Mapping[str, str] | None' = None, errors: 'Sequence[ErrorDef]' = (), base_url: 'str' = 'http://testserver') -> 'AsyncGenerator[Client]'
def open_http(app: 'ASGIApp', *, headers: 'Mapping[str, str] | None' = None, base_url: 'str' = 'http://testserver') -> 'AsyncGenerator[httpx.AsyncClient]'
