# Generated by oapi-gen 0.1.0. DO NOT EDIT.
# Source SHA256: bc992a4f0e652367ab7756437f7207d1c1db579e44540e68c06834396fc1ce98
from __future__ import annotations

from pathlib import Path
from typing import Annotated
from uuid import UUID

from msgspec import Meta, convert, json, to_builtins
from starlette.datastructures import MutableHeaders
from starlette.exceptions import HTTPException
from starlette.requests import Request
from starlette.responses import Response
from starlette.routing import Route, Router

from ._runtime import RequestError as _runtime_RequestError
from ._runtime import boolean as _runtime_boolean
from ._runtime import check_json_content_type as _runtime_check_json_content_type
from ._runtime import check_property_counts as _runtime_check_property_counts
from ._runtime import comma_values as _runtime_comma_values
from ._runtime import encode_header as _runtime_encode_header
from ._runtime import error_response as _runtime_error_response
from ._runtime import json_body as _runtime_json_body
from ._runtime import multipart_body as _runtime_multipart_body
from ._runtime import parameter as _runtime_parameter
from ._runtime import upload as _runtime_upload
from .contracts import BearerAuthSecurity
from .contracts import Cookie as _contracts_Cookie
from .contracts import CreateUser as _contracts_CreateUser
from .contracts import DeleteUser as _contracts_DeleteUser
from .contracts import GetCurrentUser as _contracts_GetCurrentUser
from .contracts import GetUser as _contracts_GetUser
from .contracts import Handlers
from .contracts import ListUsers as _contracts_ListUsers
from .contracts import Login as _contracts_Login
from .contracts import Logout as _contracts_Logout
from .contracts import RefreshToken as _contracts_RefreshToken
from .contracts import RequestPasswordReset as _contracts_RequestPasswordReset
from .contracts import ResetPassword as _contracts_ResetPassword
from .contracts import SecurityHandler, SecurityRejected
from .contracts import UpdatePassword as _contracts_UpdatePassword
from .contracts import UpdateUser as _contracts_UpdateUser
from .models import AuthSuccessResponse as _models_AuthSuccessResponse
from .models import CreateUserRequest as _models_CreateUserRequest
from .models import CreateUserResponse as _models_CreateUserResponse
from .models import HttpValidationError as _models_HttpValidationError
from .models import LoginRequest as _models_LoginRequest
from .models import MessageResponse as _models_MessageResponse
from .models import PasswordResetConfirmRequest as _models_PasswordResetConfirmRequest
from .models import PasswordResetRequest as _models_PasswordResetRequest
from .models import UpdatePasswordRequest as _models_UpdatePasswordRequest
from .models import UpdateUserRequest as _models_UpdateUserRequest
from .models import UserItem as _models_UserItem
from .models import UserListResponse as _models_UserListResponse

_encoder = json.Encoder()
_cookie_decoder = json.Decoder(list[_contracts_Cookie] | None)
_login_body_decoder = json.Decoder(_models_LoginRequest)
_login_200_decoder = json.Decoder(_models_AuthSuccessResponse)
_login_200_header_0 = json.Decoder(list[str] | None)
_login_422_decoder = json.Decoder(_models_HttpValidationError)
_logout_200_decoder = json.Decoder(_models_MessageResponse)
_logout_200_header_0 = json.Decoder(str | None)
_logout_422_decoder = json.Decoder(_models_HttpValidationError)
_get_current_user_200_decoder = json.Decoder(_models_UserItem)
_get_current_user_422_decoder = json.Decoder(_models_HttpValidationError)
_update_password_body_decoder = json.Decoder(_models_UpdatePasswordRequest)
_update_password_200_decoder = json.Decoder(_models_AuthSuccessResponse)
_update_password_200_header_0 = json.Decoder(str | None)
_update_password_422_decoder = json.Decoder(_models_HttpValidationError)
_request_password_reset_body_decoder = json.Decoder(_models_PasswordResetRequest)
_request_password_reset_200_decoder = json.Decoder(_models_MessageResponse)
_request_password_reset_422_decoder = json.Decoder(_models_HttpValidationError)
_reset_password_body_decoder = json.Decoder(_models_PasswordResetConfirmRequest)
_reset_password_200_decoder = json.Decoder(_models_MessageResponse)
_reset_password_422_decoder = json.Decoder(_models_HttpValidationError)
_refresh_token_200_decoder = json.Decoder(_models_AuthSuccessResponse)
_refresh_token_200_header_0 = json.Decoder(str | None)
_refresh_token_422_decoder = json.Decoder(_models_HttpValidationError)
_list_users_parameter_0 = Annotated[int, Meta(ge=1)]
json.Decoder(_list_users_parameter_0)
_list_users_parameter_1 = Annotated[int, Meta(ge=1, le=100)]
json.Decoder(_list_users_parameter_1)
_list_users_200_decoder = json.Decoder(_models_UserListResponse)
_list_users_422_decoder = json.Decoder(_models_HttpValidationError)
_create_user_body_decoder = json.Decoder(_models_CreateUserRequest)
_create_user_201_decoder = json.Decoder(_models_CreateUserResponse)
_create_user_422_decoder = json.Decoder(_models_HttpValidationError)
_delete_user_parameter_0 = UUID
json.Decoder(_delete_user_parameter_0)
_delete_user_422_decoder = json.Decoder(_models_HttpValidationError)
_get_user_parameter_0 = UUID
json.Decoder(_get_user_parameter_0)
_get_user_200_decoder = json.Decoder(_models_UserItem)
_get_user_422_decoder = json.Decoder(_models_HttpValidationError)
_update_user_parameter_0 = UUID
json.Decoder(_update_user_parameter_0)
_update_user_body_properties = {
    "schema": {"$ref": "#/components/schemas/UpdateUserRequest"},
    "references": {
        "#/components/schemas/UpdateUserRequest": {
            "type": "object",
            "minProperties": 1,
            "properties": {
                "last_name": {"type": "string"},
                "first_name": {"type": "string"},
                "patronymic": {"type": "string"},
                "is_active": {"type": "boolean"},
                "must_change_password": {"type": "boolean"},
                "available_licenses": {"type": "array", "items": {"type": "integer"}},
            },
        }
    },
}
_update_user_body_decoder = json.Decoder(_models_UpdateUserRequest)
_update_user_200_decoder = json.Decoder(_models_UserItem)
_update_user_422_decoder = json.Decoder(_models_HttpValidationError)


def create_router(
    handlers: Handlers, *, security: SecurityHandler, prefix: str = "", include_schema: bool = True
) -> Router:
    __oapi_handlers = handlers
    __oapi_security = security

    async def __oapi_endpoint_login(__oapi_http: Request) -> Response:
        try:
            __oapi_bytes = await __oapi_http.body()
            if __oapi_bytes:
                _runtime_check_json_content_type(__oapi_http.headers.get("content-type"))
            __oapi_body = _runtime_json_body(__oapi_bytes, _login_body_decoder, required=True)
        except _runtime_RequestError as __oapi_error:
            return _runtime_error_response(__oapi_error)
        __oapi_request = _contracts_Login.Request(body=__oapi_body)
        try:
            __oapi_result = await __oapi_handlers.auth.login(__oapi_request)
        except (
            _contracts_Login.BadRequest,
            _contracts_Login.Unauthorized,
            _contracts_Login.Forbidden,
            _contracts_Login.UnprocessableEntity,
        ) as __oapi_error:
            __oapi_result = __oapi_error
        else:
            if isinstance(__oapi_result, Exception):
                raise TypeError("login error responses must be raised")
        if isinstance(__oapi_result, _contracts_Login.Ok):
            __oapi_headers = MutableHeaders()
            __oapi_cookies = _cookie_decoder.decode(_encoder.encode(__oapi_result.set_cookie))
            __oapi_cookie_headers = (
                [__oapi_cookie.to_header() for __oapi_cookie in __oapi_cookies]
                if __oapi_cookies is not None
                else None
            )
            __oapi_header = _login_200_header_0.decode(_encoder.encode(__oapi_cookie_headers))
            if __oapi_header is not None:
                if isinstance(__oapi_header, list):
                    for __oapi_cookie in __oapi_header:
                        __oapi_headers.append(
                            "Set-Cookie", _runtime_encode_header(to_builtins(__oapi_cookie))
                        )
                else:
                    __oapi_headers["Set-Cookie"] = _runtime_encode_header(
                        to_builtins(__oapi_header)
                    )
            __oapi_body = convert(to_builtins(__oapi_result.body), type=_login_200_decoder.type)
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(
                __oapi_content,
                status_code=200,
                media_type="application/json",
                headers=__oapi_headers,
            )
        if isinstance(__oapi_result, _contracts_Login.BadRequest):
            return Response(status_code=400)
        if isinstance(__oapi_result, _contracts_Login.Unauthorized):
            return Response(status_code=401)
        if isinstance(__oapi_result, _contracts_Login.Forbidden):
            return Response(status_code=403)
        if isinstance(__oapi_result, _contracts_Login.UnprocessableEntity):
            __oapi_body = convert(to_builtins(__oapi_result.body), type=_login_422_decoder.type)
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=422, media_type="application/json")
        raise TypeError("login returned an unsupported response variant")

    async def __oapi_endpoint_logout(__oapi_http: Request) -> Response:
        __oapi_request = _contracts_Logout.Request()
        try:
            __oapi_result = await __oapi_handlers.auth.logout(__oapi_request)
        except _contracts_Logout.UnprocessableEntity as __oapi_error:
            __oapi_result = __oapi_error
        else:
            if isinstance(__oapi_result, Exception):
                raise TypeError("logout error responses must be raised")
        if isinstance(__oapi_result, _contracts_Logout.Ok):
            __oapi_headers = MutableHeaders()
            __oapi_header = _logout_200_header_0.decode(_encoder.encode(__oapi_result.set_cookie))
            if __oapi_header is not None:
                if isinstance(__oapi_header, list):
                    for __oapi_cookie in __oapi_header:
                        __oapi_headers.append(
                            "Set-Cookie", _runtime_encode_header(to_builtins(__oapi_cookie))
                        )
                else:
                    __oapi_headers["Set-Cookie"] = _runtime_encode_header(
                        to_builtins(__oapi_header)
                    )
            __oapi_body = convert(to_builtins(__oapi_result.body), type=_logout_200_decoder.type)
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(
                __oapi_content,
                status_code=200,
                media_type="application/json",
                headers=__oapi_headers,
            )
        if isinstance(__oapi_result, _contracts_Logout.UnprocessableEntity):
            __oapi_body = convert(to_builtins(__oapi_result.body), type=_logout_422_decoder.type)
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=422, media_type="application/json")
        raise TypeError("logout returned an unsupported response variant")

    async def __oapi_endpoint_get_current_user(__oapi_http: Request) -> Response:
        __oapi_security_context: object | None = None
        __oapi_security_satisfied = False
        __oapi_security_0 = __oapi_http.cookies.get("access_token") or None
        if not __oapi_security_satisfied and __oapi_security_0 is not None:
            try:
                __oapi_alternative_context = None
                __oapi_alternative_context = await __oapi_security.handle_bearer_auth(
                    __oapi_alternative_context,
                    "getCurrentUser",
                    BearerAuthSecurity(
                        api_key=__oapi_security_0,
                        roles=(),
                    ),
                )
            except SecurityRejected:
                pass
            else:
                __oapi_security_context = __oapi_alternative_context
                __oapi_security_satisfied = True
        if not __oapi_security_satisfied:
            raise HTTPException(status_code=401, detail="security requirements are not satisfied")
        __oapi_request = _contracts_GetCurrentUser.Request(security_context=__oapi_security_context)
        try:
            __oapi_result = await __oapi_handlers.auth.get_current_user(__oapi_request)
        except (
            _contracts_GetCurrentUser.Unauthorized,
            _contracts_GetCurrentUser.UnprocessableEntity,
        ) as __oapi_error:
            __oapi_result = __oapi_error
        else:
            if isinstance(__oapi_result, Exception):
                raise TypeError("getCurrentUser error responses must be raised")
        if isinstance(__oapi_result, _contracts_GetCurrentUser.Ok):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_get_current_user_200_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=200, media_type="application/json")
        if isinstance(__oapi_result, _contracts_GetCurrentUser.Unauthorized):
            return Response(status_code=401)
        if isinstance(__oapi_result, _contracts_GetCurrentUser.UnprocessableEntity):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_get_current_user_422_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=422, media_type="application/json")
        raise TypeError("getCurrentUser returned an unsupported response variant")

    async def __oapi_endpoint_update_password(__oapi_http: Request) -> Response:
        __oapi_security_context: object | None = None
        __oapi_security_satisfied = False
        __oapi_security_0 = __oapi_http.cookies.get("access_token") or None
        if not __oapi_security_satisfied and __oapi_security_0 is not None:
            try:
                __oapi_alternative_context = None
                __oapi_alternative_context = await __oapi_security.handle_bearer_auth(
                    __oapi_alternative_context,
                    "updatePassword",
                    BearerAuthSecurity(
                        api_key=__oapi_security_0,
                        roles=(),
                    ),
                )
            except SecurityRejected:
                pass
            else:
                __oapi_security_context = __oapi_alternative_context
                __oapi_security_satisfied = True
        if not __oapi_security_satisfied:
            raise HTTPException(status_code=401, detail="security requirements are not satisfied")
        try:
            __oapi_bytes = await __oapi_http.body()
            if __oapi_bytes:
                _runtime_check_json_content_type(__oapi_http.headers.get("content-type"))
            __oapi_body = _runtime_json_body(
                __oapi_bytes, _update_password_body_decoder, required=True
            )
        except _runtime_RequestError as __oapi_error:
            return _runtime_error_response(__oapi_error)
        __oapi_request = _contracts_UpdatePassword.Request(
            body=__oapi_body, security_context=__oapi_security_context
        )
        try:
            __oapi_result = await __oapi_handlers.auth.update_password(__oapi_request)
        except (
            _contracts_UpdatePassword.BadRequest,
            _contracts_UpdatePassword.Unauthorized,
            _contracts_UpdatePassword.UnprocessableEntity,
        ) as __oapi_error:
            __oapi_result = __oapi_error
        else:
            if isinstance(__oapi_result, Exception):
                raise TypeError("updatePassword error responses must be raised")
        if isinstance(__oapi_result, _contracts_UpdatePassword.Ok):
            __oapi_headers = MutableHeaders()
            __oapi_header = _update_password_200_header_0.decode(
                _encoder.encode(__oapi_result.set_cookie)
            )
            if __oapi_header is not None:
                if isinstance(__oapi_header, list):
                    for __oapi_cookie in __oapi_header:
                        __oapi_headers.append(
                            "Set-Cookie", _runtime_encode_header(to_builtins(__oapi_cookie))
                        )
                else:
                    __oapi_headers["Set-Cookie"] = _runtime_encode_header(
                        to_builtins(__oapi_header)
                    )
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_update_password_200_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(
                __oapi_content,
                status_code=200,
                media_type="application/json",
                headers=__oapi_headers,
            )
        if isinstance(__oapi_result, _contracts_UpdatePassword.BadRequest):
            return Response(status_code=400)
        if isinstance(__oapi_result, _contracts_UpdatePassword.Unauthorized):
            return Response(status_code=401)
        if isinstance(__oapi_result, _contracts_UpdatePassword.UnprocessableEntity):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_update_password_422_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=422, media_type="application/json")
        raise TypeError("updatePassword returned an unsupported response variant")

    async def __oapi_endpoint_request_password_reset(__oapi_http: Request) -> Response:
        try:
            __oapi_bytes = await __oapi_http.body()
            if __oapi_bytes:
                _runtime_check_json_content_type(__oapi_http.headers.get("content-type"))
            __oapi_body = _runtime_json_body(
                __oapi_bytes, _request_password_reset_body_decoder, required=True
            )
        except _runtime_RequestError as __oapi_error:
            return _runtime_error_response(__oapi_error)
        __oapi_request = _contracts_RequestPasswordReset.Request(body=__oapi_body)
        try:
            __oapi_result = await __oapi_handlers.auth.request_password_reset(__oapi_request)
        except _contracts_RequestPasswordReset.UnprocessableEntity as __oapi_error:
            __oapi_result = __oapi_error
        else:
            if isinstance(__oapi_result, Exception):
                raise TypeError("requestPasswordReset error responses must be raised")
        if isinstance(__oapi_result, _contracts_RequestPasswordReset.Ok):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_request_password_reset_200_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=200, media_type="application/json")
        if isinstance(__oapi_result, _contracts_RequestPasswordReset.UnprocessableEntity):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_request_password_reset_422_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=422, media_type="application/json")
        raise TypeError("requestPasswordReset returned an unsupported response variant")

    async def __oapi_endpoint_reset_password(__oapi_http: Request) -> Response:
        try:
            __oapi_bytes = await __oapi_http.body()
            if __oapi_bytes:
                _runtime_check_json_content_type(__oapi_http.headers.get("content-type"))
            __oapi_body = _runtime_json_body(
                __oapi_bytes, _reset_password_body_decoder, required=True
            )
        except _runtime_RequestError as __oapi_error:
            return _runtime_error_response(__oapi_error)
        __oapi_request = _contracts_ResetPassword.Request(body=__oapi_body)
        try:
            __oapi_result = await __oapi_handlers.auth.reset_password(__oapi_request)
        except (
            _contracts_ResetPassword.BadRequest,
            _contracts_ResetPassword.Unauthorized,
            _contracts_ResetPassword.UnprocessableEntity,
        ) as __oapi_error:
            __oapi_result = __oapi_error
        else:
            if isinstance(__oapi_result, Exception):
                raise TypeError("resetPassword error responses must be raised")
        if isinstance(__oapi_result, _contracts_ResetPassword.Ok):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_reset_password_200_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=200, media_type="application/json")
        if isinstance(__oapi_result, _contracts_ResetPassword.BadRequest):
            return Response(status_code=400)
        if isinstance(__oapi_result, _contracts_ResetPassword.Unauthorized):
            return Response(status_code=401)
        if isinstance(__oapi_result, _contracts_ResetPassword.UnprocessableEntity):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_reset_password_422_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=422, media_type="application/json")
        raise TypeError("resetPassword returned an unsupported response variant")

    async def __oapi_endpoint_refresh_token(__oapi_http: Request) -> Response:
        __oapi_request = _contracts_RefreshToken.Request()
        try:
            __oapi_result = await __oapi_handlers.auth.refresh_token(__oapi_request)
        except (
            _contracts_RefreshToken.Unauthorized,
            _contracts_RefreshToken.UnprocessableEntity,
        ) as __oapi_error:
            __oapi_result = __oapi_error
        else:
            if isinstance(__oapi_result, Exception):
                raise TypeError("refreshToken error responses must be raised")
        if isinstance(__oapi_result, _contracts_RefreshToken.Ok):
            __oapi_headers = MutableHeaders()
            __oapi_header = _refresh_token_200_header_0.decode(
                _encoder.encode(__oapi_result.set_cookie)
            )
            if __oapi_header is not None:
                if isinstance(__oapi_header, list):
                    for __oapi_cookie in __oapi_header:
                        __oapi_headers.append(
                            "Set-Cookie", _runtime_encode_header(to_builtins(__oapi_cookie))
                        )
                else:
                    __oapi_headers["Set-Cookie"] = _runtime_encode_header(
                        to_builtins(__oapi_header)
                    )
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_refresh_token_200_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(
                __oapi_content,
                status_code=200,
                media_type="application/json",
                headers=__oapi_headers,
            )
        if isinstance(__oapi_result, _contracts_RefreshToken.Unauthorized):
            return Response(status_code=401)
        if isinstance(__oapi_result, _contracts_RefreshToken.UnprocessableEntity):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_refresh_token_422_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=422, media_type="application/json")
        raise TypeError("refreshToken returned an unsupported response variant")

    async def __oapi_endpoint_list_users(__oapi_http: Request) -> Response:
        __oapi_security_context: object | None = None
        __oapi_security_satisfied = False
        __oapi_security_0 = __oapi_http.cookies.get("access_token") or None
        if not __oapi_security_satisfied and __oapi_security_0 is not None:
            try:
                __oapi_alternative_context = None
                __oapi_alternative_context = await __oapi_security.handle_bearer_auth(
                    __oapi_alternative_context,
                    "listUsers",
                    BearerAuthSecurity(
                        api_key=__oapi_security_0,
                        roles=(),
                    ),
                )
            except SecurityRejected:
                pass
            else:
                __oapi_security_context = __oapi_alternative_context
                __oapi_security_satisfied = True
        if not __oapi_security_satisfied:
            raise HTTPException(status_code=401, detail="security requirements are not satisfied")
        try:
            __oapi_parameter_0 = _runtime_parameter(
                __oapi_http.query_params.get("page"),
                _list_users_parameter_0,
                ("query", "page"),
                required=False,
                default=1,
            )
            __oapi_parameter_1 = _runtime_parameter(
                __oapi_http.query_params.get("page_size"),
                _list_users_parameter_1,
                ("query", "page_size"),
                required=False,
                default=20,
            )
        except _runtime_RequestError as __oapi_error:
            return _runtime_error_response(__oapi_error)
        __oapi_request = _contracts_ListUsers.Request(
            page=__oapi_parameter_0,
            page_size=__oapi_parameter_1,
            security_context=__oapi_security_context,
        )
        try:
            __oapi_result = await __oapi_handlers.admin.list_users(__oapi_request)
        except (
            _contracts_ListUsers.Unauthorized,
            _contracts_ListUsers.Forbidden,
            _contracts_ListUsers.UnprocessableEntity,
        ) as __oapi_error:
            __oapi_result = __oapi_error
        else:
            if isinstance(__oapi_result, Exception):
                raise TypeError("listUsers error responses must be raised")
        if isinstance(__oapi_result, _contracts_ListUsers.Ok):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_list_users_200_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=200, media_type="application/json")
        if isinstance(__oapi_result, _contracts_ListUsers.Unauthorized):
            return Response(status_code=401)
        if isinstance(__oapi_result, _contracts_ListUsers.Forbidden):
            return Response(status_code=403)
        if isinstance(__oapi_result, _contracts_ListUsers.UnprocessableEntity):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_list_users_422_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=422, media_type="application/json")
        raise TypeError("listUsers returned an unsupported response variant")

    async def __oapi_endpoint_create_user(__oapi_http: Request) -> Response:
        __oapi_security_context: object | None = None
        __oapi_security_satisfied = False
        __oapi_security_0 = __oapi_http.cookies.get("access_token") or None
        if not __oapi_security_satisfied and __oapi_security_0 is not None:
            try:
                __oapi_alternative_context = None
                __oapi_alternative_context = await __oapi_security.handle_bearer_auth(
                    __oapi_alternative_context,
                    "createUser",
                    BearerAuthSecurity(
                        api_key=__oapi_security_0,
                        roles=(),
                    ),
                )
            except SecurityRejected:
                pass
            else:
                __oapi_security_context = __oapi_alternative_context
                __oapi_security_satisfied = True
        if not __oapi_security_satisfied:
            raise HTTPException(status_code=401, detail="security requirements are not satisfied")
        try:
            __oapi_bytes = await __oapi_http.body()
            if __oapi_bytes:
                _runtime_check_json_content_type(__oapi_http.headers.get("content-type"))
            __oapi_body = _runtime_json_body(__oapi_bytes, _create_user_body_decoder, required=True)
        except _runtime_RequestError as __oapi_error:
            return _runtime_error_response(__oapi_error)
        __oapi_request = _contracts_CreateUser.Request(
            body=__oapi_body, security_context=__oapi_security_context
        )
        try:
            __oapi_result = await __oapi_handlers.admin.create_user(__oapi_request)
        except (
            _contracts_CreateUser.BadRequest,
            _contracts_CreateUser.Unauthorized,
            _contracts_CreateUser.Forbidden,
            _contracts_CreateUser.Conflict,
            _contracts_CreateUser.UnprocessableEntity,
        ) as __oapi_error:
            __oapi_result = __oapi_error
        else:
            if isinstance(__oapi_result, Exception):
                raise TypeError("createUser error responses must be raised")
        if isinstance(__oapi_result, _contracts_CreateUser.Created):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_create_user_201_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=201, media_type="application/json")
        if isinstance(__oapi_result, _contracts_CreateUser.BadRequest):
            return Response(status_code=400)
        if isinstance(__oapi_result, _contracts_CreateUser.Unauthorized):
            return Response(status_code=401)
        if isinstance(__oapi_result, _contracts_CreateUser.Forbidden):
            return Response(status_code=403)
        if isinstance(__oapi_result, _contracts_CreateUser.Conflict):
            return Response(status_code=409)
        if isinstance(__oapi_result, _contracts_CreateUser.UnprocessableEntity):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_create_user_422_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=422, media_type="application/json")
        raise TypeError("createUser returned an unsupported response variant")

    async def __oapi_endpoint_delete_user(__oapi_http: Request) -> Response:
        __oapi_security_context: object | None = None
        __oapi_security_satisfied = False
        __oapi_security_0 = __oapi_http.cookies.get("access_token") or None
        if not __oapi_security_satisfied and __oapi_security_0 is not None:
            try:
                __oapi_alternative_context = None
                __oapi_alternative_context = await __oapi_security.handle_bearer_auth(
                    __oapi_alternative_context,
                    "deleteUser",
                    BearerAuthSecurity(
                        api_key=__oapi_security_0,
                        roles=(),
                    ),
                )
            except SecurityRejected:
                pass
            else:
                __oapi_security_context = __oapi_alternative_context
                __oapi_security_satisfied = True
        if not __oapi_security_satisfied:
            raise HTTPException(status_code=401, detail="security requirements are not satisfied")
        try:
            __oapi_parameter_0 = _runtime_parameter(
                __oapi_http.path_params.get("user_id"),
                _delete_user_parameter_0,
                ("path", "user_id"),
                required=True,
                default=None,
            )
        except _runtime_RequestError as __oapi_error:
            return _runtime_error_response(__oapi_error)
        __oapi_request = _contracts_DeleteUser.Request(
            user_id=__oapi_parameter_0, security_context=__oapi_security_context
        )
        try:
            __oapi_result = await __oapi_handlers.admin.delete_user(__oapi_request)
        except (
            _contracts_DeleteUser.Unauthorized,
            _contracts_DeleteUser.Forbidden,
            _contracts_DeleteUser.NotFound,
            _contracts_DeleteUser.UnprocessableEntity,
        ) as __oapi_error:
            __oapi_result = __oapi_error
        else:
            if isinstance(__oapi_result, Exception):
                raise TypeError("deleteUser error responses must be raised")
        if isinstance(__oapi_result, _contracts_DeleteUser.NoContent):
            return Response(status_code=204)
        if isinstance(__oapi_result, _contracts_DeleteUser.Unauthorized):
            return Response(status_code=401)
        if isinstance(__oapi_result, _contracts_DeleteUser.Forbidden):
            return Response(status_code=403)
        if isinstance(__oapi_result, _contracts_DeleteUser.NotFound):
            return Response(status_code=404)
        if isinstance(__oapi_result, _contracts_DeleteUser.UnprocessableEntity):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_delete_user_422_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=422, media_type="application/json")
        raise TypeError("deleteUser returned an unsupported response variant")

    async def __oapi_endpoint_get_user(__oapi_http: Request) -> Response:
        __oapi_security_context: object | None = None
        __oapi_security_satisfied = False
        __oapi_security_0 = __oapi_http.cookies.get("access_token") or None
        if not __oapi_security_satisfied and __oapi_security_0 is not None:
            try:
                __oapi_alternative_context = None
                __oapi_alternative_context = await __oapi_security.handle_bearer_auth(
                    __oapi_alternative_context,
                    "getUser",
                    BearerAuthSecurity(
                        api_key=__oapi_security_0,
                        roles=(),
                    ),
                )
            except SecurityRejected:
                pass
            else:
                __oapi_security_context = __oapi_alternative_context
                __oapi_security_satisfied = True
        if not __oapi_security_satisfied:
            raise HTTPException(status_code=401, detail="security requirements are not satisfied")
        try:
            __oapi_parameter_0 = _runtime_parameter(
                __oapi_http.path_params.get("user_id"),
                _get_user_parameter_0,
                ("path", "user_id"),
                required=True,
                default=None,
            )
        except _runtime_RequestError as __oapi_error:
            return _runtime_error_response(__oapi_error)
        __oapi_request = _contracts_GetUser.Request(
            user_id=__oapi_parameter_0, security_context=__oapi_security_context
        )
        try:
            __oapi_result = await __oapi_handlers.admin.get_user(__oapi_request)
        except (
            _contracts_GetUser.Unauthorized,
            _contracts_GetUser.Forbidden,
            _contracts_GetUser.NotFound,
            _contracts_GetUser.UnprocessableEntity,
        ) as __oapi_error:
            __oapi_result = __oapi_error
        else:
            if isinstance(__oapi_result, Exception):
                raise TypeError("getUser error responses must be raised")
        if isinstance(__oapi_result, _contracts_GetUser.Ok):
            __oapi_body = convert(to_builtins(__oapi_result.body), type=_get_user_200_decoder.type)
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=200, media_type="application/json")
        if isinstance(__oapi_result, _contracts_GetUser.Unauthorized):
            return Response(status_code=401)
        if isinstance(__oapi_result, _contracts_GetUser.Forbidden):
            return Response(status_code=403)
        if isinstance(__oapi_result, _contracts_GetUser.NotFound):
            return Response(status_code=404)
        if isinstance(__oapi_result, _contracts_GetUser.UnprocessableEntity):
            __oapi_body = convert(to_builtins(__oapi_result.body), type=_get_user_422_decoder.type)
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=422, media_type="application/json")
        raise TypeError("getUser returned an unsupported response variant")

    async def __oapi_endpoint_update_user(__oapi_http: Request) -> Response:
        __oapi_security_context: object | None = None
        __oapi_security_satisfied = False
        __oapi_security_0 = __oapi_http.cookies.get("access_token") or None
        if not __oapi_security_satisfied and __oapi_security_0 is not None:
            try:
                __oapi_alternative_context = None
                __oapi_alternative_context = await __oapi_security.handle_bearer_auth(
                    __oapi_alternative_context,
                    "updateUser",
                    BearerAuthSecurity(
                        api_key=__oapi_security_0,
                        roles=(),
                    ),
                )
            except SecurityRejected:
                pass
            else:
                __oapi_security_context = __oapi_alternative_context
                __oapi_security_satisfied = True
        if not __oapi_security_satisfied:
            raise HTTPException(status_code=401, detail="security requirements are not satisfied")
        try:
            __oapi_parameter_0 = _runtime_parameter(
                __oapi_http.path_params.get("user_id"),
                _update_user_parameter_0,
                ("path", "user_id"),
                required=True,
                default=None,
            )
            __oapi_bytes = await __oapi_http.body()
            if __oapi_bytes:
                _runtime_check_json_content_type(__oapi_http.headers.get("content-type"))
            __oapi_body = _runtime_json_body(
                __oapi_bytes,
                _update_user_body_decoder,
                required=True,
                property_counts=_update_user_body_properties,
            )
        except _runtime_RequestError as __oapi_error:
            return _runtime_error_response(__oapi_error)
        __oapi_request = _contracts_UpdateUser.Request(
            user_id=__oapi_parameter_0, body=__oapi_body, security_context=__oapi_security_context
        )
        try:
            __oapi_result = await __oapi_handlers.admin.update_user(__oapi_request)
        except (
            _contracts_UpdateUser.Unauthorized,
            _contracts_UpdateUser.Forbidden,
            _contracts_UpdateUser.NotFound,
            _contracts_UpdateUser.UnprocessableEntity,
        ) as __oapi_error:
            __oapi_result = __oapi_error
        else:
            if isinstance(__oapi_result, Exception):
                raise TypeError("updateUser error responses must be raised")
        if isinstance(__oapi_result, _contracts_UpdateUser.Ok):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_update_user_200_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=200, media_type="application/json")
        if isinstance(__oapi_result, _contracts_UpdateUser.Unauthorized):
            return Response(status_code=401)
        if isinstance(__oapi_result, _contracts_UpdateUser.Forbidden):
            return Response(status_code=403)
        if isinstance(__oapi_result, _contracts_UpdateUser.NotFound):
            return Response(status_code=404)
        if isinstance(__oapi_result, _contracts_UpdateUser.UnprocessableEntity):
            __oapi_body = convert(
                to_builtins(__oapi_result.body), type=_update_user_422_decoder.type
            )
            __oapi_content = _encoder.encode(__oapi_body)
            return Response(__oapi_content, status_code=422, media_type="application/json")
        raise TypeError("updateUser returned an unsupported response variant")

    __oapi_routes = [
        Route(prefix + "/auth/login", __oapi_endpoint_login, methods=["POST"], name="login"),
        Route(prefix + "/auth/logout", __oapi_endpoint_logout, methods=["POST"], name="logout"),
        Route(
            prefix + "/auth/me",
            __oapi_endpoint_get_current_user,
            methods=["GET"],
            name="getCurrentUser",
        ),
        Route(
            prefix + "/auth/password",
            __oapi_endpoint_update_password,
            methods=["PUT"],
            name="updatePassword",
        ),
        Route(
            prefix + "/auth/password/recover",
            __oapi_endpoint_request_password_reset,
            methods=["POST"],
            name="requestPasswordReset",
        ),
        Route(
            prefix + "/auth/password/reset",
            __oapi_endpoint_reset_password,
            methods=["POST"],
            name="resetPassword",
        ),
        Route(
            prefix + "/auth/refresh",
            __oapi_endpoint_refresh_token,
            methods=["POST"],
            name="refreshToken",
        ),
        Route(prefix + "/users", __oapi_endpoint_list_users, methods=["GET"], name="listUsers"),
        Route(prefix + "/users", __oapi_endpoint_create_user, methods=["POST"], name="createUser"),
        Route(
            prefix + "/users/{user_id}",
            __oapi_endpoint_delete_user,
            methods=["DELETE"],
            name="deleteUser",
        ),
        Route(
            prefix + "/users/{user_id}", __oapi_endpoint_get_user, methods=["GET"], name="getUser"
        ),
        Route(
            prefix + "/users/{user_id}",
            __oapi_endpoint_update_user,
            methods=["PATCH"],
            name="updateUser",
        ),
    ]
    __oapi_routes[2].methods = {"GET"}
    __oapi_routes[7].methods = {"GET"}
    __oapi_routes[10].methods = {"GET"}
    if include_schema:
        __oapi_schema = json.decode(Path(__file__).with_name("openapi.json").read_bytes())
        __oapi_schema["paths"] = {
            prefix + path: item for path, item in __oapi_schema["paths"].items()
        }
        __oapi_schema_bytes = _encoder.encode(__oapi_schema)

        async def __oapi_openapi(request: Request) -> Response:
            return Response(__oapi_schema_bytes, media_type="application/json")

        __oapi_routes.append(Route(prefix + "/openapi.json", __oapi_openapi))
    return Router(routes=__oapi_routes)
