# 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 . import _runtime
from . import contracts as _contracts
from . import models as _models
from .contracts import (
    BearerAuthSecurity,
    Handlers,
    SecurityHandler,
    SecurityRejected,
)

_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)
