@tinyrack/issuary-server 0.26.0 → 0.28.0

package/dist/entrypoints/app.d.ts

@@ -1,21 +1,328 @@
 import { type IssuaryRuntimeConfigInput } from '../lib/config/index.ts';
+import { type ReactRouterRuntimeOptions } from '../lib/frontend/react-router.ts';
 import { type InitializeServicesOptions } from '../services/container.ts';
 /**
  * Application configuration for the backend runtime.
  */
 export type CreateAppOptions = IssuaryRuntimeConfigInput;
-export type CreateAppRuntimeOptions = InitializeServicesOptions;
+export type CreateAppRuntimeOptions = InitializeServicesOptions & {
+    reactRouter?: ReactRouterRuntimeOptions | undefined;
+};
 export declare function createApp(options: CreateAppOptions, runtimeOptions?: CreateAppRuntimeOptions): 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").BlankSchema, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-        "/admin/me": {
+    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<{
+        "/openid-configuration": {
+            $get: {
+                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" | "ja" | "ko")[];
+                    request_parameter_supported: boolean;
+                    request_uri_parameter_supported: boolean;
+                    claims_parameter_supported: boolean;
+                };
+                outputFormat: "json";
+                status: 200;
+                input: {};
+            };
+        };
+    }, "/">, "/.well-known"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+        "/end_session": {
+            $get: {
+                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;
+                input: {
+                    query: {
+                        client_id?: string | undefined;
+                        post_logout_redirect_uri?: string | undefined;
+                        id_token_hint?: string | undefined;
+                        state?: string | undefined;
+                    };
+                };
+            };
+        };
+    }, "/"> | import("hono/types").MergeSchemaPath<{
+        "/authorize": {
+            $get: {
+                output: {};
+                outputFormat: string;
+                status: import("hono/utils/http-status").StatusCode;
+                input: {
+                    query: {
+                        response_type: string | string[];
+                        redirect_uri: string | string[];
+                        state?: string | undefined;
+                        client_id: string | string[];
+                        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;
+                    };
+                };
+            };
+        };
+    }, "/"> | import("hono/types").MergeSchemaPath<{
+        "/device_authorization": {
+            $post: {
+                output: {
+                    device_code: string;
+                    user_code: string;
+                    verification_uri: string;
+                    verification_uri_complete: string;
+                    expires_in: number;
+                    interval: number;
+                };
+                outputFormat: "json";
+                status: 200;
+                input: {
+                    form: {
+                        client_id?: string | undefined;
+                        client_secret?: string | undefined;
+                        scope?: string | undefined;
+                    };
+                };
+            };
+        };
+    }, "/"> | import("hono/types").MergeSchemaPath<{
+        "/token": {
+            $post: {
+                output: {
+                    access_token: string;
+                    token_type: 'Bearer';
+                    expires_in: number;
+                    refresh_token?: string | undefined;
+                    id_token?: string | undefined;
+                    scope: string;
+                };
+                outputFormat: "json";
+                status: 200;
+                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;
+                    };
+                };
+            };
+        };
+    }, "/"> | import("hono/types").MergeSchemaPath<{
+        "/introspect": {
+            $post: {
+                output: {
+                    active: boolean;
+                    scope?: string | undefined;
+                    client_id?: string | undefined;
+                    token_type?: 'Bearer' | undefined;
+                    exp?: number | undefined;
+                    iat?: number | undefined;
+                    sub?: string | undefined;
+                    iss?: string | undefined;
+                    aud?: string | undefined;
+                };
+                outputFormat: "json";
+                status: 200;
+                input: {
+                    form: {
+                        token: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue;
+                        token_type_hint?: string | undefined;
+                        client_id?: string | undefined;
+                        client_secret?: string | undefined;
+                    };
+                };
+            };
+        };
+    }, "/"> | import("hono/types").MergeSchemaPath<{
+        "/revoke": {
+            $post: {
+                output: {};
+                outputFormat: "json";
+                status: 200;
+                input: {
+                    form: {
+                        token: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue;
+                        token_type_hint?: string | undefined;
+                        client_id?: string | undefined;
+                        client_secret?: string | undefined;
+                    };
+                };
+            };
+        };
+    }, "/"> | import("hono/types").MergeSchemaPath<{
+        "/.well-known/jwks": {
+            $get: {
+                output: {
+                    keys: {
+                        kty: string;
+                        use: string;
+                        kid: string;
+                        alg: string;
+                        n?: string | undefined;
+                        e?: string | undefined;
+                        x?: string | undefined;
+                        y?: string | undefined;
+                        crv?: string | undefined;
+                    }[];
+                };
+                outputFormat: "json";
+                status: 200;
+                input: {};
+            };
+        };
+    }, "/"> | import("hono/types").MergeSchemaPath<{
+        "/.well-known/openid-configuration": {
+            $get: {
+                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" | "ja" | "ko")[];
+                    request_parameter_supported: boolean;
+                    request_uri_parameter_supported: boolean;
+                    claims_parameter_supported: boolean;
+                };
+                outputFormat: "json";
+                status: 200;
+                input: {};
+            };
+        };
+    }, "/"> | import("hono/types").MergeSchemaPath<{
+        "/device": {
+            $get: {
+                output: {};
+                outputFormat: string;
+                status: import("hono/utils/http-status").StatusCode;
+                input: {};
+            };
+        };
+    } & {
+        "/device": {
+            $post: {
+                output: {
+                    status: string;
+                    client_id: string;
+                };
+                outputFormat: "json";
+                status: import("hono/utils/http-status").ContentfulStatusCode;
+                input: {
+                    form: {
+                        user_code: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue;
+                        decision?: "approve" | "deny" | undefined;
+                    };
+                };
+            };
+        };
+    }, "/"> | import("hono/types").MergeSchemaPath<{
+        "/userinfo": {
             $get: {
+                output: {
+                    sub: string;
+                    email?: string | undefined;
+                    email_verified?: boolean | undefined;
+                    name?: string | undefined;
+                    picture?: string | undefined;
+                    preferred_username?: string | undefined;
+                };
+                outputFormat: "json";
+                status: 200;
+                input: {};
+            };
+        };
+    } & {
+        "/userinfo": {
+            $post: {
+                output: {
+                    sub: string;
+                    email?: string | undefined;
+                    email_verified?: boolean | undefined;
+                    name?: string | undefined;
+                    picture?: string | undefined;
+                    preferred_username?: string | undefined;
+                };
+                outputFormat: "json";
+                status: 200;
                 input: {};
+            };
+        };
+    }, "/">, "/oauth"> | 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: {
                 output: {
                     user: {
-                        managed_by: "database" | "config";
+                        managed_by: "config" | "database";
                         sub: string;
                         email: string;
-                        role: "user" | "admin";
+                        role: "admin" | "user";
                         email_verified: boolean;
                         email_verification_required: boolean;
                         has_password: boolean;
@@ -27,63 +334,73 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                 };
                 outputFormat: "json";
                 status: 200;
+                input: {};
             };
         };
     }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-        "/admin/users": {
-            $get: {
+        "/auth/accounts/select": {
+            $post: {
+                output: {
+                    code: string;
+                    message: string;
+                };
+                outputFormat: "json";
+                status: 400;
                 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;
+                    json: {
+                        sub: string;
                     };
                 };
+            } | {
                 output: {
-                    users: {
-                        managed_by: "database" | "config";
+                    ok: true;
+                    active_sub: string;
+                };
+                outputFormat: "json";
+                status: 200;
+                input: {
+                    json: {
                         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;
                     };
                 };
+            };
+        };
+    }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+        "/auth/logout": {
+            $post: {
+                output: {
+                    ok: true;
+                };
                 outputFormat: "json";
                 status: 200;
+                input: {};
             };
         };
-    } & {
-        "/admin/users": {
+    }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+        "/auth/password/reset": {
             $post: {
+                output: {
+                    message: string;
+                };
+                outputFormat: "json";
+                status: 200;
                 input: {
                     json: {
-                        email: string;
+                        token: string;
                         password: string;
-                        role?: "user" | "admin" | undefined;
-                        email_verified?: boolean | undefined;
                     };
                 };
+            };
+        };
+    }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+        "/auth/totp/verify": {
+            $post: {
                 output: {
                     user: {
-                        managed_by: "database" | "config";
+                        managed_by: "config" | "database";
                         sub: string;
                         email: string;
-                        role: "user" | "admin";
+                        role: "admin" | "user";
                         email_verified: boolean;
                         email_verification_required: boolean;
                         has_password: boolean;
@@ -91,117 +408,218 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                         totp_recovery_codes_missing: boolean;
                         second_factor_required: boolean;
                         passkey_count: number;
-                        deleted_at: string | null;
                     };
                 };
                 outputFormat: "json";
-                status: 201;
+                status: 200;
+                input: {
+                    json: {
+                        code: string;
+                    };
+                };
+            };
+        };
+    }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+        "/docs": {
+            $get: {
+                output: {};
+                outputFormat: string;
+                status: import("hono/utils/http-status").StatusCode;
+                input: {};
+            };
+        };
+    }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+        "/health/ready": {
+            $get: {
+                output: {
+                    status: 'ok';
+                    checks: {
+                        database: 'ok';
+                    };
+                };
+                outputFormat: "json";
+                status: 200;
+                input: {};
+            } | {
+                output: {
+                    status: 'error';
+                    checks: {
+                        database: "error";
+                    };
+                    error: string | undefined;
+                };
+                outputFormat: "json";
+                status: 503;
+                input: {};
+            };
+        };
+    }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+        "/oauth/:provider/callback": {
+            $post: {
+                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;
+                input: {
+                    param: {
+                        provider: string;
+                    };
+                } & {
+                    form: {
+                        code?: string | undefined;
+                        state?: string | undefined;
+                        error?: string | undefined;
+                        error_description?: string | undefined;
+                    };
+                };
+            };
+        };
+    }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+        "/terms/consent": {
+            $post: {
+                output: {
+                    ok: true;
+                    recorded: number;
+                };
+                outputFormat: "json";
+                status: 200;
+                input: {
+                    json: {
+                        consents: {
+                            termsId: string;
+                            agreed: boolean;
+                            consentType?: "explicit" | "implicit" | undefined;
+                        }[];
+                        registrationToken?: string | undefined;
+                    };
+                };
             };
         };
-    } & {
-        "/admin/users/:sub": {
+    }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+        "/user/oauth-accounts": {
             $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;
-                    };
+                    accounts: {
+                        provider_name: string;
+                        linked_at: string;
+                    }[];
+                    available_providers: {
+                        id: string;
+                        display_name: string;
+                        icon_url: string | undefined;
+                        linked: boolean;
+                    }[];
                 };
                 outputFormat: "json";
                 status: 200;
+                input: {};
             };
         };
-    } & {
-        "/admin/users/:sub": {
-            $patch: {
-                input: {
-                    json: {
-                        email?: string | undefined;
-                        role?: "user" | "admin" | undefined;
-                        email_verified?: boolean | undefined;
-                    };
-                } & {
-                    param: {
-                        sub: string;
-                    };
-                };
+    }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+        "/user/passkeys/register/options": {
+            $post: {
                 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;
+                    options: {
+                        rp: {
+                            id?: string;
+                            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;
+                        excludeCredentials?: {
+                            id: import("@simplewebauthn/server").Base64URLString;
+                            type: import("@simplewebauthn/server").PublicKeyCredentialType;
+                            transports?: import("@simplewebauthn/server").AuthenticatorTransportFuture[];
+                        }[] | undefined;
+                        authenticatorSelection?: {
+                            authenticatorAttachment?: import("@simplewebauthn/server").AuthenticatorAttachment;
+                            requireResidentKey?: boolean;
+                            residentKey?: import("@simplewebauthn/server").ResidentKeyRequirement;
+                            userVerification?: import("@simplewebauthn/server").UserVerificationRequirement;
+                        } | undefined;
+                        hints?: import("@simplewebauthn/server").PublicKeyCredentialHint[];
+                        attestation?: import("@simplewebauthn/server").AttestationConveyancePreference;
+                        attestationFormats?: import("@simplewebauthn/server").AttestationFormat[];
+                        extensions?: {
+                            appid?: string;
+                            credProps?: boolean;
+                            hmacCreateSecret?: boolean;
+                            minPinLength?: boolean;
+                        } | undefined;
                     };
                 };
                 outputFormat: "json";
                 status: 200;
+                input: {};
             };
         };
-    } & {
-        "/admin/users/:sub": {
-            $delete: {
+    }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+        "/user/password": {
+            $put: {
+                output: {
+                    ok: true;
+                };
+                outputFormat: "json";
+                status: 200;
                 input: {
-                    param: {
-                        sub: string;
+                    json: {
+                        current_password: string;
+                        new_password: string;
                     };
                 };
+            };
+        };
+    }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+        "/user/totp/recovery/regenerate": {
+            $post: {
                 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;
-                    };
+                    recovery_codes: string[];
                 };
                 outputFormat: "json";
                 status: 200;
+                input: {
+                    json: {
+                        code: string;
+                    };
+                };
             };
         };
     }, "/">, "/"> | 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">>;
+                        role: import("@mikro-orm/core").Opt<NonNullable<"admin" | "user">>;
                         current: boolean;
                         authenticated_at: number;
                         last_used_at: number;
@@ -211,89 +629,60 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                 };
                 outputFormat: "json";
                 status: 200;
+                input: {
+                    query: {
+                        client_id?: string | undefined;
+                    };
+                };
             };
         };
     }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-        "/auth/accounts/select": {
+        "/auth/accounts/remove": {
             $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")[];
+                    methods: ("passkey" | "totp")[];
                 };
                 outputFormat: "json";
                 status: 200;
+                input: {};
             };
         };
     }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
         "/auth/login": {
             $post: {
-                input: {
-                    json: {
-                        email: string;
-                        password: string;
-                    };
-                };
                 output: {
                     user: {
-                        managed_by: "database" | "config";
+                        managed_by: "config" | "database";
                         sub: string;
                         email: string;
-                        role: "user" | "admin";
+                        role: "admin" | "user";
                         email_verified: boolean;
                         email_verification_required: boolean;
                         has_password: boolean;
@@ -305,43 +694,23 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                 };
                 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;
                     };
                 };
+            };
+        };
+    }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+        "/auth/register": {
+            $post: {
                 output: {
                     user: {
-                        managed_by: "database" | "config";
+                        managed_by: "config" | "database";
                         sub: string;
                         email: string;
-                        role: "user" | "admin";
+                        role: "admin" | "user";
                         email_verified: boolean;
                         email_verification_required: boolean;
                         has_password: boolean;
@@ -353,11 +722,6 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                 };
                 outputFormat: "json";
                 status: 200;
-            };
-        };
-    }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-        "/auth/password/forgot": {
-            $post: {
                 input: {
                     header: {
                         'accept-language'?: string | undefined;
@@ -365,61 +729,24 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                 } & {
                     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;
+                        consents?: {
+                            termsId: string;
+                            agreed: boolean;
+                            consentType?: "explicit" | "implicit" | undefined;
+                        }[] | undefined;
                     };
                 };
-                output: {
-                    message: string;
-                };
-                outputFormat: "json";
-                status: 200;
             };
         };
     }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-        "/auth/email/verify": {
+        "/auth/password/forgot": {
             $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;
-                    };
+                    ok: true;
                 };
                 outputFormat: "json";
-                status: 200;
-            };
-        };
-    }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-        "/auth/email/resend": {
-            $post: {
+                status: 200;
                 input: {
                     header: {
                         'accept-language'?: string | undefined;
@@ -429,27 +756,17 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                         email: string;
                     };
                 };
-                output: {
-                    message: string;
-                };
-                outputFormat: "json";
-                status: 200;
             };
         };
     }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-        "/auth/totp/verify": {
+        "/auth/email/verify": {
             $post: {
-                input: {
-                    json: {
-                        code: string;
-                    };
-                };
                 output: {
                     user: {
-                        managed_by: "database" | "config";
+                        managed_by: "config" | "database";
                         sub: string;
                         email: string;
-                        role: "user" | "admin";
+                        role: "admin" | "user";
                         email_verified: boolean;
                         email_verification_required: boolean;
                         has_password: boolean;
@@ -461,22 +778,41 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                 };
                 outputFormat: "json";
                 status: 200;
+                input: {
+                    json: {
+                        token: string;
+                    };
+                };
             };
         };
     }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-        "/auth/totp/recovery/verify": {
+        "/auth/email/resend": {
             $post: {
+                output: {
+                    message: string;
+                };
+                outputFormat: "json";
+                status: 200;
                 input: {
+                    header: {
+                        'accept-language'?: string | undefined;
+                    };
+                } & {
                     json: {
-                        code: string;
+                        email: string;
                     };
                 };
+            };
+        };
+    }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+        "/auth/totp/recovery/verify": {
+            $post: {
                 output: {
                     user: {
-                        managed_by: "database" | "config";
+                        managed_by: "config" | "database";
                         sub: string;
                         email: string;
-                        role: "user" | "admin";
+                        role: "admin" | "user";
                         email_verified: boolean;
                         email_verification_required: boolean;
                         has_password: boolean;
@@ -488,39 +824,61 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                 };
                 outputFormat: "json";
                 status: 200;
+                input: {
+                    json: {
+                        code: string;
+                    };
+                };
             };
         };
     }, "/">, "/"> | 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;
+                        timeout?: number;
+                        rpId?: string;
                         allowCredentials?: {
                             id: import("@simplewebauthn/server").Base64URLString;
                             type: import("@simplewebauthn/server").PublicKeyCredentialType;
-                            transports?: import("@simplewebauthn/server").AuthenticatorTransportFuture[] | undefined;
+                            transports?: import("@simplewebauthn/server").AuthenticatorTransportFuture[];
                         }[] | undefined;
-                        userVerification?: import("@simplewebauthn/server").UserVerificationRequirement | undefined;
-                        hints?: import("@simplewebauthn/server").PublicKeyCredentialHint[] | undefined;
+                        userVerification?: import("@simplewebauthn/server").UserVerificationRequirement;
+                        hints?: import("@simplewebauthn/server").PublicKeyCredentialHint[];
                         extensions?: {
-                            appid?: string | undefined;
-                            credProps?: boolean | undefined;
-                            hmacCreateSecret?: boolean | undefined;
-                            minPinLength?: boolean | undefined;
+                            appid?: string;
+                            credProps?: boolean;
+                            hmacCreateSecret?: boolean;
+                            minPinLength?: boolean;
                         } | undefined;
                     };
                 };
                 outputFormat: "json";
                 status: 200;
+                input: {};
             };
         };
     }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
         "/auth/passkey/verify": {
             $post: {
+                output: {
+                    user: {
+                        managed_by: "config" | "database";
+                        sub: string;
+                        email: string;
+                        role: "admin" | "user";
+                        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;
                 input: {
                     json: {
                         response: {
@@ -532,35 +890,17 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                                 signature: string;
                                 userHandle?: string | undefined;
                             };
+                            authenticatorAttachment?: "cross-platform" | "platform" | 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[];
@@ -569,9 +909,16 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                     };
                     branding: {
                         icon_url?: string | undefined;
-                        title?: {
+                        logo_url?: string | undefined;
+                        title: {
                             [x: string]: string;
-                        } | undefined;
+                        };
+                        subtitle: {
+                            [x: string]: string;
+                        };
+                        login_method_description: {
+                            [x: string]: string;
+                        };
                     };
                     registration: {
                         public_registration: boolean;
@@ -613,7 +960,7 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                     };
                     identity_providers: {
                         id: string;
-                        type: "github" | "google" | "apple" | "generic_oauth";
+                        type: "apple" | "generic_oauth" | "github" | "google";
                         display_name: string;
                         icon_url?: string | undefined;
                     }[];
@@ -624,17 +971,12 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                 };
                 outputFormat: "json";
                 status: 200;
+                input: {};
             };
         };
     }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
         "/consent": {
             $get: {
-                input: {
-                    query: {
-                        client_id: string | string[];
-                        scope?: string | undefined;
-                    };
-                };
                 output: {
                     client: {
                         id: string;
@@ -652,17 +994,27 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                 };
                 outputFormat: "json";
                 status: 200;
+                input: {
+                    query: {
+                        client_id: string | string[];
+                        scope?: string | undefined;
+                    };
+                };
             };
         };
     }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
         "/consent": {
             $post: {
+                output: {
+                    redirect_url: string;
+                };
+                outputFormat: "json";
+                status: 200;
                 input: {
                     json: {
                         client_id: string;
                         redirect_uri: string;
                         response_type: string;
-                        decision: "allow" | "deny";
                         scope?: string | undefined;
                         state?: string | undefined;
                         nonce?: string | undefined;
@@ -672,39 +1024,34 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                         max_age?: unknown;
                         reauthenticated?: "1" | undefined;
                         display?: "page" | "popup" | "touch" | "wap" | undefined;
-                        response_mode?: "query" | "fragment" | "form_post" | undefined;
+                        response_mode?: "form_post" | "fragment" | "query" | 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;
+                        decision: "allow" | "deny";
                     };
                 };
-                output: {
-                    redirect_url: string;
-                };
-                outputFormat: "json";
-                status: 200;
             };
         };
     }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
         "/health": {
             $get: {
-                input: {};
                 output: {
-                    status: "ok";
+                    status: 'ok';
                     uptime: number;
                     checks: {
-                        database: "ok";
+                        database: 'ok';
                     };
                 };
                 outputFormat: "json";
                 status: 200;
-            } | {
                 input: {};
+            } | {
                 output: {
-                    status: "error";
+                    status: 'error';
                     uptime: number;
                     checks: {
                         database: "error";
@@ -713,109 +1060,54 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                 };
                 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";
+                    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";
+                        consentMode: 'explicit' | 'implicit';
                         version: string;
                         title: string;
                         type: import("../services/terms.service.ts").TermsContentType;
                         content: string;
+                        userConsent: {
+                            agreed: boolean;
+                            agreedVersion: string | null;
+                            consentType: 'explicit' | 'implicit' | null;
+                            requiresUpdate: boolean;
+                            agreedAt: string | null;
+                        } | null;
                     }[];
                     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;
+                    query: {
+                        lang?: 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;
@@ -823,25 +1115,25 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                 };
                 outputFormat: "json";
                 status: 200;
+                input: {};
             };
         };
     }, "/">, "/"> | 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";
+                        managed_by: "config" | "database";
                         sub: string;
                         email: string;
-                        role: "user" | "admin";
+                        role: "admin" | "user";
                         email_verified: boolean;
                         email_verification_required: boolean;
                         has_password: boolean;
@@ -853,78 +1145,42 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                 };
                 outputFormat: "json";
                 status: 200;
+                input: {};
             };
         };
     }, "/">, "/"> | 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;
+                        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;
-                    }[];
+                input: {
+                    json: {
+                        current_password: string;
+                    };
                 };
-                outputFormat: "json";
-                status: 200;
             };
         };
     }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
         "/user/totp/setup": {
             $post: {
-                input: {};
                 output: {
                     secret: string;
                     otpauth_url: string;
@@ -932,114 +1188,105 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                 };
                 outputFormat: "json";
                 status: 200;
+                input: {};
             };
         };
     }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
         "/user/totp/verify": {
             $post: {
-                input: {
-                    json: {
-                        code: string;
-                    };
-                };
                 output: {
                     recovery_codes: string[];
                 };
                 outputFormat: "json";
                 status: 200;
+                input: {
+                    json: {
+                        code: string;
+                    };
+                };
             };
         };
     }, "/">, "/"> | 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";
+                        managed_by: "config" | "database";
                         sub: string;
                         email: string;
-                        role: "user" | "admin";
+                        role: "admin" | "user";
                         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;
+                        second_factor_required: boolean;
+                        passkey_count: number;
                     };
                 };
-                output: {
-                    recovery_codes: string[];
-                };
                 outputFormat: "json";
                 status: 200;
+                input: {
+                    json?: Record<string, never> | null | undefined;
+                };
             };
         };
     }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
         "/user/totp": {
             $delete: {
-                input: {
-                    json: {
-                        code: string;
-                    };
-                };
                 output: {
                     ok: true;
                 };
                 outputFormat: "json";
                 status: 200;
+                input: {
+                    json: {
+                        code: string;
+                    };
+                };
             };
         };
     }, "/">, "/"> | 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";
+                        device_type: 'singleDevice' | 'multiDevice';
                         backed_up: boolean;
                         created_at: string;
                     }[];
                 };
                 outputFormat: "json";
                 status: 200;
+                input: {};
             };
         };
     }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
         "/user/passkeys/:id": {
             $delete: {
-                input: {
-                    param: {
-                        id: string;
-                    };
-                };
                 output: {
                     ok: true;
                 };
                 outputFormat: "json";
                 status: 200;
+                input: {
+                    param: {
+                        id: string;
+                    };
+                };
             };
         };
     }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
         "/user/passkeys/:id": {
             $patch: {
+                output: {
+                    ok: true;
+                };
+                outputFormat: "json";
+                status: 200;
                 input: {
                     param: {
                         id: string;
@@ -1049,76 +1296,18 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                         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";
+                        managed_by: "config" | "database";
                         sub: string;
                         email: string;
-                        role: "user" | "admin";
+                        role: "admin" | "user";
                         email_verified: boolean;
                         email_verification_required: boolean;
                         has_password: boolean;
@@ -1131,32 +1320,30 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                 };
                 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;
+                input: {
+                    json: {
+                        response: Record<string, any>;
+                        name?: string | undefined;
+                    };
+                };
             };
         };
     }, "/">, "/"> | 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;
@@ -1172,29 +1359,40 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                 };
                 outputFormat: "json";
                 status: 200;
+                input: {
+                    query: {
+                        client_id: string | string[];
+                        redirect_uri: string | string[];
+                        response_type: string | string[];
+                        scope?: string | undefined;
+                    };
+                };
             };
         };
     }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
         "/oauth/:provider/authorize": {
             $get: {
+                output: undefined;
+                outputFormat: "redirect";
+                status: 302;
                 input: {
                     param: {
                         provider: string;
                     };
                 } & {
                     query: {
-                        mode?: "link" | "register" | "login" | undefined;
+                        mode?: "link" | "login" | "register" | undefined;
                         return_url?: string | undefined;
                     };
                 };
-                output: undefined;
-                outputFormat: "redirect";
-                status: 302;
             };
         };
     }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
         "/oauth/:provider/callback": {
             $get: {
+                output: undefined;
+                outputFormat: "redirect";
+                status: 302;
                 input: {
                     param: {
                         provider: string;
@@ -1207,10 +1405,13 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                         error_description?: string | undefined;
                     };
                 };
-                output: undefined;
-                outputFormat: "redirect";
-                status: 302;
             } | {
+                output: {
+                    code: any;
+                    message: any;
+                };
+                outputFormat: "json";
+                status: any;
                 input: {
                     param: {
                         provider: string;
@@ -1223,374 +1424,767 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                         error_description?: string | undefined;
                     };
                 };
+            };
+        };
+    }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+        "/oauth/:provider": {
+            $delete: {
                 output: {
-                    code: any;
-                    message: any;
+                    ok: true;
+                };
+                outputFormat: "json";
+                status: 200;
+                input: {
+                    param: {
+                        provider: string;
+                    };
+                };
+            };
+        };
+    }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+        "/admin/users": {
+            $get: {
+                output: {
+                    users: {
+                        managed_by: "config" | "database";
+                        sub: string;
+                        email: string;
+                        role: "admin" | "user";
+                        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;
+                input: {
+                    query: {
+                        query?: string | undefined;
+                        page?: string | string[];
+                        page_size?: string | string[];
+                        include_deleted?: string | string[];
+                        managed_by?: "config" | "database" | undefined;
+                        role?: "admin" | "user" | undefined;
+                        email_verified?: string | string[];
+                        two_factor?: string | string[];
+                        sort?: "created_at" | "email" | "role" | undefined;
+                        direction?: "asc" | "desc" | undefined;
+                    };
+                };
+            };
+        };
+    } & {
+        "/admin/users/bulk-status": {
+            $post: {
+                output: {
+                    matched: number;
+                    changed: number;
+                    skipped: {
+                        [x: string]: number;
+                    };
+                };
+                outputFormat: "json";
+                status: 200;
+                input: {
+                    json: {
+                        target: {
+                            kind: "ids";
+                            ids: string[];
+                        } | {
+                            kind: "filter";
+                            filter: {
+                                query?: string | undefined;
+                                include_deleted?: boolean | undefined;
+                                managed_by?: "config" | "database" | undefined;
+                                role?: "admin" | "user" | undefined;
+                                email_verified?: boolean | undefined;
+                            };
+                        };
+                        active: boolean;
+                    };
+                };
+            };
+        };
+    } & {
+        "/admin/users/:sub/restore": {
+            $post: {
+                output: {
+                    user: {
+                        managed_by: "config" | "database";
+                        sub: string;
+                        email: string;
+                        role: "admin" | "user";
+                        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;
+                input: {
+                    param: {
+                        sub: string;
+                    };
+                };
+            };
+        };
+    } & {
+        "/admin/users": {
+            $post: {
+                output: {
+                    user: {
+                        managed_by: "config" | "database";
+                        sub: string;
+                        email: string;
+                        role: "admin" | "user";
+                        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;
+                input: {
+                    json: {
+                        email: string;
+                        password: string;
+                        role?: "admin" | "user" | undefined;
+                        email_verified?: boolean | undefined;
+                    };
+                };
+            };
+        };
+    } & {
+        "/admin/users/:sub": {
+            $get: {
+                output: {
+                    user: {
+                        managed_by: "config" | "database";
+                        sub: string;
+                        email: string;
+                        role: "admin" | "user";
+                        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: any;
-            };
-        };
-    }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-        "/oauth/:provider/callback": {
-            $post: {
+                status: 200;
                 input: {
                     param: {
-                        provider: string;
+                        sub: string;
                     };
-                } & {
-                    form: {
-                        code?: string | undefined;
-                        state?: string | undefined;
-                        error?: string | undefined;
-                        error_description?: string | undefined;
+                };
+            };
+        };
+    } & {
+        "/admin/users/:sub": {
+            $patch: {
+                output: {
+                    user: {
+                        managed_by: "config" | "database";
+                        sub: string;
+                        email: string;
+                        role: "admin" | "user";
+                        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;
                     };
                 };
-                output: undefined;
-                outputFormat: "redirect";
-                status: 302;
-            } | {
+                outputFormat: "json";
+                status: 200;
                 input: {
-                    param: {
-                        provider: string;
+                    json: {
+                        email?: string | undefined;
+                        role?: "admin" | "user" | undefined;
+                        email_verified?: boolean | undefined;
                     };
                 } & {
-                    form: {
-                        code?: string | undefined;
-                        state?: string | undefined;
-                        error?: string | undefined;
-                        error_description?: string | undefined;
+                    param: {
+                        sub: string;
                     };
                 };
-                output: {
-                    code: any;
-                    message: any;
-                };
-                outputFormat: "json";
-                status: any;
             };
         };
-    }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-        "/oauth/:provider": {
+    } & {
+        "/admin/users/:sub": {
             $delete: {
+                output: {
+                    user: {
+                        managed_by: "config" | "database";
+                        sub: string;
+                        email: string;
+                        role: "admin" | "user";
+                        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;
                 input: {
                     param: {
-                        provider: string;
+                        sub: string;
                     };
                 };
+            };
+        };
+    }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+        "/admin/overview": {
+            $get: {
                 output: {
-                    ok: true;
+                    metrics: {
+                        active_users: number;
+                        admins: number;
+                        active_clients: number;
+                        required_terms: number;
+                    };
+                    users: {
+                        source: {
+                            config: number;
+                            database: number;
+                        };
+                        authentication: {
+                            email_verified: number;
+                            two_factor: number;
+                            remaining: number;
+                        };
+                    };
+                    status: {
+                        database: string;
+                        email: string;
+                        password: boolean;
+                        passkey: boolean;
+                        totp: boolean;
+                    };
                 };
                 outputFormat: "json";
                 status: 200;
+                input: {};
             };
         };
-    }, "/">, "/">, "/api"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
-        "/authorize": {
+    } & {
+        "/admin/search": {
             $get: {
+                output: {
+                    users: {
+                        id: import("@mikro-orm/core").Opt<string>;
+                        title: string;
+                        subtitle: import("@mikro-orm/core").Opt<string>;
+                    }[];
+                    clients: {
+                        id: string & import("@mikro-orm/core").Opt.Brand;
+                        title: string;
+                        subtitle: string;
+                    }[];
+                    terms: {
+                        id: string;
+                        title: string;
+                        subtitle: string;
+                    }[];
+                };
+                outputFormat: "json";
+                status: 200;
                 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;
+                        q: string;
                     };
                 };
-                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;
-                    };
-                };
+    } & {
+        "/admin/system": {
+            $get: {
                 output: {
-                    device_code: string;
-                    user_code: string;
-                    verification_uri: string;
-                    verification_uri_complete: string;
-                    expires_in: number;
-                    interval: number;
+                    health: {
+                        database: string;
+                        email: string;
+                    };
+                    sections: ({
+                        id: string;
+                        values: {
+                            password_enabled: boolean;
+                            passkey_enabled: boolean;
+                            totp_enabled: boolean;
+                        };
+                    } | {
+                        id: string;
+                        values: {
+                            enabled: boolean;
+                            email_verification_required: boolean;
+                            allowed_email_patterns: string[];
+                        };
+                    } | {
+                        id: string;
+                        values: {
+                            min_length: number;
+                            max_length: number;
+                            two_factor_required: boolean;
+                        };
+                    } | {
+                        id: string;
+                        values: {
+                            access_token_ttl: number;
+                            refresh_token_ttl: number;
+                            key_rotation_enabled: boolean;
+                        };
+                    } | {
+                        id: string;
+                        values: {
+                            configured: string[];
+                        };
+                    } | {
+                        id: string;
+                        values: {
+                            account_deletion_enabled: boolean;
+                            account_deletion_retention: string;
+                        };
+                    } | {
+                        id: string;
+                        values: {
+                            supported: ("en" | "ja" | "ko")[];
+                            default: "auto" | "en" | "ja" | "ko";
+                            fallback: "en" | "ja" | "ko";
+                        };
+                    })[];
                 };
                 outputFormat: "json";
                 status: 200;
+                input: {};
             };
         };
-    }, "/"> | import("hono/types").MergeSchemaPath<{
-        "/device": {
+    } & {
+        "/admin/clients": {
             $get: {
-                input: {};
-                output: {};
-                outputFormat: string;
-                status: import("hono/utils/http-status").StatusCode;
+                output: {
+                    clients: {
+                        id: string;
+                        client_id: string;
+                        name: string;
+                        type: "confidential" | "public";
+                        grant_types: string[];
+                        response_types: string[];
+                        scopes: string[];
+                        redirect_uris: string[];
+                        post_logout_redirect_uris: string[];
+                        web_origins: string[];
+                        enabled: boolean;
+                        skip_consent: boolean;
+                        managed_by: "config" | "database";
+                        created_at: string;
+                        updated_at: string;
+                    }[];
+                    pagination: {
+                        page: number;
+                        page_size: number;
+                        total: number;
+                    };
+                };
+                outputFormat: "json";
+                status: 200;
+                input: {
+                    query: {
+                        query?: string | undefined;
+                        page?: string | string[];
+                        page_size?: string | string[];
+                        managed_by?: "config" | "database" | undefined;
+                        direction?: "asc" | "desc" | undefined;
+                        enabled?: string | string[];
+                        type?: "confidential" | "public" | undefined;
+                    };
+                };
             };
         };
     } & {
-        "/device": {
+        "/admin/clients": {
             $post: {
+                output: {
+                    client: {
+                        id: string;
+                        client_id: string;
+                        name: string;
+                        type: "confidential" | "public";
+                        grant_types: string[];
+                        response_types: string[];
+                        scopes: string[];
+                        redirect_uris: string[];
+                        post_logout_redirect_uris: string[];
+                        web_origins: string[];
+                        enabled: boolean;
+                        skip_consent: boolean;
+                        managed_by: "config" | "database";
+                        created_at: string;
+                        updated_at: string;
+                    };
+                    client_secret: string | undefined;
+                };
+                outputFormat: "json";
+                status: 201;
                 input: {
-                    form: {
-                        user_code: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
-                        decision?: "deny" | "approve" | undefined;
+                    json: {
+                        client_id: string;
+                        name: string;
+                        type: "confidential" | "public";
+                        redirect_uris: string[];
+                        post_logout_redirect_uris?: string[] | undefined;
+                        web_origins?: string[] | undefined;
+                        grant_types: string[];
+                        response_types: string[];
+                        scopes: string[];
+                        skip_consent?: boolean | undefined;
                     };
                 };
+            };
+        };
+    } & {
+        "/admin/clients/bulk-status": {
+            $post: {
                 output: {
-                    status: string;
-                    client_id: string;
+                    matched: number;
+                    changed: number;
+                    skipped: {
+                        [x: string]: number;
+                    };
                 };
                 outputFormat: "json";
-                status: import("hono/utils/http-status").ContentfulStatusCode;
+                status: 200;
+                input: {
+                    json: {
+                        target: {
+                            kind: "ids";
+                            ids: string[];
+                        } | {
+                            kind: "filter";
+                            filter: {
+                                query?: string | undefined;
+                                managed_by?: "config" | "database" | undefined;
+                                enabled?: boolean | undefined;
+                            };
+                        };
+                        active: boolean;
+                    };
+                };
             };
         };
-    }, "/"> | 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;
+    } & {
+        "/admin/clients/:id": {
+            $patch: {
+                output: {
+                    client: {
+                        id: string;
+                        client_id: string;
+                        name: string;
+                        type: "confidential" | "public";
+                        grant_types: string[];
+                        response_types: string[];
+                        scopes: string[];
+                        redirect_uris: string[];
+                        post_logout_redirect_uris: string[];
+                        web_origins: string[];
+                        enabled: boolean;
+                        skip_consent: boolean;
+                        managed_by: "config" | "database";
+                        created_at: string;
+                        updated_at: string;
                     };
                 };
-                output: undefined;
-                outputFormat: "redirect";
-                status: 302;
-            } | {
+                outputFormat: "json";
+                status: 200;
                 input: {
-                    query: {
-                        client_id?: string | undefined;
-                        post_logout_redirect_uri?: string | undefined;
-                        id_token_hint?: string | undefined;
-                        state?: string | undefined;
+                    json: {
+                        name: string;
+                        redirect_uris: string[];
+                        post_logout_redirect_uris?: string[] | undefined;
+                        web_origins?: string[] | undefined;
+                        grant_types: string[];
+                        response_types: string[];
+                        scopes: string[];
+                        skip_consent?: boolean | undefined;
+                    };
+                } & {
+                    param: {
+                        id: string;
                     };
                 };
+            } | {
                 output: {
                     error: string;
-                    error_description: string;
                 };
                 outputFormat: "json";
-                status: 400;
-            };
-        };
-    }, "/"> | import("hono/types").MergeSchemaPath<{
-        "/token": {
-            $post: {
+                status: 404;
                 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;
+                    json: {
+                        name: string;
+                        redirect_uris: string[];
+                        post_logout_redirect_uris?: string[] | undefined;
+                        web_origins?: string[] | undefined;
+                        grant_types: string[];
+                        response_types: string[];
+                        scopes: string[];
+                        skip_consent?: boolean | undefined;
+                    };
+                } & {
+                    param: {
+                        id: string;
                     };
                 };
+            };
+        };
+    } & {
+        "/admin/clients/:id/rotate-secret": {
+            $post: {
                 output: {
-                    access_token: string;
-                    token_type: "Bearer";
-                    expires_in: number;
-                    refresh_token?: string | undefined | undefined;
-                    id_token?: string | undefined | undefined;
-                    scope: string;
+                    client: {
+                        id: string;
+                        client_id: string;
+                        name: string;
+                        type: "confidential" | "public";
+                        grant_types: string[];
+                        response_types: string[];
+                        scopes: string[];
+                        redirect_uris: string[];
+                        post_logout_redirect_uris: string[];
+                        web_origins: string[];
+                        enabled: boolean;
+                        skip_consent: boolean;
+                        managed_by: "config" | "database";
+                        created_at: string;
+                        updated_at: string;
+                    };
+                    client_secret: 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;
+                    param: {
+                        id: string;
                     };
                 };
+            } | {
                 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;
+                    error: string;
                 };
                 outputFormat: "json";
-                status: 200;
-            };
-        };
-    }, "/"> | import("hono/types").MergeSchemaPath<{
-        "/revoke": {
-            $post: {
+                status: 404;
                 input: {
-                    form: {
-                        token: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
-                        token_type_hint?: string | undefined;
-                        client_id?: string | undefined;
-                        client_secret?: string | undefined;
+                    param: {
+                        id: string;
                     };
                 };
-                output: {};
-                outputFormat: "json";
-                status: 200;
             };
         };
-    }, "/"> | import("hono/types").MergeSchemaPath<{
-        "/userinfo": {
+    } & {
+        "/admin/terms": {
             $get: {
-                input: {};
                 output: {
-                    sub: string;
-                    email?: string | undefined;
-                    email_verified?: boolean | undefined;
-                    name?: string | undefined;
-                    picture?: string | undefined;
-                    preferred_username?: string | undefined;
+                    terms: {
+                        id: string;
+                        required: boolean;
+                        consent_mode: "explicit" | "implicit";
+                        version: string;
+                        managed_by: "config" | "database";
+                        archived_at: string | null;
+                        created_at: string;
+                        updated_at: string;
+                        contents: {
+                            lang: string;
+                            title: string;
+                            type: "link" | "text";
+                            content: string;
+                        }[];
+                    }[];
+                    pagination: {
+                        page: number;
+                        page_size: number;
+                        total: number;
+                    };
                 };
                 outputFormat: "json";
                 status: 200;
+                input: {
+                    query: {
+                        query?: string | undefined;
+                        page?: string | string[];
+                        page_size?: string | string[];
+                        managed_by?: "config" | "database" | undefined;
+                        direction?: "asc" | "desc" | undefined;
+                        required?: string | string[];
+                        consent_mode?: "explicit" | "implicit" | undefined;
+                        archived?: string | string[];
+                    };
+                };
             };
         };
     } & {
-        "/userinfo": {
+        "/admin/terms": {
             $post: {
-                input: {};
                 output: {
-                    sub: string;
-                    email?: string | undefined;
-                    email_verified?: boolean | undefined;
-                    name?: string | undefined;
-                    picture?: string | undefined;
-                    preferred_username?: string | undefined;
+                    term: {
+                        id: string;
+                        required: boolean;
+                        consent_mode: "explicit" | "implicit";
+                        version: string;
+                        managed_by: "config" | "database";
+                        archived_at: string | null;
+                        created_at: string;
+                        updated_at: string;
+                        contents: {
+                            lang: string;
+                            title: string;
+                            type: "link" | "text";
+                            content: string;
+                        }[];
+                    };
                 };
                 outputFormat: "json";
-                status: 200;
+                status: 201;
+                input: {
+                    json: {
+                        id: string;
+                        required: boolean;
+                        consent_mode: "explicit" | "implicit";
+                        version: string;
+                        contents: {
+                            lang: "en" | "ja" | "ko";
+                            title: string;
+                            type: "link" | "text";
+                            content: string;
+                        }[];
+                    };
+                };
             };
         };
-    }, "/"> | import("hono/types").MergeSchemaPath<{
-        "/.well-known/jwks": {
-            $get: {
-                input: {};
+    } & {
+        "/admin/terms/bulk-status": {
+            $post: {
                 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;
-                    }[];
+                    matched: number;
+                    changed: number;
+                    skipped: {
+                        [x: string]: number;
+                    };
                 };
                 outputFormat: "json";
                 status: 200;
+                input: {
+                    json: {
+                        target: {
+                            kind: "ids";
+                            ids: string[];
+                        } | {
+                            kind: "filter";
+                            filter: {
+                                query?: string | undefined;
+                                managed_by?: "config" | "database" | undefined;
+                                archived?: boolean | undefined;
+                            };
+                        };
+                        active: boolean;
+                    };
+                };
             };
         };
-    }, "/"> | import("hono/types").MergeSchemaPath<{
-        "/.well-known/openid-configuration": {
-            $get: {
-                input: {};
+    } & {
+        "/admin/terms/:id": {
+            $patch: {
                 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;
+                    term: {
+                        id: string;
+                        required: boolean;
+                        consent_mode: "explicit" | "implicit";
+                        version: string;
+                        managed_by: "config" | "database";
+                        archived_at: string | null;
+                        created_at: string;
+                        updated_at: string;
+                        contents: {
+                            lang: string;
+                            title: string;
+                            type: "link" | "text";
+                            content: string;
+                        }[];
+                    };
                 };
                 outputFormat: "json";
                 status: 200;
-            };
-        };
-    }, "/">, "/oauth"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
-        "/openid-configuration": {
-            $get: {
-                input: {};
+                input: {
+                    json: {
+                        required: boolean;
+                        consent_mode: "explicit" | "implicit";
+                        version: string;
+                        contents: {
+                            lang: "en" | "ja" | "ko";
+                            title: string;
+                            type: "link" | "text";
+                            content: string;
+                        }[];
+                    };
+                } & {
+                    param: {
+                        id: string;
+                    };
+                };
+            } | {
                 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;
+                    error: string;
                 };
                 outputFormat: "json";
-                status: 200;
+                status: 404;
+                input: {
+                    json: {
+                        required: boolean;
+                        consent_mode: "explicit" | "implicit";
+                        version: string;
+                        contents: {
+                            lang: "en" | "ja" | "ko";
+                            title: string;
+                            type: "link" | "text";
+                            content: string;
+                        }[];
+                    };
+                } & {
+                    param: {
+                        id: string;
+                    };
+                };
             };
         };
-    }, "/">, "/.well-known">, "/">, "/", "*">;
+    }, "/">, "/">, "/api">, "/">, "/", "*">;
     services: {
         config: {
             server: {
@@ -1608,13 +2202,16 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                 };
             };
             i18n: {
-                supported_languages: ("en" | "ko" | "ja")[];
-                default_language: "en" | "ko" | "ja" | "auto";
-                fallback_language: "en" | "ko" | "ja";
+                supported_languages: ("en" | "ja" | "ko")[];
+                default_language: "auto" | "en" | "ja" | "ko";
+                fallback_language: "en" | "ja" | "ko";
             };
             branding: {
-                title: Record<string, string>;
                 icon_url?: string | undefined;
+                logo_url?: string | undefined;
+                title: Record<string, string>;
+                subtitle: Record<string, string>;
+                login_method_description: Record<string, string>;
             };
             registration: {
                 enabled: boolean;
@@ -1630,7 +2227,7 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                 enabled: boolean;
             };
             logging: {
-                level: "error" | "trace" | "debug" | "info" | "warn" | "fatal" | "silent";
+                level: "debug" | "error" | "fatal" | "info" | "silent" | "trace" | "warn";
                 format: "json" | "pretty";
             };
             openapi: {
@@ -1661,7 +2258,7 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                 };
                 account_selection: {
                     enabled: boolean;
-                    mode: "always" | "oidc_prompt" | "disabled" | "smart";
+                    mode: "always" | "disabled" | "oidc_prompt" | "smart";
                     remember_accounts: {
                         enabled: boolean;
                         max_accounts: number;
@@ -1670,9 +2267,9 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                     allow_add_account: boolean;
                     allow_remove_account: boolean;
                     login_hint: {
-                        behavior: "prefer" | "ignore" | "require_match";
+                        behavior: "ignore" | "prefer" | "require_match";
                     };
-                    prompt_none_error: "login_required" | "account_selection_required";
+                    prompt_none_error: "account_selection_required" | "login_required";
                 };
             };
             security: {
@@ -1702,6 +2299,7 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                     retention: string;
                 };
             };
+            scheduler?: import("../lib/config/scheduler.ts").SchedulerRuntimeConfig | undefined;
             terms: {
                 id: string;
                 required: boolean;
@@ -1720,18 +2318,18 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
             clients: {
                 id: string;
                 name: string;
+                logo_uri?: string | undefined;
                 client_id: string;
+                client_secret?: string | undefined;
                 redirect_uris: string[];
                 post_logout_redirect_uris: string[];
                 web_origins: string[];
                 response_types: ("code" | "id_token")[];
-                grant_types: ("refresh_token" | "implicit" | "authorization_code" | "client_credentials" | "urn:ietf:params:oauth:grant-type:device_code")[];
+                grant_types: ("authorization_code" | "client_credentials" | "implicit" | "refresh_token" | "urn:ietf:params:oauth:grant-type:device_code")[];
                 scope: string;
                 skip_consent: boolean;
-                logo_uri?: string | undefined;
-                client_secret?: string | undefined;
                 account_selection?: {
-                    mode: "inherit" | "never" | "always" | "oidc_prompt" | "smart";
+                    mode: "always" | "inherit" | "never" | "oidc_prompt" | "smart";
                     allow_add_account?: boolean | undefined;
                 } | undefined;
             }[];
@@ -1739,20 +2337,26 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                 sub: string;
                 email: string;
                 password: string;
-                role: "user" | "admin";
+                role: "admin" | "user";
             }[];
             database: import("../lib/config/database.ts").DatabaseConfig;
+            email?: import("../lib/config/email.ts").EmailConfig | undefined;
             identity_providers: {
                 id: string;
-                type: "github" | "google" | "apple" | "generic_oauth";
+                type: "apple" | "generic_oauth" | "github" | "google";
                 enabled: boolean;
                 display_name: string;
+                icon_url?: string | undefined;
                 client_id: string;
                 client_secret: string;
                 authorization_url: string;
                 token_url: string;
                 userinfo_url: string | null;
+                jwks_url?: string | undefined;
+                issuer?: string | undefined;
+                email_url?: string | undefined;
                 scopes: string[];
+                response_mode?: string | undefined;
                 email_conflict_strategy: "auto_link" | "require_link";
                 userinfo_mapping: {
                     id: string;
@@ -1761,15 +2365,7 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
                     name?: string | undefined;
                     picture?: string | undefined;
                 };
-                icon_url?: string | undefined;
-                jwks_url?: string | undefined;
-                issuer?: string | undefined;
-                email_url?: string | undefined;
-                response_mode?: string | undefined;
             }[];
-            scheduler?: import("../lib/config/scheduler.ts").SchedulerRuntimeConfig | 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;
@@ -1788,6 +2384,7 @@ export declare function createApp(options: CreateAppOptions, runtimeOptions?: Cr
         oauthConnectService: import("../services/oauth-connect.service.ts").OAuthConnectService;
         oauthTokenService: import("../services/oauth-token.service.ts").OAuthTokenService;
         cleanupService: import("../services/cleanup.service.ts").CleanupService;
+        adminConsoleService: import("../services/admin-console.service.ts").AdminConsoleService;
     };
     cleanup: () => Promise<void>;
     logger: import("pino").Logger<never, boolean>;