@tinyrack/tinyauth-server 0.0.7

package/dist/entrypoints/app.d.ts

@@ -0,0 +1,1300 @@
+import { type TinyAuthRuntimeConfigInput } from '../lib/config/index.ts';
+/**
+ * Application configuration for the backend runtime.
+ */
+export type CreateAppOptions = TinyAuthRuntimeConfigInput;
+export declare function createApp(options: CreateAppOptions): Promise<{
+    app: import("hono/hono-base").HonoBase<import("../middleware/logger.ts").LoggerEnv & import("../middleware/session.ts").SessionEnv & import("../middleware/services.ts").ServicesEnv, 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<{
+        "/auth/login": {
+            $post: {
+                input: {
+                    json: {
+                        email: string;
+                        password: string;
+                    };
+                };
+                output: {
+                    user: {
+                        managed_by: "database" | "config";
+                        sub: string;
+                        email: string;
+                        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;
+                    };
+                } & {
+                    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;
+                        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;
+                    };
+                } & {
+                    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;
+                        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;
+                    };
+                } & {
+                    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;
+                        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;
+                        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;
+                        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: ("en" | "ko" | "ja")[];
+                        default_language: "en" | "ko" | "ja" | "auto";
+                        fallback_language: "en" | "ko" | "ja";
+                    };
+                    branding: {
+                        light_theme: "light" | "dark" | "cupcake" | "bumblebee" | "emerald" | "corporate" | "synthwave" | "retro" | "cyberpunk" | "valentine" | "halloween" | "garden" | "forest" | "aqua" | "lofi" | "pastel" | "fantasy" | "wireframe" | "black" | "luxury" | "dracula" | "cmyk" | "autumn" | "business" | "acid" | "lemonade" | "night" | "coffee" | "winter" | "dim" | "nord" | "sunset" | "caramellatte" | "abyss" | "silk";
+                        dark_theme: "light" | "dark" | "cupcake" | "bumblebee" | "emerald" | "corporate" | "synthwave" | "retro" | "cyberpunk" | "valentine" | "halloween" | "garden" | "forest" | "aqua" | "lofi" | "pastel" | "fantasy" | "wireframe" | "black" | "luxury" | "dracula" | "cmyk" | "autumn" | "business" | "acid" | "lemonade" | "night" | "coffee" | "winter" | "dim" | "nord" | "sunset" | "caramellatte" | "abyss" | "silk";
+                        theme_mode: "light" | "dark" | "system";
+                        background_url: string;
+                        icon_url: string | undefined;
+                        title: {
+                            [x: string]: string;
+                        };
+                        subtitle: {
+                            [x: string]: string;
+                        };
+                    };
+                    registration: {
+                        public_registration: boolean;
+                        email_pattern_filter_enabled: boolean;
+                        email_verification_required: boolean;
+                        signup_notice: {
+                            [x: string]: string;
+                        };
+                    };
+                    database: {
+                        enabled: true;
+                    };
+                    email: {
+                        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 | string[];
+                    };
+                };
+                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;
+                    };
+                };
+                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<{
+        "/terms": {
+            $get: {
+                input: {
+                    query: {
+                        lang?: string | string[];
+                    };
+                };
+                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<{
+        "/docs": {
+            $get: {
+                input: {};
+                output: {};
+                outputFormat: string;
+                status: import("hono/utils/http-status").StatusCode;
+            };
+        };
+    }, "/">, "/"> | 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;
+                        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;
+                        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;
+                        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").BlankSchema | import("hono/types").MergeSchemaPath<{
+        "/oauth/:provider/authorize": {
+            $get: {
+                input: {
+                    param: {
+                        provider: string;
+                    };
+                } & {
+                    query: {
+                        mode?: string | string[];
+                        return_url?: string | string[];
+                    };
+                };
+                output: undefined;
+                outputFormat: "redirect";
+                status: 302;
+            };
+        };
+    }, "/"> | import("hono/types").MergeSchemaPath<{
+        "/oauth/:provider/callback": {
+            $get: {
+                input: {
+                    param: {
+                        provider: string;
+                    };
+                } & {
+                    query: {
+                        code?: string | string[];
+                        state?: string | string[];
+                        error?: string | string[];
+                        error_description?: string | string[];
+                    };
+                };
+                output: undefined;
+                outputFormat: "redirect";
+                status: 302;
+            };
+        };
+    }, "/"> | import("hono/types").MergeSchemaPath<{
+        "/oauth/:provider/callback": {
+            $post: {
+                input: {
+                    param: {
+                        provider: string;
+                    };
+                } & {
+                    form: {
+                        code?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                        state?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                        error?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                        error_description?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                    };
+                };
+                output: undefined;
+                outputFormat: "redirect";
+                status: 302;
+            };
+        };
+    }, "/"> | 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 | string[];
+                        code_challenge?: string | string[];
+                        code_challenge_method?: string | string[];
+                        scope?: string | string[];
+                        nonce?: string | string[];
+                        prompt?: string | string[];
+                        max_age?: string | string[];
+                        display?: string | string[];
+                    };
+                };
+                output: undefined;
+                outputFormat: "redirect";
+                status: 302;
+            } | {
+                input: {
+                    query: {
+                        response_type: string | string[];
+                        redirect_uri: string | string[];
+                        client_id: string | string[];
+                        state?: string | string[];
+                        code_challenge?: string | string[];
+                        code_challenge_method?: string | string[];
+                        scope?: string | string[];
+                        nonce?: string | string[];
+                        prompt?: string | string[];
+                        max_age?: string | string[];
+                        display?: string | string[];
+                    };
+                };
+                output: {
+                    error: string;
+                    error_description: string;
+                };
+                outputFormat: "json";
+                status: 400;
+            };
+        };
+    }, "/"> | import("hono/types").MergeSchemaPath<{
+        "/token": {
+            $post: {
+                input: {
+                    form: {
+                        grant_type: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                        client_id: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                        code?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                        redirect_uri?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                        client_secret?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                        code_verifier?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                        refresh_token?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                    };
+                };
+                output: {
+                    access_token: string;
+                    token_type: "Bearer";
+                    expires_in: number;
+                    refresh_token: string;
+                    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?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                        client_id?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                        client_secret?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                    };
+                };
+                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;
+                };
+                outputFormat: "json";
+                status: 200;
+            };
+        };
+    }, "/"> | import("hono/types").MergeSchemaPath<{
+        "/revoke": {
+            $post: {
+                input: {
+                    form: {
+                        token: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                        token_type_hint?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                        client_id?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                        client_secret?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                    };
+                };
+                output: {};
+                outputFormat: "json";
+                status: 200;
+            };
+        };
+    }, "/"> | import("hono/types").MergeSchemaPath<{
+        "/userinfo": {
+            $get: {
+                input: {
+                    header: {
+                        authorization?: string;
+                    };
+                };
+                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[];
+                    subject_types_supported: string[];
+                    id_token_signing_alg_values_supported: string[];
+                    userinfo_endpoint: string;
+                    scopes_supported: string[];
+                    claims_supported: string[];
+                    grant_types_supported: string[];
+                    token_endpoint_auth_methods_supported: string[];
+                    code_challenge_methods_supported: string[];
+                    introspection_endpoint: string;
+                    revocation_endpoint: string;
+                    ui_locales_supported: ("en" | "ko" | "ja")[];
+                };
+                outputFormat: "json";
+                status: 200;
+            };
+        };
+    }, "/">, "/oauth"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+        "/openid-configuration": {
+            $get: {
+                input: {};
+                output: undefined;
+                outputFormat: "redirect";
+                status: 302;
+            };
+        };
+    }, "/">, "/.well-known">, "/">, "/", "*">;
+    services: {
+        config: {
+            server: {
+                public_origin: string;
+                listen_port: number;
+                trust_proxy: string | number | boolean | string[];
+            };
+            tokens: {
+                access_token_ttl: number;
+                refresh_token_ttl: number;
+                key_rotation: {
+                    enabled: boolean;
+                    interval_days: number;
+                    overlap_days: number;
+                };
+            };
+            i18n: {
+                supported_languages: ("en" | "ko" | "ja")[];
+                default_language: "en" | "ko" | "ja" | "auto";
+                fallback_language: "en" | "ko" | "ja";
+            };
+            branding: {
+                light_theme: "light" | "dark" | "cupcake" | "bumblebee" | "emerald" | "corporate" | "synthwave" | "retro" | "cyberpunk" | "valentine" | "halloween" | "garden" | "forest" | "aqua" | "lofi" | "pastel" | "fantasy" | "wireframe" | "black" | "luxury" | "dracula" | "cmyk" | "autumn" | "business" | "acid" | "lemonade" | "night" | "coffee" | "winter" | "dim" | "nord" | "sunset" | "caramellatte" | "abyss" | "silk";
+                dark_theme: "light" | "dark" | "cupcake" | "bumblebee" | "emerald" | "corporate" | "synthwave" | "retro" | "cyberpunk" | "valentine" | "halloween" | "garden" | "forest" | "aqua" | "lofi" | "pastel" | "fantasy" | "wireframe" | "black" | "luxury" | "dracula" | "cmyk" | "autumn" | "business" | "acid" | "lemonade" | "night" | "coffee" | "winter" | "dim" | "nord" | "sunset" | "caramellatte" | "abyss" | "silk";
+                theme_mode: "light" | "dark" | "system";
+                background_url: string;
+                title: Record<string, string>;
+                subtitle: Record<string, string>;
+                icon_url?: string | undefined;
+            };
+            registration: {
+                enabled: boolean;
+                allowed_email_patterns: string[];
+                email_verification_required: boolean;
+                signup_notice: Record<string, string>;
+            };
+            account_deletion: {
+                enabled: boolean;
+                retention: string;
+            };
+            logging: {
+                level: "error" | "trace" | "debug" | "info" | "warn" | "fatal" | "silent";
+                format: "json" | "pretty";
+            };
+            openapi: {
+                enabled: boolean;
+                title: string;
+                description: string;
+                ui_title: string;
+            };
+            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;
+                };
+            };
+            security: {
+                session_secret: string;
+                hash_secret: string;
+                pbkdf2_iterations: number;
+            };
+            cleanup: {
+                revoked_tokens: {
+                    enabled: boolean;
+                    retention: string;
+                };
+                oauth_codes: {
+                    enabled: boolean;
+                    consumed_retention: string;
+                };
+                email_verifications: {
+                    enabled: boolean;
+                    retention: string;
+                };
+                password_resets: {
+                    enabled: boolean;
+                    retention: string;
+                };
+                pending_oauth_registrations: {
+                    enabled: boolean;
+                    retention: string;
+                };
+            };
+            terms: {
+                id: string;
+                required: boolean;
+                consent_mode: "explicit" | "implicit";
+                version: string;
+                content: Record<string, {
+                    title: string;
+                    type: "link";
+                    content: string;
+                } | {
+                    title: string;
+                    type: "text";
+                    content: string;
+                }>;
+            }[];
+            clients: {
+                id: string;
+                name: string;
+                client_id: string;
+                redirect_uris: string[];
+                response_types: string[];
+                grant_types: string[];
+                scope: string;
+                logo_uri?: string | undefined;
+                client_secret?: string | undefined;
+            }[];
+            users: {
+                sub: string;
+                email: string;
+                password: string;
+                role: "user" | "admin";
+            }[];
+            database: import("../lib/config/database.ts").DatabaseConfig;
+            identity_providers: {
+                id: string;
+                type: "github" | "google" | "apple" | "generic_oauth";
+                enabled: boolean;
+                display_name: string;
+                client_id: string;
+                client_secret: string;
+                authorization_url: string;
+                token_url: string;
+                userinfo_url: string | null;
+                scopes: string[];
+                email_conflict_strategy: "auto_link" | "require_link";
+                userinfo_mapping: {
+                    id: string;
+                    email: string;
+                    email_verified?: string | undefined;
+                    name?: string | undefined;
+                    picture?: string | undefined;
+                };
+                icon_url?: string | undefined;
+                email_url?: string | undefined;
+                response_mode?: string | undefined;
+            }[];
+            scheduler?: import("../lib/config/scheduler.ts").SchedulerConfig | undefined;
+            frontend?: import("../lib/config/frontend.ts").FrontendConfig | undefined;
+            email?: import("../lib/config/email.ts").EmailConfig | undefined;
+        };
+        securityService: import("../services/security.service.ts").SecurityService;
+        mikro: import("../services/mikro.service.ts").MikroService;
+        scheduler: import("../services/scheduler.service.ts").SchedulerService;
+        emailService: import("../services/email.service.ts").EmailService;
+        jwtService: import("../services/jwt.service.ts").JwtService;
+        passwordAuthService: import("../services/password-auth.service.ts").PasswordAuthService;
+        passwordResetService: import("../services/password-reset.service.ts").PasswordResetService;
+        termsService: import("../services/terms.service.ts").TermsService;
+        userConsentService: import("../services/user-consent.service.ts").UserConsentService;
+        oauthClientService: import("../services/oauth-client.service.ts").OAuthClientService;
+        totpService: import("../services/totp.service.ts").TotpService;
+        passkeyService: import("../services/passkey.service.ts").PasskeyService;
+        userService: import("../services/user.service.ts").UserService;
+        oauthAuthorizeService: import("../services/oauth-authorize.service.ts").OAuthAuthorizeService;
+        oauthConnectService: import("../services/oauth-connect.service.ts").OAuthConnectService;
+        oauthTokenService: import("../services/oauth-token.service.ts").OAuthTokenService;
+        cleanupService: import("../services/cleanup.service.ts").CleanupService;
+    };
+    cleanup: () => Promise<void>;
+    logger: import("pino").Logger<never, boolean>;
+}>;
+export type AppType = Awaited<ReturnType<typeof createApp>>['app'];
+//# sourceMappingURL=app.d.ts.map