@tinyrack/issuary-server 0.26.0 → 0.28.0

package/dist/routes/index.d.ts

@@ -1,144 +1,345 @@
 import type { AppEnv } from '../lib/app-env.ts';
-export declare const routes: import("hono/hono-base").HonoBase<AppEnv, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/admin/me": {
+export declare const routes: import("hono/hono-base").HonoBase<AppEnv, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/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<{
+    "/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: {
-                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;
+                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<import("hono/types").MergeSchemaPath<{
-    "/admin/users": {
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/end_session": {
         $get: {
+            output: undefined;
+            outputFormat: "redirect";
+            status: 302;
             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;
+                    client_id?: string | undefined;
+                    post_logout_redirect_uri?: string | undefined;
+                    id_token_hint?: string | undefined;
+                    state?: string | undefined;
                 };
             };
+        } | {
             output: {
-                users: {
-                    managed_by: "database" | "config";
-                    sub: string;
-                    email: string;
-                    role: "user" | "admin";
-                    email_verified: boolean;
-                    email_verification_required: boolean;
-                    has_password: boolean;
-                    totp_registered: boolean;
-                    totp_recovery_codes_missing: boolean;
-                    second_factor_required: boolean;
-                    passkey_count: number;
-                    deleted_at: string | null;
-                }[];
-                pagination: {
-                    page: number;
-                    page_size: number;
-                    total: number;
+                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<{
+    "/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;
+                };
+            };
         };
     };
-} & {
-    "/admin/users": {
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/revoke": {
         $post: {
+            output: {};
+            outputFormat: "json";
+            status: 200;
             input: {
-                json: {
-                    email: string;
-                    password: string;
-                    role?: "user" | "admin" | undefined;
-                    email_verified?: boolean | undefined;
+                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: {
-                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;
-                };
+                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: 201;
+            status: 200;
+            input: {};
         };
     };
-} & {
-    "/admin/users/:sub": {
+}, "/"> | 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: {
-                param: {
-                    sub: string;
+                form: {
+                    user_code: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue;
+                    decision?: "approve" | "deny" | undefined;
                 };
             };
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/userinfo": {
+        $get: {
             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;
-                };
+                sub: string;
+                email?: string | undefined;
+                email_verified?: boolean | undefined;
+                name?: string | undefined;
+                picture?: string | undefined;
+                preferred_username?: string | undefined;
             };
             outputFormat: "json";
             status: 200;
+            input: {};
         };
     };
 } & {
-    "/admin/users/:sub": {
-        $patch: {
+    "/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<{
+    "/auth/accounts/remove": {
+        $post: {
+            output: {
+                code: string;
+                message: string;
+            };
+            outputFormat: "json";
+            status: 400;
             input: {
                 json: {
-                    email?: string | undefined;
-                    role?: "user" | "admin" | undefined;
-                    email_verified?: boolean | undefined;
+                    sub: string;
                 };
-            } & {
-                param: {
+            };
+        } | {
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+            input: {
+                json: {
                     sub: string;
                 };
             };
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/auth/login": {
+        $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;
@@ -146,27 +347,46 @@ export declare const routes: import("hono/hono-base").HonoBase<AppEnv, import("h
                     totp_recovery_codes_missing: boolean;
                     second_factor_required: boolean;
                     passkey_count: number;
-                    deleted_at: string | null;
                 };
             };
             outputFormat: "json";
             status: 200;
+            input: {
+                json: {
+                    email: string;
+                    password: string;
+                };
+            };
         };
     };
-} & {
-    "/admin/users/:sub": {
-        $delete: {
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/auth/password/forgot": {
+        $post: {
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
             input: {
-                param: {
-                    sub: string;
+                header: {
+                    'accept-language'?: string | undefined;
+                };
+            } & {
+                json: {
+                    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;
@@ -174,229 +394,382 @@ export declare const routes: import("hono/hono-base").HonoBase<AppEnv, import("h
                     totp_recovery_codes_missing: boolean;
                     second_factor_required: boolean;
                     passkey_count: number;
-                    deleted_at: string | null;
                 };
             };
             outputFormat: "json";
             status: 200;
+            input: {
+                json: {
+                    code: string;
+                };
+            };
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/auth/accounts": {
+    "/config": {
         $get: {
-            input: {
-                query: {
-                    client_id?: string | undefined;
+            output: {
+                i18n: {
+                    supported_languages: string[];
+                    default_language: string;
+                    fallback_language: string;
+                };
+                branding: {
+                    icon_url?: string | undefined;
+                    logo_url?: string | undefined;
+                    title: {
+                        [x: string]: string;
+                    };
+                    subtitle: {
+                        [x: string]: string;
+                    };
+                    login_method_description: {
+                        [x: string]: string;
+                    };
+                };
+                registration: {
+                    public_registration: boolean;
+                    email_pattern_filter_enabled: boolean;
+                    email_verification_required: boolean;
+                    signup_notice?: {
+                        [x: string]: string;
+                    } | undefined;
+                };
+                database: {
+                    enabled: boolean;
+                };
+                email: {
+                    enabled: boolean;
+                };
+                admin: {
+                    enabled: boolean;
+                };
+                auth: {
+                    password: {
+                        enabled: boolean;
+                        two_factor: {
+                            enrollment_required: boolean;
+                        };
+                        totp: {
+                            enabled: boolean;
+                            issuer: string;
+                        };
+                        policy: {
+                            min_length: number;
+                            max_length: number;
+                        };
+                    };
+                    passkey: {
+                        enabled: boolean;
+                        rp_id?: string | undefined;
+                        origins?: string[] | undefined;
+                    };
+                };
+                identity_providers: {
+                    id: string;
+                    type: "apple" | "generic_oauth" | "github" | "google";
+                    display_name: string;
+                    icon_url?: string | undefined;
+                }[];
+                account_deletion: {
+                    enabled: boolean;
+                    retention: string;
                 };
             };
+            outputFormat: "json";
+            status: 200;
+            input: {};
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/consent": {
+        $get: {
             output: {
-                active_sub: string | null;
-                accounts: {
+                client: {
+                    id: string;
+                    clientId: string;
+                    name: string;
+                };
+                scopes: {
+                    name: string;
+                    description: string;
+                }[];
+                user: {
                     sub: import("@mikro-orm/core").Opt<string>;
                     email: string;
-                    role: import("@mikro-orm/core").Opt<NonNullable<"user" | "admin">>;
-                    current: boolean;
-                    authenticated_at: number;
-                    last_used_at: number;
-                }[];
-                allow_add_account: boolean;
-                allow_remove_account: boolean;
+                };
             };
             outputFormat: "json";
             status: 200;
+            input: {
+                query: {
+                    client_id: string | string[];
+                    scope?: string | undefined;
+                };
+            };
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/auth/accounts/select": {
+    "/consent": {
         $post: {
+            output: {
+                redirect_url: string;
+            };
+            outputFormat: "json";
+            status: 200;
             input: {
                 json: {
-                    sub: string;
+                    client_id: string;
+                    redirect_uri: string;
+                    response_type: string;
+                    scope?: string | undefined;
+                    state?: string | undefined;
+                    nonce?: string | undefined;
+                    code_challenge?: string | undefined;
+                    code_challenge_method?: "S256" | "plain" | undefined;
+                    prompt?: string | undefined;
+                    max_age?: unknown;
+                    reauthenticated?: "1" | undefined;
+                    display?: "page" | "popup" | "touch" | "wap" | undefined;
+                    response_mode?: "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";
                 };
             };
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/health/live": {
+        $get: {
             output: {
-                code: string;
-                message: string;
+                status: 'ok';
             };
             outputFormat: "json";
-            status: 400;
+            status: 200;
+            input: {};
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/oauth/:provider/callback": {
+        $get: {
+            output: undefined;
+            outputFormat: "redirect";
+            status: 302;
+            input: {
+                param: {
+                    provider: string;
+                };
+            } & {
+                query: {
+                    code?: string | undefined;
+                    state?: string | undefined;
+                    error?: string | undefined;
+                    error_description?: string | undefined;
+                };
+            };
         } | {
+            output: {
+                code: any;
+                message: any;
+            };
+            outputFormat: "json";
+            status: any;
             input: {
-                json: {
-                    sub: string;
+                param: {
+                    provider: string;
+                };
+            } & {
+                query: {
+                    code?: string | undefined;
+                    state?: string | undefined;
+                    error?: string | undefined;
+                    error_description?: string | undefined;
+                };
+            };
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/oauth/authorization-context": {
+        $get: {
+            output: {
+                client: {
+                    id: string;
+                    clientId: string;
+                    name: string;
+                };
+                redirect_uri: string;
+                redirect_origin: string;
+                scopes: {
+                    name: string;
+                    description: string;
+                }[];
+            };
+            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" | "login" | "register" | undefined;
+                    return_url?: string | undefined;
                 };
             };
-            output: {
-                ok: true;
-                active_sub: string;
-            };
-            outputFormat: "json";
-            status: 200;
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/auth/accounts/remove": {
+    "/oauth/:provider/callback": {
         $post: {
+            output: undefined;
+            outputFormat: "redirect";
+            status: 302;
             input: {
-                json: {
-                    sub: string;
+                param: {
+                    provider: string;
+                };
+            } & {
+                form: {
+                    code?: string | undefined;
+                    state?: string | undefined;
+                    error?: string | undefined;
+                    error_description?: string | undefined;
                 };
             };
+        } | {
             output: {
-                code: string;
-                message: string;
+                code: any;
+                message: any;
             };
             outputFormat: "json";
-            status: 400;
-        } | {
+            status: any;
             input: {
-                json: {
-                    sub: string;
+                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<{
+    "/oauth/:provider": {
+        $delete: {
             output: {
                 ok: true;
             };
             outputFormat: "json";
             status: 200;
+            input: {
+                param: {
+                    provider: string;
+                };
+            };
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/auth/2fa/methods": {
-        $get: {
-            input: {};
+    "/user": {
+        $delete: {
             output: {
-                methods: ("totp" | "passkey")[];
+                ok: true;
+                deleted_at: string;
+                permanent_deletion_at: string;
             };
             outputFormat: "json";
             status: 200;
+            input: {};
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/auth/login": {
-        $post: {
-            input: {
-                json: {
-                    email: string;
-                    password: string;
-                };
-            };
+    "/user/passkeys": {
+        $get: {
             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;
-                };
+                passkeys: {
+                    id: string;
+                    credential_id: string;
+                    name: string | null;
+                    device_type: 'singleDevice' | 'multiDevice';
+                    backed_up: boolean;
+                    created_at: string;
+                }[];
             };
             outputFormat: "json";
             status: 200;
+            input: {};
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/auth/logout": {
+    "/user/password": {
         $post: {
-            input: {};
             output: {
                 ok: true;
             };
             outputFormat: "json";
             status: 200;
-        };
-    };
-}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/auth/register": {
-        $post: {
             input: {
-                header: {
-                    'accept-language'?: string | undefined;
-                };
-            } & {
                 json: {
-                    email: string;
                     password: string;
-                    consents?: {
-                        termsId: string;
-                        agreed: boolean;
-                        consentType?: "explicit" | "implicit" | undefined;
-                    }[] | undefined;
-                };
-            };
-            output: {
-                user: {
-                    managed_by: "database" | "config";
-                    sub: string;
-                    email: string;
-                    role: "user" | "admin";
-                    email_verified: boolean;
-                    email_verification_required: boolean;
-                    has_password: boolean;
-                    totp_registered: boolean;
-                    totp_recovery_codes_missing: boolean;
-                    second_factor_required: boolean;
-                    passkey_count: number;
                 };
             };
-            outputFormat: "json";
-            status: 200;
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/auth/password/forgot": {
-        $post: {
-            input: {
-                header: {
-                    'accept-language'?: string | undefined;
-                };
-            } & {
-                json: {
-                    email: string;
-                };
-            };
+    "/user/totp": {
+        $delete: {
             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;
+                    code: string;
                 };
             };
-            output: {
-                message: string;
-            };
-            outputFormat: "json";
-            status: 200;
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/auth/email/verify": {
-        $post: {
-            input: {
-                json: {
-                    token: string;
-                };
+    "/user/session": {
+        $get: {
+            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;
@@ -408,135 +781,97 @@ export declare const routes: import("hono/hono-base").HonoBase<AppEnv, import("h
             };
             outputFormat: "json";
             status: 200;
+            input: {};
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/auth/email/resend": {
-        $post: {
-            input: {
-                header: {
-                    'accept-language'?: string | undefined;
-                };
-            } & {
-                json: {
-                    email: string;
-                };
-            };
+    "/user/password": {
+        $put: {
             output: {
-                message: string;
+                ok: true;
             };
             outputFormat: "json";
             status: 200;
-        };
-    };
-}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/auth/totp/verify": {
-        $post: {
             input: {
                 json: {
-                    code: string;
+                    current_password: string;
+                    new_password: string;
                 };
             };
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/user/password": {
+        $delete: {
             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/totp/recovery/verify": {
-        $post: {
             input: {
                 json: {
-                    code: string;
+                    current_password: string;
                 };
             };
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/user/oauth-accounts": {
+        $get: {
             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;
-                };
+                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: {};
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/auth/passkey/options": {
-        $post: {
-            input: {};
-            output: {
-                options: {
-                    challenge: import("@simplewebauthn/server").Base64URLString;
-                    timeout?: number | undefined;
-                    rpId?: string | undefined;
-                    allowCredentials?: {
-                        id: import("@simplewebauthn/server").Base64URLString;
-                        type: import("@simplewebauthn/server").PublicKeyCredentialType;
-                        transports?: import("@simplewebauthn/server").AuthenticatorTransportFuture[] | undefined;
-                    }[] | undefined;
-                    userVerification?: import("@simplewebauthn/server").UserVerificationRequirement | undefined;
-                    hints?: import("@simplewebauthn/server").PublicKeyCredentialHint[] | undefined;
-                    extensions?: {
-                        appid?: string | undefined;
-                        credProps?: boolean | undefined;
-                        hmacCreateSecret?: boolean | undefined;
-                        minPinLength?: boolean | undefined;
-                    } | undefined;
-                };
+    "/user/totp/setup": {
+        $post: {
+            output: {
+                secret: string;
+                otpauth_url: string;
+                qr_code: string;
             };
             outputFormat: "json";
             status: 200;
+            input: {};
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/auth/passkey/verify": {
+    "/user/totp/verify": {
         $post: {
+            output: {
+                recovery_codes: string[];
+            };
+            outputFormat: "json";
+            status: 200;
             input: {
                 json: {
-                    response: {
-                        id: string;
-                        rawId: string;
-                        response: {
-                            clientDataJSON: string;
-                            authenticatorData: string;
-                            signature: string;
-                            userHandle?: string | undefined;
-                        };
-                        clientExtensionResults: Record<string, unknown>;
-                        type: "public-key";
-                        authenticatorAttachment?: "platform" | "cross-platform" | undefined;
-                    };
+                    code: string;
                 };
             };
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/user/totp/confirm": {
+        $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;
@@ -548,293 +883,257 @@ export declare const routes: import("hono/hono-base").HonoBase<AppEnv, import("h
             };
             outputFormat: "json";
             status: 200;
+            input: {
+                json?: Record<string, never> | null | undefined;
+            };
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/config": {
-        $get: {
-            input: {};
+    "/user/totp/recovery/regenerate": {
+        $post: {
             output: {
-                i18n: {
-                    supported_languages: string[];
-                    default_language: string;
-                    fallback_language: string;
-                };
-                branding: {
-                    icon_url?: string | undefined;
-                    title?: {
-                        [x: string]: string;
-                    } | undefined;
-                };
-                registration: {
-                    public_registration: boolean;
-                    email_pattern_filter_enabled: boolean;
-                    email_verification_required: boolean;
-                    signup_notice?: {
-                        [x: string]: string;
-                    } | undefined;
-                };
-                database: {
-                    enabled: boolean;
-                };
-                email: {
-                    enabled: boolean;
-                };
-                admin: {
-                    enabled: boolean;
-                };
-                auth: {
-                    password: {
-                        enabled: boolean;
-                        two_factor: {
-                            enrollment_required: boolean;
-                        };
-                        totp: {
-                            enabled: boolean;
-                            issuer: string;
-                        };
-                        policy: {
-                            min_length: number;
-                            max_length: number;
-                        };
-                    };
-                    passkey: {
-                        enabled: boolean;
-                        rp_id?: string | undefined;
-                        origins?: string[] | undefined;
-                    };
-                };
-                identity_providers: {
-                    id: string;
-                    type: "github" | "google" | "apple" | "generic_oauth";
-                    display_name: string;
-                    icon_url?: string | undefined;
-                }[];
-                account_deletion: {
-                    enabled: boolean;
-                    retention: string;
-                };
+                recovery_codes: string[];
             };
             outputFormat: "json";
             status: 200;
+            input: {
+                json: {
+                    code: string;
+                };
+            };
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/consent": {
-        $get: {
+    "/user/passkeys/:id": {
+        $delete: {
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
             input: {
-                query: {
-                    client_id: string | string[];
-                    scope?: string | undefined;
+                param: {
+                    id: string;
                 };
             };
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/user/passkeys/:id": {
+        $patch: {
             output: {
-                client: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+            input: {
+                param: {
                     id: string;
-                    clientId: string;
-                    name: string;
                 };
-                scopes: {
+            } & {
+                json: {
                     name: string;
-                    description: string;
-                }[];
-                user: {
-                    sub: import("@mikro-orm/core").Opt<string>;
-                    email: string;
                 };
             };
-            outputFormat: "json";
-            status: 200;
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/consent": {
+    "/user/passkeys/register/options": {
         $post: {
-            input: {
-                json: {
-                    client_id: string;
-                    redirect_uri: string;
-                    response_type: string;
-                    decision: "allow" | "deny";
-                    scope?: string | undefined;
-                    state?: string | undefined;
-                    nonce?: string | undefined;
-                    code_challenge?: string | undefined;
-                    code_challenge_method?: "S256" | "plain" | undefined;
-                    prompt?: string | undefined;
-                    max_age?: unknown;
-                    reauthenticated?: "1" | undefined;
-                    display?: "page" | "popup" | "touch" | "wap" | undefined;
-                    response_mode?: "query" | "fragment" | "form_post" | undefined;
-                    login_hint?: string | undefined;
-                    ui_locales?: string | undefined;
-                    id_token_hint?: string | undefined;
-                    acr_values?: string | undefined;
-                    account_selected?: unknown;
-                    account_selection_state?: string | undefined;
-                };
-            };
             output: {
-                redirect_url: string;
+                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: {};
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/health": {
-        $get: {
-            input: {};
+    "/user/passkeys/register/verify": {
+        $post: {
             output: {
-                status: "ok";
-                uptime: number;
-                checks: {
-                    database: "ok";
+                ok: true;
+                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;
                 };
+                second_factor_setup_completed: true;
             };
             outputFormat: "json";
             status: 200;
+            input: {
+                json: {
+                    response: Record<string, any>;
+                    name?: string | undefined;
+                };
+            };
         } | {
-            input: {};
             output: {
-                status: "error";
-                uptime: number;
-                checks: {
-                    database: "error";
-                };
-                error: string | undefined;
+                ok: true;
+                second_factor_setup_completed: false;
             };
             outputFormat: "json";
-            status: 503;
+            status: 200;
+            input: {
+                json: {
+                    response: Record<string, any>;
+                    name?: string | undefined;
+                };
+            };
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/health/ready": {
+    "/admin/me": {
         $get: {
-            input: {};
-            output: {
-                status: "ok";
-                checks: {
-                    database: "ok";
-                };
-            };
-            outputFormat: "json";
-            status: 200;
-        } | {
-            input: {};
             output: {
-                status: "error";
-                checks: {
-                    database: "error";
+                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;
                 };
-                error: string | undefined;
             };
             outputFormat: "json";
-            status: 503;
+            status: 200;
+            input: {};
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/health/live": {
+    "/auth/accounts": {
         $get: {
-            input: {};
             output: {
-                status: "ok";
+                active_sub: string | null;
+                accounts: {
+                    sub: import("@mikro-orm/core").Opt<string>;
+                    email: string;
+                    role: import("@mikro-orm/core").Opt<NonNullable<"admin" | "user">>;
+                    current: boolean;
+                    authenticated_at: number;
+                    last_used_at: number;
+                }[];
+                allow_add_account: boolean;
+                allow_remove_account: boolean;
             };
             outputFormat: "json";
             status: 200;
-        };
-    };
-}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/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;
+                    client_id?: string | undefined;
                 };
             };
-            output: {
-                terms: {
-                    userConsent: {
-                        agreedAt: string | null;
-                        agreed: boolean;
-                        agreedVersion: string | null;
-                        consentType: "explicit" | "implicit" | null;
-                        requiresUpdate: boolean;
-                    } | null;
-                    id: string;
-                    required: boolean;
-                    consentMode: "explicit" | "implicit";
-                    version: string;
-                    title: string;
-                    type: import("../services/terms.service.ts").TermsContentType;
-                    content: string;
-                }[];
-                pendingTerms: string[];
-            };
-            outputFormat: "json";
-            status: 200;
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/terms/consent": {
+    "/auth/accounts/select": {
         $post: {
+            output: {
+                code: string;
+                message: string;
+            };
+            outputFormat: "json";
+            status: 400;
             input: {
                 json: {
-                    consents: {
-                        termsId: string;
-                        agreed: boolean;
-                        consentType?: "explicit" | "implicit" | undefined;
-                    }[];
-                    registrationToken?: string | undefined;
+                    sub: string;
                 };
             };
+        } | {
             output: {
                 ok: true;
-                recorded: number;
+                active_sub: string;
             };
             outputFormat: "json";
             status: 200;
+            input: {
+                json: {
+                    sub: string;
+                };
+            };
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/user": {
-        $delete: {
-            input: {};
+    "/auth/2fa/methods": {
+        $get: {
             output: {
-                ok: true;
-                deleted_at: string;
-                permanent_deletion_at: string;
+                methods: ("passkey" | "totp")[];
             };
             outputFormat: "json";
             status: 200;
+            input: {};
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/user/session": {
-        $get: {
-            input: {};
+    "/auth/logout": {
+        $post: {
             output: {
-                user: null;
+                ok: true;
             };
             outputFormat: "json";
             status: 200;
-        } | {
             input: {};
+        };
+    };
+}, "/">, "/"> | 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;
@@ -846,114 +1145,149 @@ export declare const routes: import("hono/hono-base").HonoBase<AppEnv, import("h
             };
             outputFormat: "json";
             status: 200;
-        };
-    };
-}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/user/password": {
-        $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/password/reset": {
+        $post: {
             output: {
-                ok: true;
+                message: string;
             };
             outputFormat: "json";
             status: 200;
-        };
-    };
-}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/user/password": {
-        $put: {
             input: {
                 json: {
-                    current_password: string;
-                    new_password: string;
+                    token: string;
+                    password: string;
                 };
             };
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/auth/email/verify": {
+        $post: {
             output: {
-                ok: true;
+                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;
-        };
-    };
-}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/user/password": {
-        $delete: {
             input: {
                 json: {
-                    current_password: string;
+                    token: string;
                 };
             };
-            output: {
-                ok: true;
-            };
-            outputFormat: "json";
-            status: 200;
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/user/oauth-accounts": {
-        $get: {
-            input: {};
+    "/auth/email/resend": {
+        $post: {
             output: {
-                accounts: {
-                    provider_name: string;
-                    linked_at: string;
-                }[];
-                available_providers: {
-                    id: string;
-                    display_name: string;
-                    icon_url: string | undefined;
-                    linked: boolean;
-                }[];
+                message: string;
             };
             outputFormat: "json";
             status: 200;
+            input: {
+                header: {
+                    'accept-language'?: string | undefined;
+                };
+            } & {
+                json: {
+                    email: string;
+                };
+            };
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/user/totp/setup": {
+    "/auth/totp/verify": {
         $post: {
-            input: {};
             output: {
-                secret: string;
-                otpauth_url: string;
-                qr_code: string;
+                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;
-        };
-    };
-}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/user/totp/verify": {
-        $post: {
             input: {
                 json: {
                     code: string;
                 };
             };
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/auth/passkey/options": {
+        $post: {
             output: {
-                recovery_codes: string[];
+                options: {
+                    challenge: import("@simplewebauthn/server").Base64URLString;
+                    timeout?: number;
+                    rpId?: string;
+                    allowCredentials?: {
+                        id: import("@simplewebauthn/server").Base64URLString;
+                        type: import("@simplewebauthn/server").PublicKeyCredentialType;
+                        transports?: import("@simplewebauthn/server").AuthenticatorTransportFuture[];
+                    }[] | undefined;
+                    userVerification?: import("@simplewebauthn/server").UserVerificationRequirement;
+                    hints?: import("@simplewebauthn/server").PublicKeyCredentialHint[];
+                    extensions?: {
+                        appid?: string;
+                        credProps?: boolean;
+                        hmacCreateSecret?: boolean;
+                        minPinLength?: boolean;
+                    } | undefined;
+                };
             };
             outputFormat: "json";
             status: 200;
+            input: {};
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/user/totp/confirm": {
+    "/auth/passkey/verify": {
         $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;
@@ -965,153 +1299,147 @@ export declare const routes: import("hono/hono-base").HonoBase<AppEnv, import("h
             };
             outputFormat: "json";
             status: 200;
+            input: {
+                json: {
+                    response: {
+                        id: string;
+                        rawId: string;
+                        response: {
+                            clientDataJSON: string;
+                            authenticatorData: string;
+                            signature: string;
+                            userHandle?: string | undefined;
+                        };
+                        authenticatorAttachment?: "cross-platform" | "platform" | undefined;
+                        clientExtensionResults: Record<string, unknown>;
+                        type: "public-key";
+                    };
+                };
+            };
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/user/totp/recovery/regenerate": {
-        $post: {
-            input: {
-                json: {
-                    code: string;
+    "/docs": {
+        $get: {
+            output: {};
+            outputFormat: string;
+            status: import("hono/utils/http-status").StatusCode;
+            input: {};
+        };
+    };
+}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
+    "/health": {
+        $get: {
+            output: {
+                status: 'ok';
+                uptime: number;
+                checks: {
+                    database: 'ok';
                 };
             };
+            outputFormat: "json";
+            status: 200;
+            input: {};
+        } | {
             output: {
-                recovery_codes: string[];
+                status: 'error';
+                uptime: number;
+                checks: {
+                    database: "error";
+                };
+                error: string | undefined;
             };
             outputFormat: "json";
-            status: 200;
+            status: 503;
+            input: {};
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/user/totp": {
-        $delete: {
-            input: {
-                json: {
-                    code: string;
+    "/health/ready": {
+        $get: {
+            output: {
+                status: 'ok';
+                checks: {
+                    database: 'ok';
                 };
             };
+            outputFormat: "json";
+            status: 200;
+            input: {};
+        } | {
             output: {
-                ok: true;
+                status: 'error';
+                checks: {
+                    database: "error";
+                };
+                error: string | undefined;
             };
             outputFormat: "json";
-            status: 200;
+            status: 503;
+            input: {};
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/user/passkeys": {
+    "/terms": {
         $get: {
-            input: {};
             output: {
-                passkeys: {
+                terms: {
                     id: string;
-                    credential_id: string;
-                    name: string | null;
-                    device_type: "singleDevice" | "multiDevice";
-                    backed_up: boolean;
-                    created_at: string;
+                    required: boolean;
+                    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<{
-    "/user/passkeys/:id": {
-        $delete: {
             input: {
-                param: {
-                    id: string;
+                query: {
+                    lang?: string | undefined;
                 };
             };
-            output: {
-                ok: true;
-            };
-            outputFormat: "json";
-            status: 200;
         };
     };
 }, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/user/passkeys/:id": {
-        $patch: {
-            input: {
-                param: {
-                    id: string;
-                };
-            } & {
-                json: {
-                    name: string;
-                };
-            };
+    "/terms/consent": {
+        $post: {
             output: {
                 ok: true;
+                recorded: number;
             };
             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;
+            input: {
+                json: {
+                    consents: {
+                        termsId: string;
+                        agreed: boolean;
+                        consentType?: "explicit" | "implicit" | undefined;
                     }[];
-                    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;
+                    registrationToken?: string | 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;
-                };
-            };
+    "/admin/users": {
+        $get: {
             output: {
-                ok: true;
-                user: {
-                    managed_by: "database" | "config";
+                users: {
+                    managed_by: "config" | "database";
                     sub: string;
                     email: string;
-                    role: "user" | "admin";
+                    role: "admin" | "user";
                     email_verified: boolean;
                     email_verification_required: boolean;
                     has_password: boolean;
@@ -1119,469 +1447,732 @@ export declare const routes: import("hono/hono-base").HonoBase<AppEnv, import("h
                     totp_recovery_codes_missing: boolean;
                     second_factor_required: boolean;
                     passkey_count: number;
+                    deleted_at: string | null;
+                }[];
+                pagination: {
+                    page: number;
+                    page_size: number;
+                    total: number;
                 };
-                second_factor_setup_completed: true;
             };
             outputFormat: "json";
             status: 200;
-        } | {
             input: {
-                json: {
-                    response: Record<string, any>;
-                    name?: string | undefined;
+                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: {
-                ok: true;
-                second_factor_setup_completed: false;
+                matched: number;
+                changed: number;
+                skipped: {
+                    [x: string]: number;
+                };
             };
             outputFormat: "json";
             status: 200;
-        };
-    };
-}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/oauth/authorization-context": {
-        $get: {
             input: {
-                query: {
-                    client_id: string | string[];
-                    redirect_uri: string | string[];
-                    response_type: string | string[];
-                    scope?: string | undefined;
+                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: {
-                client: {
-                    id: string;
-                    clientId: string;
-                    name: string;
+                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;
                 };
-                redirect_uri: string;
-                redirect_origin: string;
-                scopes: {
-                    name: string;
-                    description: string;
-                }[];
             };
             outputFormat: "json";
             status: 200;
-        };
-    };
-}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/oauth/:provider/authorize": {
-        $get: {
             input: {
                 param: {
-                    provider: string;
-                };
-            } & {
-                query: {
-                    mode?: "link" | "register" | "login" | undefined;
-                    return_url?: string | undefined;
+                    sub: string;
                 };
             };
-            output: undefined;
-            outputFormat: "redirect";
-            status: 302;
         };
     };
-}, "/">, "/"> | import("hono/types").MergeSchemaPath<import("hono/types").MergeSchemaPath<{
-    "/oauth/:provider/callback": {
-        $get: {
-            input: {
-                param: {
-                    provider: string;
-                };
-            } & {
-                query: {
-                    code?: string | undefined;
-                    state?: string | undefined;
-                    error?: string | undefined;
-                    error_description?: string | undefined;
+} & {
+    "/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;
                 };
             };
-            output: undefined;
-            outputFormat: "redirect";
-            status: 302;
-        } | {
+            outputFormat: "json";
+            status: 201;
             input: {
-                param: {
-                    provider: string;
-                };
-            } & {
-                query: {
-                    code?: string | undefined;
-                    state?: string | undefined;
-                    error?: string | undefined;
-                    error_description?: string | undefined;
+                json: {
+                    email: string;
+                    password: string;
+                    role?: "admin" | "user" | undefined;
+                    email_verified?: boolean | undefined;
                 };
             };
+        };
+    };
+} & {
+    "/admin/users/:sub": {
+        $get: {
             output: {
-                code: any;
-                message: any;
+                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">, "/", "/">;
 //# sourceMappingURL=index.d.ts.map