@tinyrack/issuary-server 0.20.0

package/dist/routes/index.d.ts

@@ -0,0 +1,1591 @@
+import type { AppEnv } from '../lib/app-env.ts';
+export declare const routes: import("hono/hono-base").HonoBase<AppEnv, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/admin/me": {
+        $get: {
+            input: {};
+            output: {
+                user: {
+                    managed_by: "database" | "config";
+                    sub: string;
+                    email: string;
+                    role: "user" | "admin";
+                    email_verified: boolean;
+                    email_verification_required: boolean;
+                    has_password: boolean;
+                    totp_registered: boolean;
+                    totp_recovery_codes_missing: boolean;
+                    second_factor_required: boolean;
+                    passkey_count: number;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/admin/users": {
+        $get: {
+            input: {
+                query: {
+                    query?: string | undefined;
+                    page?: string | string[];
+                    page_size?: string | string[];
+                    include_deleted?: string | string[];
+                    managed_by?: "database" | "config" | undefined;
+                    role?: "user" | "admin" | undefined;
+                };
+            };
+            output: {
+                users: {
+                    managed_by: "database" | "config";
+                    sub: string;
+                    email: string;
+                    role: "user" | "admin";
+                    email_verified: boolean;
+                    email_verification_required: boolean;
+                    has_password: boolean;
+                    totp_registered: boolean;
+                    totp_recovery_codes_missing: boolean;
+                    second_factor_required: boolean;
+                    passkey_count: number;
+                    deleted_at: string | null;
+                }[];
+                pagination: {
+                    page: number;
+                    page_size: number;
+                    total: number;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/admin/users": {
+        $post: {
+            input: {
+                json: {
+                    email: string;
+                    password: string;
+                    role?: "user" | "admin" | undefined;
+                    email_verified?: boolean | undefined;
+                };
+            };
+            output: {
+                user: {
+                    managed_by: "database" | "config";
+                    sub: string;
+                    email: string;
+                    role: "user" | "admin";
+                    email_verified: boolean;
+                    email_verification_required: boolean;
+                    has_password: boolean;
+                    totp_registered: boolean;
+                    totp_recovery_codes_missing: boolean;
+                    second_factor_required: boolean;
+                    passkey_count: number;
+                    deleted_at: string | null;
+                };
+            };
+            outputFormat: "json";
+            status: 201;
+        };
+    };
+} & {
+    "/admin/users/:sub": {
+        $get: {
+            input: {
+                param: {
+                    sub: string;
+                };
+            };
+            output: {
+                user: {
+                    managed_by: "database" | "config";
+                    sub: string;
+                    email: string;
+                    role: "user" | "admin";
+                    email_verified: boolean;
+                    email_verification_required: boolean;
+                    has_password: boolean;
+                    totp_registered: boolean;
+                    totp_recovery_codes_missing: boolean;
+                    second_factor_required: boolean;
+                    passkey_count: number;
+                    deleted_at: string | null;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/admin/users/:sub": {
+        $patch: {
+            input: {
+                json: {
+                    email?: string | undefined;
+                    role?: "user" | "admin" | undefined;
+                    email_verified?: boolean | undefined;
+                };
+            } & {
+                param: {
+                    sub: string;
+                };
+            };
+            output: {
+                user: {
+                    managed_by: "database" | "config";
+                    sub: string;
+                    email: string;
+                    role: "user" | "admin";
+                    email_verified: boolean;
+                    email_verification_required: boolean;
+                    has_password: boolean;
+                    totp_registered: boolean;
+                    totp_recovery_codes_missing: boolean;
+                    second_factor_required: boolean;
+                    passkey_count: number;
+                    deleted_at: string | null;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/admin/users/:sub": {
+        $delete: {
+            input: {
+                param: {
+                    sub: string;
+                };
+            };
+            output: {
+                user: {
+                    managed_by: "database" | "config";
+                    sub: string;
+                    email: string;
+                    role: "user" | "admin";
+                    email_verified: boolean;
+                    email_verification_required: boolean;
+                    has_password: boolean;
+                    totp_registered: boolean;
+                    totp_recovery_codes_missing: boolean;
+                    second_factor_required: boolean;
+                    passkey_count: number;
+                    deleted_at: string | null;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/auth/accounts": {
+        $get: {
+            input: {
+                query: {
+                    client_id?: string | undefined;
+                };
+            };
+            output: {
+                active_sub: string | null;
+                accounts: {
+                    sub: import("@mikro-orm/core").Opt<string>;
+                    email: string;
+                    role: import("@mikro-orm/core").Opt<NonNullable<"user" | "admin">>;
+                    current: boolean;
+                    authenticated_at: number;
+                    last_used_at: number;
+                }[];
+                allow_add_account: boolean;
+                allow_remove_account: boolean;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/auth/accounts/select": {
+        $post: {
+            input: {
+                json: {
+                    sub: string;
+                };
+            };
+            output: {
+                code: string;
+                message: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {
+                json: {
+                    sub: string;
+                };
+            };
+            output: {
+                ok: true;
+                active_sub: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/auth/accounts/remove": {
+        $post: {
+            input: {
+                json: {
+                    sub: string;
+                };
+            };
+            output: {
+                code: string;
+                message: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {
+                json: {
+                    sub: string;
+                };
+            };
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/auth/2fa/methods": {
+        $get: {
+            input: {};
+            output: {
+                methods: ("totp" | "passkey")[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/auth/login": {
+        $post: {
+            input: {
+                json: {
+                    email: string;
+                    password: string;
+                };
+            };
+            output: {
+                user: {
+                    managed_by: "database" | "config";
+                    sub: string;
+                    email: string;
+                    role: "user" | "admin";
+                    email_verified: boolean;
+                    email_verification_required: boolean;
+                    has_password: boolean;
+                    totp_registered: boolean;
+                    totp_recovery_codes_missing: boolean;
+                    second_factor_required: boolean;
+                    passkey_count: number;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/auth/logout": {
+        $post: {
+            input: {};
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/auth/register": {
+        $post: {
+            input: {
+                header: {
+                    'accept-language'?: string | undefined;
+                };
+            } & {
+                json: {
+                    email: string;
+                    password: string;
+                    consents?: {
+                        termsId: string;
+                        agreed: boolean;
+                        consentType?: "explicit" | "implicit" | undefined;
+                    }[] | undefined;
+                };
+            };
+            output: {
+                user: {
+                    managed_by: "database" | "config";
+                    sub: string;
+                    email: string;
+                    role: "user" | "admin";
+                    email_verified: boolean;
+                    email_verification_required: boolean;
+                    has_password: boolean;
+                    totp_registered: boolean;
+                    totp_recovery_codes_missing: boolean;
+                    second_factor_required: boolean;
+                    passkey_count: number;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/auth/password/forgot": {
+        $post: {
+            input: {
+                header: {
+                    'accept-language'?: string | undefined;
+                };
+            } & {
+                json: {
+                    email: string;
+                };
+            };
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/auth/password/reset": {
+        $post: {
+            input: {
+                json: {
+                    token: string;
+                    password: string;
+                };
+            };
+            output: {
+                message: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/auth/email/verify": {
+        $post: {
+            input: {
+                json: {
+                    token: string;
+                };
+            };
+            output: {
+                user: {
+                    managed_by: "database" | "config";
+                    sub: string;
+                    email: string;
+                    role: "user" | "admin";
+                    email_verified: boolean;
+                    email_verification_required: boolean;
+                    has_password: boolean;
+                    totp_registered: boolean;
+                    totp_recovery_codes_missing: boolean;
+                    second_factor_required: boolean;
+                    passkey_count: number;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/auth/email/resend": {
+        $post: {
+            input: {
+                header: {
+                    'accept-language'?: string | undefined;
+                };
+            } & {
+                json: {
+                    email: string;
+                };
+            };
+            output: {
+                message: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/auth/totp/verify": {
+        $post: {
+            input: {
+                json: {
+                    code: string;
+                };
+            };
+            output: {
+                user: {
+                    managed_by: "database" | "config";
+                    sub: string;
+                    email: string;
+                    role: "user" | "admin";
+                    email_verified: boolean;
+                    email_verification_required: boolean;
+                    has_password: boolean;
+                    totp_registered: boolean;
+                    totp_recovery_codes_missing: boolean;
+                    second_factor_required: boolean;
+                    passkey_count: number;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/auth/totp/recovery/verify": {
+        $post: {
+            input: {
+                json: {
+                    code: string;
+                };
+            };
+            output: {
+                user: {
+                    managed_by: "database" | "config";
+                    sub: string;
+                    email: string;
+                    role: "user" | "admin";
+                    email_verified: boolean;
+                    email_verification_required: boolean;
+                    has_password: boolean;
+                    totp_registered: boolean;
+                    totp_recovery_codes_missing: boolean;
+                    second_factor_required: boolean;
+                    passkey_count: number;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/auth/passkey/options": {
+        $post: {
+            input: {};
+            output: {
+                options: {
+                    challenge: import("@simplewebauthn/server").Base64URLString;
+                    timeout?: number | undefined;
+                    rpId?: string | undefined;
+                    allowCredentials?: {
+                        id: import("@simplewebauthn/server").Base64URLString;
+                        type: import("@simplewebauthn/server").PublicKeyCredentialType;
+                        transports?: import("@simplewebauthn/server").AuthenticatorTransportFuture[] | undefined;
+                    }[] | undefined;
+                    userVerification?: import("@simplewebauthn/server").UserVerificationRequirement | undefined;
+                    hints?: import("@simplewebauthn/server").PublicKeyCredentialHint[] | undefined;
+                    extensions?: {
+                        appid?: string | undefined;
+                        credProps?: boolean | undefined;
+                        hmacCreateSecret?: boolean | undefined;
+                        minPinLength?: boolean | undefined;
+                    } | undefined;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/auth/passkey/verify": {
+        $post: {
+            input: {
+                json: {
+                    response: {
+                        id: string;
+                        rawId: string;
+                        response: {
+                            clientDataJSON: string;
+                            authenticatorData: string;
+                            signature: string;
+                            userHandle?: string | undefined;
+                        };
+                        clientExtensionResults: Record<string, unknown>;
+                        type: "public-key";
+                        authenticatorAttachment?: "platform" | "cross-platform" | undefined;
+                    };
+                };
+            };
+            output: {
+                user: {
+                    managed_by: "database" | "config";
+                    sub: string;
+                    email: string;
+                    role: "user" | "admin";
+                    email_verified: boolean;
+                    email_verification_required: boolean;
+                    has_password: boolean;
+                    totp_registered: boolean;
+                    totp_recovery_codes_missing: boolean;
+                    second_factor_required: boolean;
+                    passkey_count: number;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/config": {
+        $get: {
+            input: {};
+            output: {
+                i18n: {
+                    supported_languages: string[];
+                    default_language: string;
+                    fallback_language: string;
+                };
+                branding: {
+                    background_url?: string | undefined;
+                    icon_url?: string | undefined;
+                    title?: {
+                        [x: string]: string;
+                    } | undefined;
+                    subtitle?: {
+                        [x: string]: string;
+                    } | undefined;
+                };
+                registration: {
+                    public_registration: boolean;
+                    email_pattern_filter_enabled: boolean;
+                    email_verification_required: boolean;
+                    signup_notice?: {
+                        [x: string]: string;
+                    } | undefined;
+                };
+                database: {
+                    enabled: boolean;
+                };
+                email: {
+                    enabled: boolean;
+                };
+                admin: {
+                    enabled: boolean;
+                };
+                auth: {
+                    password: {
+                        enabled: boolean;
+                        two_factor: {
+                            enrollment_required: boolean;
+                        };
+                        totp: {
+                            enabled: boolean;
+                            issuer: string;
+                        };
+                        policy: {
+                            min_length: number;
+                            max_length: number;
+                        };
+                    };
+                    passkey: {
+                        enabled: boolean;
+                        rp_id?: string | undefined;
+                        origins?: string[] | undefined;
+                    };
+                };
+                identity_providers: {
+                    id: string;
+                    type: "github" | "google" | "apple" | "generic_oauth";
+                    display_name: string;
+                    icon_url?: string | undefined;
+                }[];
+                account_deletion: {
+                    enabled: boolean;
+                    retention: string;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/consent": {
+        $get: {
+            input: {
+                query: {
+                    client_id: string | string[];
+                    scope?: string | undefined;
+                };
+            };
+            output: {
+                client: {
+                    id: string;
+                    clientId: string;
+                    name: string;
+                };
+                scopes: {
+                    name: string;
+                    description: string;
+                }[];
+                user: {
+                    sub: import("@mikro-orm/core").Opt<string>;
+                    email: string;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/consent": {
+        $post: {
+            input: {
+                json: {
+                    client_id: string;
+                    redirect_uri: string;
+                    response_type: string;
+                    decision: "allow" | "deny";
+                    scope?: string | undefined;
+                    state?: string | undefined;
+                    nonce?: string | undefined;
+                    code_challenge?: string | undefined;
+                    code_challenge_method?: "S256" | "plain" | undefined;
+                    prompt?: string | undefined;
+                    max_age?: unknown;
+                    reauthenticated?: "1" | undefined;
+                    display?: "page" | "popup" | "touch" | "wap" | undefined;
+                    response_mode?: "query" | "fragment" | "form_post" | undefined;
+                    login_hint?: string | undefined;
+                    ui_locales?: string | undefined;
+                    id_token_hint?: string | undefined;
+                    acr_values?: string | undefined;
+                    account_selected?: unknown;
+                    account_selection_state?: string | undefined;
+                };
+            };
+            output: {
+                redirect_url: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/health": {
+        $get: {
+            input: {};
+            output: {
+                status: "ok";
+                uptime: number;
+                checks: {
+                    database: "ok";
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        } | {
+            input: {};
+            output: {
+                status: "error";
+                uptime: number;
+                checks: {
+                    database: "error";
+                };
+                error: string | undefined;
+            };
+            outputFormat: "json";
+            status: 503;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/health/ready": {
+        $get: {
+            input: {};
+            output: {
+                status: "ok";
+                checks: {
+                    database: "ok";
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        } | {
+            input: {};
+            output: {
+                status: "error";
+                checks: {
+                    database: "error";
+                };
+                error: string | undefined;
+            };
+            outputFormat: "json";
+            status: 503;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/health/live": {
+        $get: {
+            input: {};
+            output: {
+                status: "ok";
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/docs": {
+        $get: {
+            input: {};
+            output: {};
+            outputFormat: string;
+            status: import("hono/utils/http-status").StatusCode;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/terms": {
+        $get: {
+            input: {
+                query: {
+                    lang?: string | undefined;
+                };
+            };
+            output: {
+                terms: {
+                    userConsent: {
+                        agreedAt: string | null;
+                        agreed: boolean;
+                        agreedVersion: string | null;
+                        consentType: "explicit" | "implicit" | null;
+                        requiresUpdate: boolean;
+                    } | null;
+                    id: string;
+                    required: boolean;
+                    consentMode: "explicit" | "implicit";
+                    version: string;
+                    title: string;
+                    type: import("../services/terms.service.ts").TermsContentType;
+                    content: string;
+                }[];
+                pendingTerms: string[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/terms/consent": {
+        $post: {
+            input: {
+                json: {
+                    consents: {
+                        termsId: string;
+                        agreed: boolean;
+                        consentType?: "explicit" | "implicit" | undefined;
+                    }[];
+                    registrationToken?: string | undefined;
+                };
+            };
+            output: {
+                ok: true;
+                recorded: number;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/user": {
+        $delete: {
+            input: {};
+            output: {
+                ok: true;
+                deleted_at: string;
+                permanent_deletion_at: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/user/session": {
+        $get: {
+            input: {};
+            output: {
+                user: null;
+            };
+            outputFormat: "json";
+            status: 200;
+        } | {
+            input: {};
+            output: {
+                user: {
+                    managed_by: "database" | "config";
+                    sub: string;
+                    email: string;
+                    role: "user" | "admin";
+                    email_verified: boolean;
+                    email_verification_required: boolean;
+                    has_password: boolean;
+                    totp_registered: boolean;
+                    totp_recovery_codes_missing: boolean;
+                    second_factor_required: boolean;
+                    passkey_count: number;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/user/password": {
+        $post: {
+            input: {
+                json: {
+                    password: string;
+                };
+            };
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/user/password": {
+        $put: {
+            input: {
+                json: {
+                    current_password: string;
+                    new_password: string;
+                };
+            };
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/user/password": {
+        $delete: {
+            input: {
+                json: {
+                    current_password: string;
+                };
+            };
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/user/oauth-accounts": {
+        $get: {
+            input: {};
+            output: {
+                accounts: {
+                    provider_name: string;
+                    linked_at: string;
+                }[];
+                available_providers: {
+                    id: string;
+                    display_name: string;
+                    icon_url: string | undefined;
+                    linked: boolean;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/user/totp/setup": {
+        $post: {
+            input: {};
+            output: {
+                secret: string;
+                otpauth_url: string;
+                qr_code: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/user/totp/verify": {
+        $post: {
+            input: {
+                json: {
+                    code: string;
+                };
+            };
+            output: {
+                recovery_codes: string[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/user/totp/confirm": {
+        $post: {
+            input: {
+                json?: Record<string, never> | null | undefined;
+            };
+            output: {
+                user: {
+                    managed_by: "database" | "config";
+                    sub: string;
+                    email: string;
+                    role: "user" | "admin";
+                    email_verified: boolean;
+                    email_verification_required: boolean;
+                    has_password: boolean;
+                    totp_registered: boolean;
+                    totp_recovery_codes_missing: boolean;
+                    second_factor_required: boolean;
+                    passkey_count: number;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/user/totp/recovery/regenerate": {
+        $post: {
+            input: {
+                json: {
+                    code: string;
+                };
+            };
+            output: {
+                recovery_codes: string[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/user/totp": {
+        $delete: {
+            input: {
+                json: {
+                    code: string;
+                };
+            };
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/user/passkeys": {
+        $get: {
+            input: {};
+            output: {
+                passkeys: {
+                    id: string;
+                    credential_id: string;
+                    name: string | null;
+                    device_type: "singleDevice" | "multiDevice";
+                    backed_up: boolean;
+                    created_at: string;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/user/passkeys/:id": {
+        $delete: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/user/passkeys/:id": {
+        $patch: {
+            input: {
+                param: {
+                    id: string;
+                };
+            } & {
+                json: {
+                    name: string;
+                };
+            };
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/user/passkeys/register/options": {
+        $post: {
+            input: {};
+            output: {
+                options: {
+                    rp: {
+                        id?: string | undefined;
+                        name: string;
+                    };
+                    user: {
+                        id: string;
+                        name: string;
+                        displayName: string;
+                    };
+                    challenge: import("@simplewebauthn/server").Base64URLString;
+                    pubKeyCredParams: {
+                        alg: import("@simplewebauthn/server").COSEAlgorithmIdentifier;
+                        type: import("@simplewebauthn/server").PublicKeyCredentialType;
+                    }[];
+                    timeout?: number | undefined;
+                    excludeCredentials?: {
+                        id: import("@simplewebauthn/server").Base64URLString;
+                        type: import("@simplewebauthn/server").PublicKeyCredentialType;
+                        transports?: import("@simplewebauthn/server").AuthenticatorTransportFuture[] | undefined;
+                    }[] | undefined;
+                    authenticatorSelection?: {
+                        authenticatorAttachment?: import("@simplewebauthn/server").AuthenticatorAttachment | undefined;
+                        requireResidentKey?: boolean | undefined;
+                        residentKey?: import("@simplewebauthn/server").ResidentKeyRequirement | undefined;
+                        userVerification?: import("@simplewebauthn/server").UserVerificationRequirement | undefined;
+                    } | undefined;
+                    hints?: import("@simplewebauthn/server").PublicKeyCredentialHint[] | undefined;
+                    attestation?: import("@simplewebauthn/server").AttestationConveyancePreference | undefined;
+                    attestationFormats?: import("@simplewebauthn/server").AttestationFormat[] | undefined;
+                    extensions?: {
+                        appid?: string | undefined;
+                        credProps?: boolean | undefined;
+                        hmacCreateSecret?: boolean | undefined;
+                        minPinLength?: boolean | undefined;
+                    } | undefined;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/user/passkeys/register/verify": {
+        $post: {
+            input: {
+                json: {
+                    response: Record<string, any>;
+                    name?: string | undefined;
+                };
+            };
+            output: {
+                ok: true;
+                user: {
+                    managed_by: "database" | "config";
+                    sub: string;
+                    email: string;
+                    role: "user" | "admin";
+                    email_verified: boolean;
+                    email_verification_required: boolean;
+                    has_password: boolean;
+                    totp_registered: boolean;
+                    totp_recovery_codes_missing: boolean;
+                    second_factor_required: boolean;
+                    passkey_count: number;
+                };
+                second_factor_setup_completed: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        } | {
+            input: {
+                json: {
+                    response: Record<string, any>;
+                    name?: string | undefined;
+                };
+            };
+            output: {
+                ok: true;
+                second_factor_setup_completed: false;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/oauth/authorization-context": {
+        $get: {
+            input: {
+                query: {
+                    client_id: string | string[];
+                    redirect_uri: string | string[];
+                    response_type: string | string[];
+                    scope?: string | undefined;
+                };
+            };
+            output: {
+                client: {
+                    id: string;
+                    clientId: string;
+                    name: string;
+                };
+                redirect_uri: string;
+                redirect_origin: string;
+                scopes: {
+                    name: string;
+                    description: string;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/oauth/:provider/authorize": {
+        $get: {
+            input: {
+                param: {
+                    provider: string;
+                };
+            } & {
+                query: {
+                    mode?: "link" | "register" | "login" | undefined;
+                    return_url?: string | undefined;
+                };
+            };
+            output: undefined;
+            outputFormat: "redirect";
+            status: 302;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/oauth/:provider/callback": {
+        $get: {
+            input: {
+                param: {
+                    provider: string;
+                };
+            } & {
+                query: {
+                    code?: string | undefined;
+                    state?: string | undefined;
+                    error?: string | undefined;
+                    error_description?: string | undefined;
+                };
+            };
+            output: undefined;
+            outputFormat: "redirect";
+            status: 302;
+        } | {
+            input: {
+                param: {
+                    provider: string;
+                };
+            } & {
+                query: {
+                    code?: string | undefined;
+                    state?: string | undefined;
+                    error?: string | undefined;
+                    error_description?: string | undefined;
+                };
+            };
+            output: {
+                code: any;
+                message: any;
+            };
+            outputFormat: "json";
+            status: any;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/oauth/:provider/callback": {
+        $post: {
+            input: {
+                param: {
+                    provider: string;
+                };
+            } & {
+                form: {
+                    code?: string | undefined;
+                    state?: string | undefined;
+                    error?: string | undefined;
+                    error_description?: string | undefined;
+                };
+            };
+            output: undefined;
+            outputFormat: "redirect";
+            status: 302;
+        } | {
+            input: {
+                param: {
+                    provider: string;
+                };
+            } & {
+                form: {
+                    code?: string | undefined;
+                    state?: string | undefined;
+                    error?: string | undefined;
+                    error_description?: string | undefined;
+                };
+            };
+            output: {
+                code: any;
+                message: any;
+            };
+            outputFormat: "json";
+            status: any;
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/oauth/:provider": {
+        $delete: {
+            input: {
+                param: {
+                    provider: string;
+                };
+            };
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/">, "/api"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/authorize": {
+        $get: {
+            input: {
+                query: {
+                    response_type: string | string[];
+                    redirect_uri: string | string[];
+                    client_id: string | string[];
+                    state?: string | undefined;
+                    code_challenge?: string | undefined;
+                    code_challenge_method?: "S256" | "plain" | undefined;
+                    scope?: string | undefined;
+                    nonce?: string | undefined;
+                    prompt?: string | undefined;
+                    max_age?: string | string[];
+                    reauthenticated?: string | string[];
+                    account_selected?: string | string[];
+                    account_selection_state?: string | undefined;
+                    display?: "page" | "popup" | "touch" | "wap" | undefined;
+                    response_mode?: string | undefined;
+                    login_hint?: string | undefined;
+                    ui_locales?: string | undefined;
+                    id_token_hint?: string | undefined;
+                    acr_values?: string | undefined;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: import("hono/utils/http-status").StatusCode;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/device_authorization": {
+        $post: {
+            input: {
+                form: {
+                    client_id?: string | undefined;
+                    client_secret?: string | undefined;
+                    scope?: string | undefined;
+                };
+            };
+            output: {
+                device_code: string;
+                user_code: string;
+                verification_uri: string;
+                verification_uri_complete: string;
+                expires_in: number;
+                interval: number;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/device": {
+        $get: {
+            input: {};
+            output: {};
+            outputFormat: string;
+            status: import("hono/utils/http-status").StatusCode;
+        };
+    };
+} & {
+    "/device": {
+        $post: {
+            input: {
+                form: {
+                    user_code: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                    decision?: "deny" | "approve" | undefined;
+                };
+            };
+            output: {
+                status: string;
+                client_id: string;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/end_session": {
+        $get: {
+            input: {
+                query: {
+                    client_id?: string | undefined;
+                    post_logout_redirect_uri?: string | undefined;
+                    id_token_hint?: string | undefined;
+                    state?: string | undefined;
+                };
+            };
+            output: undefined;
+            outputFormat: "redirect";
+            status: 302;
+        } | {
+            input: {
+                query: {
+                    client_id?: string | undefined;
+                    post_logout_redirect_uri?: string | undefined;
+                    id_token_hint?: string | undefined;
+                    state?: string | undefined;
+                };
+            };
+            output: {
+                error: string;
+                error_description: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/token": {
+        $post: {
+            input: {
+                form: {
+                    grant_type?: string | undefined;
+                    code?: string | undefined;
+                    redirect_uri?: string | undefined;
+                    client_id?: string | undefined;
+                    client_secret?: string | undefined;
+                    code_verifier?: string | undefined;
+                    refresh_token?: string | undefined;
+                    scope?: string | undefined;
+                    device_code?: string | undefined;
+                };
+            };
+            output: {
+                access_token: string;
+                token_type: "Bearer";
+                expires_in: number;
+                refresh_token?: string | undefined | undefined;
+                id_token?: string | undefined | undefined;
+                scope: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/introspect": {
+        $post: {
+            input: {
+                form: {
+                    token: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                    token_type_hint?: string | undefined;
+                    client_id?: string | undefined;
+                    client_secret?: string | undefined;
+                };
+            };
+            output: {
+                active: boolean;
+                scope?: string | undefined | undefined;
+                client_id?: string | undefined | undefined;
+                token_type?: "Bearer" | undefined | undefined;
+                exp?: number | undefined | undefined;
+                iat?: number | undefined | undefined;
+                sub?: string | undefined | undefined;
+                iss?: string | undefined | undefined;
+                aud?: string | undefined | undefined;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/revoke": {
+        $post: {
+            input: {
+                form: {
+                    token: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                    token_type_hint?: string | undefined;
+                    client_id?: string | undefined;
+                    client_secret?: string | undefined;
+                };
+            };
+            output: {};
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/userinfo": {
+        $get: {
+            input: {};
+            output: {
+                sub: string;
+                email?: string | undefined;
+                email_verified?: boolean | undefined;
+                name?: string | undefined;
+                picture?: string | undefined;
+                preferred_username?: string | undefined;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/userinfo": {
+        $post: {
+            input: {};
+            output: {
+                sub: string;
+                email?: string | undefined;
+                email_verified?: boolean | undefined;
+                name?: string | undefined;
+                picture?: string | undefined;
+                preferred_username?: string | undefined;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/.well-known/jwks": {
+        $get: {
+            input: {};
+            output: {
+                keys: {
+                    kty: string;
+                    use: string;
+                    kid: string;
+                    alg: string;
+                    n?: string | undefined | undefined;
+                    e?: string | undefined | undefined;
+                    x?: string | undefined | undefined;
+                    y?: string | undefined | undefined;
+                    crv?: string | undefined | undefined;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/.well-known/openid-configuration": {
+        $get: {
+            input: {};
+            output: {
+                issuer: string;
+                authorization_endpoint: string;
+                token_endpoint: string;
+                jwks_uri: string;
+                response_types_supported: string[];
+                response_modes_supported: string[];
+                subject_types_supported: string[];
+                id_token_signing_alg_values_supported: string[];
+                userinfo_signing_alg_values_supported: string[];
+                userinfo_endpoint: string;
+                scopes_supported: string[];
+                claims_supported: string[];
+                prompt_values_supported: string[];
+                grant_types_supported: string[];
+                token_endpoint_auth_methods_supported: string[];
+                introspection_endpoint_auth_methods_supported: string[];
+                revocation_endpoint_auth_methods_supported: string[];
+                code_challenge_methods_supported: string[];
+                introspection_endpoint: string;
+                revocation_endpoint: string;
+                end_session_endpoint: string;
+                device_authorization_endpoint: string;
+                ui_locales_supported: ("en" | "ko" | "ja")[];
+                request_parameter_supported: boolean;
+                request_uri_parameter_supported: boolean;
+                claims_parameter_supported: boolean;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/oauth"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/openid-configuration": {
+        $get: {
+            input: {};
+            output: {
+                issuer: string;
+                authorization_endpoint: string;
+                token_endpoint: string;
+                jwks_uri: string;
+                response_types_supported: string[];
+                response_modes_supported: string[];
+                subject_types_supported: string[];
+                id_token_signing_alg_values_supported: string[];
+                userinfo_signing_alg_values_supported: string[];
+                userinfo_endpoint: string;
+                scopes_supported: string[];
+                claims_supported: string[];
+                prompt_values_supported: string[];
+                grant_types_supported: string[];
+                token_endpoint_auth_methods_supported: string[];
+                introspection_endpoint_auth_methods_supported: string[];
+                revocation_endpoint_auth_methods_supported: string[];
+                code_challenge_methods_supported: string[];
+                introspection_endpoint: string;
+                revocation_endpoint: string;
+                end_session_endpoint: string;
+                device_authorization_endpoint: string;
+                ui_locales_supported: ("en" | "ko" | "ja")[];
+                request_parameter_supported: boolean;
+                request_uri_parameter_supported: boolean;
+                claims_parameter_supported: boolean;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/.well-known">, "/", "/">;
+//# sourceMappingURL=index.d.ts.map