@absolutejs/auth 0.57.9 → 0.59.0

package/dist/index.d.ts

@@ -1,3637 +0,0 @@
-import { Elysia } from 'elysia';
-import type { AuthConfig } from './types';
-export declare const auth: <UserType>(configuration: AuthConfig<UserType>) => Promise<Elysia<"", {
-    decorator: {};
-    store: {
-        session: import("./types").SessionRecord<UserType>;
-        unregisteredSession: import("./types").UnregisteredSessionRecord;
-    };
-    derive: ({
-        readonly protectRoute: <AuthReturn, AuthFailReturn = never>(handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
-            readonly code: "Bad Request";
-            readonly message: "Cookies are missing";
-        } | {
-            readonly code: "Unauthorized";
-            readonly message: "User is not authenticated";
-        }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
-    } & {
-        readonly requireRecentAuth: <AuthReturn, AuthFailReturn_1>(maxAgeMs: number, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
-            readonly code: "Unauthorized";
-            readonly message: "Recent authentication required";
-        }) => AuthFailReturn_1) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "Recent authentication required", 401> | AuthReturn | NonNullable<AuthFailReturn_1>>;
-    } & {
-        readonly protectAgent: <AuthReturn, AuthFailReturn_2>(requiredScopes: string[], handleAuth: (principal: import(".").AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: {
-            code: "Forbidden" | "Unauthorized";
-            message: "Agent is not authenticated" | "Insufficient agent scopes";
-        }) => AuthFailReturn_2 | Promise<AuthFailReturn_2>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn_2>>>;
-    }) | ({
-        readonly protectRoute: <AuthReturn, AuthFailReturn = never>(handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
-            readonly code: "Bad Request";
-            readonly message: "Cookies are missing";
-        } | {
-            readonly code: "Unauthorized";
-            readonly message: "User is not authenticated";
-        }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
-    } & {
-        readonly requireRecentAuth: <AuthReturn, AuthFailReturn_1>(maxAgeMs: number, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
-            readonly code: "Unauthorized";
-            readonly message: "Recent authentication required";
-        }) => AuthFailReturn_1) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "Recent authentication required", 401> | AuthReturn | NonNullable<AuthFailReturn_1>>;
-    } & {
-        readonly protectPermission: <AuthReturn, AuthFailReturn_3>(check: import(".").PermissionCheck, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
-            readonly code: "Bad Request";
-            readonly message: "Cookies are missing";
-        } | {
-            readonly code: "Forbidden";
-            readonly message: "Insufficient permissions";
-        } | {
-            readonly code: "Unauthorized";
-            readonly message: "User is not authenticated";
-        }) => AuthFailReturn_3) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaCustomStatusResponse<"Forbidden", "Insufficient permissions", 403> | AuthReturn | NonNullable<AuthFailReturn_3>>;
-    } & {
-        readonly protectAgent: <AuthReturn, AuthFailReturn_2>(requiredScopes: string[], handleAuth: (principal: import(".").AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: {
-            code: "Forbidden" | "Unauthorized";
-            message: "Agent is not authenticated" | "Insufficient agent scopes";
-        }) => AuthFailReturn_2 | Promise<AuthFailReturn_2>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn_2>>>;
-    });
-    resolve: {};
-}, {
-    typebox: {};
-    error: {};
-} & {
-    typebox: {};
-    error: {};
-}, {
-    schema: {};
-    standaloneSchema: {};
-    macro: {};
-    macroFn: {};
-    parser: {};
-    response: {};
-} & (({
-    schema: {};
-    standaloneSchema: {};
-    macro: {};
-    macroFn: {};
-    parser: {};
-    response: {};
-} & ({
-    schema: import("elysia").UnwrapRoute<{
-        cookie: import("@sinclair/typebox").TObject<{
-            user_session_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"${string}-${string}-${string}-${string}-${string}">>;
-        }>;
-    }, {}, "">;
-    standaloneSchema: {};
-    macro: {};
-    macroFn: {};
-    parser: {};
-    response: import("elysia").ExtractErrorFromHandle<{
-        readonly protectRoute: <AuthReturn, AuthFailReturn = never>(handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
-            readonly code: "Bad Request";
-            readonly message: "Cookies are missing";
-        } | {
-            readonly code: "Unauthorized";
-            readonly message: "User is not authenticated";
-        }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
-    }>;
-} & ({
-    schema: import("elysia").UnwrapRoute<{
-        cookie: import("@sinclair/typebox").TObject<{
-            user_session_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"${string}-${string}-${string}-${string}-${string}">>;
-        }>;
-    }, {}, "">;
-    standaloneSchema: {};
-    macro: {};
-    macroFn: {};
-    parser: {};
-    response: import("elysia").ExtractErrorFromHandle<{
-        readonly requireRecentAuth: <AuthReturn, AuthFailReturn_1>(maxAgeMs: number, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
-            readonly code: "Unauthorized";
-            readonly message: "Recent authentication required";
-        }) => AuthFailReturn_1) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "Recent authentication required", 401> | AuthReturn | NonNullable<AuthFailReturn_1>>;
-    }>;
-} & ({
-    schema: {};
-    standaloneSchema: {};
-    macro: {};
-    macroFn: {};
-    parser: {};
-    response: {};
-} | {
-    schema: import("elysia").UnwrapRoute<{
-        cookie: import("@sinclair/typebox").TObject<{
-            user_session_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"${string}-${string}-${string}-${string}-${string}">>;
-        }>;
-    }, {}, "">;
-    standaloneSchema: {};
-    macro: {};
-    macroFn: {};
-    parser: {};
-    response: import("elysia").ExtractErrorFromHandle<{
-        readonly protectPermission: <AuthReturn, AuthFailReturn_3>(check: import(".").PermissionCheck, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
-            readonly code: "Bad Request";
-            readonly message: "Cookies are missing";
-        } | {
-            readonly code: "Forbidden";
-            readonly message: "Insufficient permissions";
-        } | {
-            readonly code: "Unauthorized";
-            readonly message: "User is not authenticated";
-        }) => AuthFailReturn_3) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaCustomStatusResponse<"Forbidden", "Insufficient permissions", 403> | AuthReturn | NonNullable<AuthFailReturn_3>>;
-    }>;
-})))) & {
-    schema: {};
-    standaloneSchema: {};
-    macro: {};
-    macroFn: {};
-    parser: {};
-    response: import("elysia").ExtractErrorFromHandle<{
-        readonly protectAgent: <AuthReturn, AuthFailReturn_2>(requiredScopes: string[], handleAuth: (principal: import(".").AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: {
-            code: "Forbidden" | "Unauthorized";
-            message: "Agent is not authenticated" | "Insufficient agent scopes";
-        }) => AuthFailReturn_2 | Promise<AuthFailReturn_2>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn_2>>>;
-    }>;
-}), {}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-} & {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-}>>;
-export declare const createAuthApplications: <UserType>(configuration: AuthConfig<UserType>) => Promise<{
-    authContext: Elysia<"", {
-        decorator: {};
-        store: {
-            session: import("./types").SessionRecord<UserType>;
-            unregisteredSession: import("./types").UnregisteredSessionRecord;
-        };
-        derive: ({
-            readonly protectRoute: <AuthReturn, AuthFailReturn = never>(handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
-                readonly code: "Bad Request";
-                readonly message: "Cookies are missing";
-            } | {
-                readonly code: "Unauthorized";
-                readonly message: "User is not authenticated";
-            }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
-        } & {
-            readonly requireRecentAuth: <AuthReturn, AuthFailReturn_1>(maxAgeMs: number, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
-                readonly code: "Unauthorized";
-                readonly message: "Recent authentication required";
-            }) => AuthFailReturn_1) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "Recent authentication required", 401> | AuthReturn | NonNullable<AuthFailReturn_1>>;
-        } & {
-            readonly protectAgent: <AuthReturn, AuthFailReturn_2>(requiredScopes: string[], handleAuth: (principal: import(".").AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: {
-                code: "Forbidden" | "Unauthorized";
-                message: "Agent is not authenticated" | "Insufficient agent scopes";
-            }) => AuthFailReturn_2 | Promise<AuthFailReturn_2>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn_2>>>;
-        }) | ({
-            readonly protectRoute: <AuthReturn, AuthFailReturn = never>(handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
-                readonly code: "Bad Request";
-                readonly message: "Cookies are missing";
-            } | {
-                readonly code: "Unauthorized";
-                readonly message: "User is not authenticated";
-            }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
-        } & {
-            readonly requireRecentAuth: <AuthReturn, AuthFailReturn_1>(maxAgeMs: number, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
-                readonly code: "Unauthorized";
-                readonly message: "Recent authentication required";
-            }) => AuthFailReturn_1) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "Recent authentication required", 401> | AuthReturn | NonNullable<AuthFailReturn_1>>;
-        } & {
-            readonly protectPermission: <AuthReturn, AuthFailReturn_3>(check: import(".").PermissionCheck, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
-                readonly code: "Bad Request";
-                readonly message: "Cookies are missing";
-            } | {
-                readonly code: "Forbidden";
-                readonly message: "Insufficient permissions";
-            } | {
-                readonly code: "Unauthorized";
-                readonly message: "User is not authenticated";
-            }) => AuthFailReturn_3) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaCustomStatusResponse<"Forbidden", "Insufficient permissions", 403> | AuthReturn | NonNullable<AuthFailReturn_3>>;
-        } & {
-            readonly protectAgent: <AuthReturn, AuthFailReturn_2>(requiredScopes: string[], handleAuth: (principal: import(".").AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: {
-                code: "Forbidden" | "Unauthorized";
-                message: "Agent is not authenticated" | "Insufficient agent scopes";
-            }) => AuthFailReturn_2 | Promise<AuthFailReturn_2>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn_2>>>;
-        });
-        resolve: {};
-    }, {
-        typebox: {};
-        error: {};
-    } & {
-        typebox: {};
-        error: {};
-    }, ({
-        schema: {};
-        standaloneSchema: {};
-        macro: {};
-        macroFn: {};
-        parser: {};
-        response: {};
-    } & ({
-        schema: import("elysia").UnwrapRoute<{
-            cookie: import("@sinclair/typebox").TObject<{
-                user_session_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"${string}-${string}-${string}-${string}-${string}">>;
-            }>;
-        }, {}, "">;
-        standaloneSchema: {};
-        macro: {};
-        macroFn: {};
-        parser: {};
-        response: import("elysia").ExtractErrorFromHandle<{
-            readonly protectRoute: <AuthReturn, AuthFailReturn = never>(handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
-                readonly code: "Bad Request";
-                readonly message: "Cookies are missing";
-            } | {
-                readonly code: "Unauthorized";
-                readonly message: "User is not authenticated";
-            }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
-        }>;
-    } & ({
-        schema: import("elysia").UnwrapRoute<{
-            cookie: import("@sinclair/typebox").TObject<{
-                user_session_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"${string}-${string}-${string}-${string}-${string}">>;
-            }>;
-        }, {}, "">;
-        standaloneSchema: {};
-        macro: {};
-        macroFn: {};
-        parser: {};
-        response: import("elysia").ExtractErrorFromHandle<{
-            readonly requireRecentAuth: <AuthReturn, AuthFailReturn_1>(maxAgeMs: number, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
-                readonly code: "Unauthorized";
-                readonly message: "Recent authentication required";
-            }) => AuthFailReturn_1) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "Recent authentication required", 401> | AuthReturn | NonNullable<AuthFailReturn_1>>;
-        }>;
-    } & ({
-        schema: {};
-        standaloneSchema: {};
-        macro: {};
-        macroFn: {};
-        parser: {};
-        response: {};
-    } | {
-        schema: import("elysia").UnwrapRoute<{
-            cookie: import("@sinclair/typebox").TObject<{
-                user_session_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"${string}-${string}-${string}-${string}-${string}">>;
-            }>;
-        }, {}, "">;
-        standaloneSchema: {};
-        macro: {};
-        macroFn: {};
-        parser: {};
-        response: import("elysia").ExtractErrorFromHandle<{
-            readonly protectPermission: <AuthReturn, AuthFailReturn_3>(check: import(".").PermissionCheck, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
-                readonly code: "Bad Request";
-                readonly message: "Cookies are missing";
-            } | {
-                readonly code: "Forbidden";
-                readonly message: "Insufficient permissions";
-            } | {
-                readonly code: "Unauthorized";
-                readonly message: "User is not authenticated";
-            }) => AuthFailReturn_3) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaCustomStatusResponse<"Forbidden", "Insufficient permissions", 403> | AuthReturn | NonNullable<AuthFailReturn_3>>;
-        }>;
-    })))) & {
-        schema: {};
-        standaloneSchema: {};
-        macro: {};
-        macroFn: {};
-        parser: {};
-        response: import("elysia").ExtractErrorFromHandle<{
-            readonly protectAgent: <AuthReturn, AuthFailReturn_2>(requiredScopes: string[], handleAuth: (principal: import(".").AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: {
-                code: "Forbidden" | "Unauthorized";
-                message: "Agent is not authenticated" | "Insufficient agent scopes";
-            }) => AuthFailReturn_2 | Promise<AuthFailReturn_2>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn_2>>>;
-        }>;
-    }, {}, {
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    }, ({
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & {
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    }) | ({
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & {
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & {
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    })>;
-    coreRoutes: Elysia<"", {
-        decorator: {};
-        store: {
-            session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<NoInfer<UserType>>;
-            unregisteredSession: import("./types").UnregisteredSessionRecord;
-        };
-        derive: {
-            readonly cleanupSessions: () => Promise<void>;
-        };
-        resolve: {};
-    }, {
-        typebox: {};
-        error: {};
-    } & {
-        typebox: {};
-        error: {};
-    }, {
-        schema: {};
-        standaloneSchema: {};
-        macro: {};
-        macroFn: {};
-        parser: {};
-        response: {};
-    } & {
-        schema: {};
-        standaloneSchema: {};
-        macro: {};
-        macroFn: {};
-        parser: {};
-        response: import("elysia").ExtractErrorFromHandle<{
-            readonly cleanupSessions: () => Promise<void>;
-        }>;
-    } & {
-        schema: {};
-        standaloneSchema: {};
-        macro: {};
-        macroFn: {};
-        parser: {};
-        response: {};
-    }, (({
-        [x: string]: {
-            delete: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    400: "Cookies are missing";
-                    401: "No user session id found";
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                    500: "Sign out operation failed";
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    400: "Cookies are missing" | "Session has no access token to revoke";
-                    401: "Provider is required" | "Client provider not found" | "Client variant is required" | "Client variant not found" | "No auth provider found" | "No user session found";
-                    501: "Provider does not support revocation";
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                    500: "Failed to revoke token";
-                };
-            };
-        };
-    } & ({
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    400: "Cookies are missing";
-                    200: {
-                        impersonator: import("./types").Impersonator | undefined;
-                        user: NonNullable<UserType> | null;
-                    };
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                    500: `Error: ${string} - ${string}` | `Unknown Error: ${string}`;
-                };
-            };
-        };
-    } & ({
-        [x: string]: {
-            post: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    400: "Cookies are missing" | "No refresh token found";
-                    401: "Provider is required" | "Client provider not found" | "Client variant is required" | "Client variant not found" | "No auth provider found" | "No user session found";
-                    501: "Provider is not refreshable";
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                    500: "Failed to refresh token";
-                };
-            };
-        };
-    } & ({
-        [x: string]: {
-            ":provider": {
-                get: {
-                    body: unknown;
-                    params: {
-                        provider: string;
-                    };
-                    query: {
-                        client?: string | undefined;
-                        intent?: "login" | "link_identity" | "link_connector" | undefined;
-                    };
-                    headers: unknown;
-                    response: {
-                        400: "Cookies are missing" | "Provider is required";
-                        401: "Provider is required" | "Client provider not found" | "Client variant is required" | "Client variant not found";
-                        200: Response;
-                        422: {
-                            type: "validation";
-                            on: string;
-                            summary?: string;
-                            message?: string;
-                            found?: unknown;
-                            property?: string;
-                            expected?: string;
-                        };
-                        500: "Failed to create authorization URL";
-                    };
-                };
-            };
-        };
-    } | {
-        [x: string]: {
-            ":provider": {
-                [x: string]: {
-                    get: {
-                        body: unknown;
-                        params: {
-                            provider: string;
-                        };
-                        query: {
-                            client?: string | undefined;
-                            intent?: "login" | "link_identity" | "link_connector" | undefined;
-                        };
-                        headers: unknown;
-                        response: {
-                            400: "Cookies are missing" | "Provider is required";
-                            401: "Provider is required" | "Client provider not found" | "Client variant is required" | "Client variant not found";
-                            200: Response;
-                            422: {
-                                type: "validation";
-                                on: string;
-                                summary?: string;
-                                message?: string;
-                                found?: unknown;
-                                property?: string;
-                                expected?: string;
-                            };
-                            500: "Failed to create authorization URL";
-                        };
-                    };
-                };
-            };
-        };
-    })))) & {
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    [x: number]: {};
-                };
-            };
-        };
-    }) & {
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    400: "Cookies are missing" | "Session has no access token to fetch a profile";
-                    401: "Provider is required" | "Client provider not found" | "Client variant is required" | "Client variant not found" | "No auth provider found" | "No user session found";
-                    501: "Provider does not expose a profile endpoint";
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                    500: `${string} - ${string}` | `Failed to validate authorization code: Unknown status: ${string}`;
-                };
-            };
-        };
-    }, {
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    }, {
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & {
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & {
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    }>;
-    featureRoutes: Elysia<"", {
-        decorator: {};
-        store: {} | {
-            session: import("./types").SessionRecord<import(".").AuthHtmxUser>;
-            unregisteredSession: import("./types").UnregisteredSessionRecord;
-        } | {
-            session: import("./types").SessionRecord<UserType>;
-            unregisteredSession: import("./types").UnregisteredSessionRecord;
-        } | {
-            session: import("./types").SessionRecord<UserType>;
-            unregisteredSession: import("./types").UnregisteredSessionRecord;
-        } | {
-            session: import("./types").SessionRecord<UserType>;
-            unregisteredSession: import("./types").UnregisteredSessionRecord;
-        } | {
-            session: import("./types").SessionRecord<UserType>;
-            unregisteredSession: import("./types").UnregisteredSessionRecord;
-        } | {
-            session: import("./types").SessionRecord<UserType>;
-            unregisteredSession: import("./types").UnregisteredSessionRecord;
-        } | {
-            session: import("./types").SessionRecord<UserType>;
-            unregisteredSession: import("./types").UnregisteredSessionRecord;
-        } | {
-            session: import("./types").SessionRecord<UserType>;
-            unregisteredSession: import("./types").UnregisteredSessionRecord;
-        } | {
-            session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
-            unregisteredSession: import("./types").UnregisteredSessionRecord;
-        } | {
-            session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
-            unregisteredSession: import("./types").UnregisteredSessionRecord;
-        } | {
-            session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
-            unregisteredSession: import("./types").UnregisteredSessionRecord;
-        } | {
-            session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
-            unregisteredSession: import("./types").UnregisteredSessionRecord;
-        } | {
-            session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
-            unregisteredSession: import("./types").UnregisteredSessionRecord;
-        } | {
-            session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
-            unregisteredSession: import("./types").UnregisteredSessionRecord;
-        } | {
-            session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
-            unregisteredSession: import("./types").UnregisteredSessionRecord;
-        };
-        derive: {} | {
-            readonly protectRoute: <AuthReturn, AuthFailReturn = never>(handleAuth: (user: import(".").AuthHtmxUser) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
-                readonly code: "Bad Request";
-                readonly message: "Cookies are missing";
-            } | {
-                readonly code: "Unauthorized";
-                readonly message: "User is not authenticated";
-            }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
-        };
-        resolve: {};
-    }, {
-        typebox: {};
-        error: {};
-    } & {
-        typebox: {};
-        error: {};
-    }, (({
-        schema: {};
-        standaloneSchema: {};
-        macro: {};
-        macroFn: {};
-        parser: {};
-        response: {};
-    } & {
-        schema: {};
-        standaloneSchema: {};
-        macro: {};
-        macroFn: {};
-        parser: {};
-        response: {};
-    }) | ({
-        schema: {};
-        standaloneSchema: {};
-        macro: {};
-        macroFn: {};
-        parser: {};
-        response: {};
-    } & {
-        schema: {};
-        standaloneSchema: {};
-        macro: {};
-        macroFn: {};
-        parser: {};
-        response: {};
-    } & {
-        schema: import("elysia").UnwrapRoute<{
-            cookie: import("@sinclair/typebox").TObject<{
-                user_session_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"${string}-${string}-${string}-${string}-${string}">>;
-            }>;
-        }, {}, "">;
-        standaloneSchema: {};
-        macro: {};
-        macroFn: {};
-        parser: {};
-        response: import("elysia").ExtractErrorFromHandle<{
-            readonly protectRoute: <AuthReturn, AuthFailReturn = never>(handleAuth: (user: import(".").AuthHtmxUser) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
-                readonly code: "Bad Request";
-                readonly message: "Cookies are missing";
-            } | {
-                readonly code: "Unauthorized";
-                readonly message: "User is not authenticated";
-            }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
-        }>;
-    })) & {
-        schema: {};
-        standaloneSchema: {};
-        macro: {};
-        macroFn: {};
-        parser: {};
-        response: {};
-    }, (((((((((((((((({} | ({
-        [x: string]: {
-            post: {
-                body: {
-                    email: string;
-                    password: string;
-                };
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    [x: number]: {};
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: {
-                    token: string;
-                };
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    400: "Invalid or expired verification token";
-                    200: {
-                        readonly status: "email_verified";
-                    };
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            request: {
-                post: {
-                    body: {
-                        email: string;
-                    };
-                    params: {};
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        200: {
-                            readonly status: "verification_requested";
-                        };
-                        422: {
-                            type: "validation";
-                            on: string;
-                            summary?: string;
-                            message?: string;
-                            found?: unknown;
-                            property?: string;
-                            expected?: string;
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: {
-                    email: string;
-                    password: string;
-                };
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    401: "Invalid email or password";
-                    403: {
-                        readonly status: "email_not_verified";
-                    };
-                    200: {
-                        readonly status: "mfa_required";
-                    } | {
-                        readonly passwordCompromised: boolean;
-                        readonly status: "authenticated";
-                    };
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                    429: {
-                        readonly retryAfterMs: number | undefined;
-                        readonly status: "account_locked";
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            request: {
-                post: {
-                    body: {
-                        email: string;
-                    };
-                    params: {};
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        200: {
-                            readonly status: "reset_requested";
-                        };
-                        422: {
-                            type: "validation";
-                            on: string;
-                            summary?: string;
-                            message?: string;
-                            found?: unknown;
-                            property?: string;
-                            expected?: string;
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: {
-                    token: string;
-                    password: string;
-                };
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    400: "Invalid or expired reset token" | {
-                        readonly message: "Password does not meet the policy";
-                        readonly violations: import(".").PasswordPolicyViolation[];
-                    };
-                    200: {
-                        readonly status: "password_reset";
-                    };
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    })) & ({} | ({
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    401: "Authentication required";
-                    200: {
-                        backupCodesRemaining: number;
-                        enabled: boolean;
-                        smsBackup: {
-                            enabled: boolean;
-                            phone: string | null;
-                        };
-                        totp: {
-                            enabled: boolean;
-                        };
-                    };
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            delete: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    401: "Authentication required";
-                    200: {
-                        readonly status: "disabled";
-                    };
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    401: "Authentication required";
-                    200: {
-                        readonly secret: string;
-                        readonly uri: string;
-                    };
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: {
-                    code: string;
-                };
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    400: "No TOTP enrollment in progress" | "Invalid TOTP code";
-                    401: "Authentication required";
-                    200: {
-                        readonly backupCodes: string[];
-                    };
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: {
-                    phone: string;
-                };
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    400: "Phone must be in E.164 format";
-                    401: "Authentication required";
-                    501: "SMS MFA is not configured";
-                    200: {
-                        readonly phone: string;
-                    };
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: {
-                    code: string;
-                };
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    400: "No SMS enrollment in progress" | "SMS code expired" | "Invalid SMS code";
-                    401: "Authentication required";
-                    200: {
-                        readonly status: "enrolled";
-                    };
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                    429: "Too many attempts";
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: {
-                    code?: string | undefined;
-                    action?: "verify" | "send" | undefined;
-                    factor?: "sms" | undefined;
-                };
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    400: "SMS code required" | "No SMS code in progress";
-                    401: "SMS code expired" | "Too many attempts" | "No MFA challenge in progress" | "Invalid MFA code";
-                    200: {
-                        readonly status: "sent";
-                    } | {
-                        readonly status: "authenticated";
-                    };
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    }))) & {}) & ({} | ({
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    401: "Authentication required";
-                    501: "Session management requires an authSessionStore";
-                    200: {
-                        readonly sessions: {
-                            authenticatedAt?: number;
-                            current: boolean;
-                            expiresAt: number;
-                            id: import("./types").UserSessionId;
-                        }[];
-                    };
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            ":id": {
-                delete: {
-                    body: unknown;
-                    params: {
-                        id: string;
-                    };
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        400: "Invalid session id";
-                        401: "Authentication required";
-                        501: "Session management requires an authSessionStore";
-                        404: "Session not found";
-                        200: {
-                            readonly revoked: `${string}-${string}-${string}-${string}-${string}`;
-                        };
-                        422: {
-                            type: "validation";
-                            on: string;
-                            summary?: string;
-                            message?: string;
-                            found?: unknown;
-                            property?: string;
-                            expected?: string;
-                        };
-                    };
-                };
-            };
-        };
-    }))) & ({} | ({
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {
-                    organizationId: string;
-                };
-                query: unknown;
-                headers: unknown;
-                response: {
-                    404: "No OIDC connection is configured for this organization";
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {
-                    organizationId: string;
-                };
-                query: {
-                    code?: string | undefined;
-                    state?: string | undefined;
-                };
-                headers: unknown;
-                response: {
-                    400: "SSO session cookies are missing" | "Invalid SSO callback request" | "SSO organization mismatch" | "OIDC token response is missing an id_token";
-                    404: "No OIDC connection is configured for this organization";
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                    500: "OIDC sign-in failed";
-                };
-            };
-        };
-    }))) & ({} | ({
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {
-                    organizationId: string;
-                };
-                query: unknown;
-                headers: unknown;
-                response: {
-                    404: "No SAML connection is configured for this organization";
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: {
-                    RelayState?: string | undefined;
-                    SAMLResponse: string;
-                };
-                params: {
-                    organizationId: string;
-                };
-                query: unknown;
-                headers: unknown;
-                response: {
-                    404: "No SAML connection is configured for this organization";
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                    500: "SAML sign-in failed";
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {
-                    organizationId: string;
-                };
-                query: unknown;
-                headers: unknown;
-                response: {
-                    404: "No SAML connection is configured for this organization";
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {
-                    organizationId: string;
-                };
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {
-                    organizationId: string;
-                };
-                query: {
-                    RelayState?: string | undefined;
-                    SAMLResponse?: string | undefined;
-                    SAMLRequest?: string | undefined;
-                    SigAlg?: string | undefined;
-                    Signature?: string | undefined;
-                };
-                headers: unknown;
-                response: {
-                    400: "Missing SAMLRequest or SAMLResponse" | "Invalid SAML LogoutRequest";
-                    501: "SAML Single Logout is not configured";
-                    404: "No SAML connection is configured for this organization";
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                    500: "SAML logout failed";
-                };
-            };
-        };
-    }))) & ({} | {
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {};
-                query: {
-                    email?: string | undefined;
-                };
-                headers: unknown;
-                response: {
-                    400: "An \"email\" query parameter is required" | "A valid email address is required";
-                    404: "No SSO organization is configured for this email domain" | "No SSO connection is configured for this organization";
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    })) & ({} | ({
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {};
-                query: {
-                    filter?: string | undefined;
-                };
-                headers: unknown;
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {
-                    id: string;
-                };
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            put: {
-                body: unknown;
-                params: {
-                    id: string;
-                };
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            patch: {
-                body: unknown;
-                params: {
-                    id: string;
-                };
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            delete: {
-                body: unknown;
-                params: {
-                    id: string;
-                };
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {};
-                query: {
-                    filter?: string | undefined;
-                };
-                headers: unknown;
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {
-                    id: string;
-                };
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            put: {
-                body: unknown;
-                params: {
-                    id: string;
-                };
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            patch: {
-                body: unknown;
-                params: {
-                    id: string;
-                };
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            delete: {
-                body: unknown;
-                params: {
-                    id: string;
-                };
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {
-                    id: string;
-                };
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {
-                    id: string;
-                };
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    }))) & ({} | {
-        [x: string]: {
-            post: {
-                body: {
-                    client_id?: string | undefined;
-                    scope?: string | undefined;
-                    grant_type?: string | undefined;
-                    client_secret?: string | undefined;
-                };
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    })) & ({} | ({
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {};
-                query: {
-                    client_id?: string | undefined;
-                    scope?: string | undefined;
-                    nonce?: string | undefined;
-                    claims?: string | undefined;
-                    resource?: string | undefined;
-                    request?: string | undefined;
-                    redirect_uri?: string | undefined;
-                    acr_values?: string | undefined;
-                    code_challenge?: string | undefined;
-                    code_challenge_method?: string | undefined;
-                    id_token_hint?: string | undefined;
-                    max_age?: string | undefined;
-                    prompt?: string | undefined;
-                    request_uri?: string | undefined;
-                    response_mode?: string | undefined;
-                    response_type?: string | undefined;
-                    state?: string | undefined;
-                };
-                headers: unknown;
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: {
-                    code?: string | undefined;
-                    client_id?: string | undefined;
-                    scope?: string | undefined;
-                    audience?: string | undefined;
-                    resource?: string | undefined;
-                    refresh_token?: string | undefined;
-                    device_code?: string | undefined;
-                    auth_req_id?: string | undefined;
-                    grant_type?: string | undefined;
-                    claim_token?: string | undefined;
-                    assertion?: string | undefined;
-                    client_secret?: string | undefined;
-                    redirect_uri?: string | undefined;
-                    client_assertion?: string | undefined;
-                    client_assertion_type?: string | undefined;
-                    code_verifier?: string | undefined;
-                    'pre-authorized_code'?: string | undefined;
-                    subject_token?: string | undefined;
-                    subject_token_type?: string | undefined;
-                };
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: {
-                    client_id?: string | undefined;
-                    scope?: string | undefined;
-                    nonce?: string | undefined;
-                    audience?: string | undefined;
-                    claims?: string | undefined;
-                    resource?: string | undefined;
-                    client_secret?: string | undefined;
-                    redirect_uri?: string | undefined;
-                    acr_values?: string | undefined;
-                    code_challenge?: string | undefined;
-                    code_challenge_method?: string | undefined;
-                    response_type?: string | undefined;
-                    state?: string | undefined;
-                    client_assertion?: string | undefined;
-                    client_assertion_type?: string | undefined;
-                };
-                params: {};
-                query: unknown;
-                headers: {
-                    authorization?: string | undefined;
-                };
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: {
-                    client_id?: string | undefined;
-                    client_secret?: string | undefined;
-                    token_type_hint?: string | undefined;
-                    token: string;
-                };
-                params: {};
-                query: unknown;
-                headers: {
-                    authorization?: string | undefined;
-                };
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: {
-                    client_id?: string | undefined;
-                    client_secret?: string | undefined;
-                    token_type_hint?: string | undefined;
-                    token: string;
-                };
-                params: {};
-                query: unknown;
-                headers: {
-                    authorization?: string | undefined;
-                };
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: {
-                    client_id?: string | undefined;
-                    scope?: string | undefined;
-                    client_secret?: string | undefined;
-                    login_hint?: string | undefined;
-                    binding_message?: string | undefined;
-                };
-                params: {};
-                query: unknown;
-                headers: {
-                    authorization?: string | undefined;
-                };
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: {
-                    client_id?: string | undefined;
-                    scope?: string | undefined;
-                    client_secret?: string | undefined;
-                };
-                params: {};
-                query: unknown;
-                headers: {
-                    authorization?: string | undefined;
-                };
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: {
-                    action?: "deny" | "approve" | undefined;
-                    user_code: string;
-                };
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {};
-                query: {
-                    client_id?: string | undefined;
-                    id_token_hint?: string | undefined;
-                    state?: string | undefined;
-                    post_logout_redirect_uri?: string | undefined;
-                };
-                headers: unknown;
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: {
-                    client_id?: string | undefined;
-                    id_token_hint?: string | undefined;
-                    state?: string | undefined;
-                    post_logout_redirect_uri?: string | undefined;
-                };
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: {
-                    jwks?: any;
-                    scope?: string | undefined;
-                    backchannel_logout_uri?: string | undefined;
-                    client_name?: string | undefined;
-                    grant_types?: string[] | undefined;
-                    jwks_uri?: string | undefined;
-                    post_logout_redirect_uris?: string[] | undefined;
-                    redirect_uris?: string[] | undefined;
-                };
-                params: {};
-                query: unknown;
-                headers: {
-                    authorization?: string | undefined;
-                };
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            ":clientId": {
-                get: {
-                    body: unknown;
-                    params: {
-                        clientId: string;
-                    };
-                    query: unknown;
-                    headers: {
-                        authorization?: string | undefined;
-                    };
-                    response: {
-                        200: Response;
-                        422: {
-                            type: "validation";
-                            on: string;
-                            summary?: string;
-                            message?: string;
-                            found?: unknown;
-                            property?: string;
-                            expected?: string;
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            ":clientId": {
-                put: {
-                    body: {
-                        jwks?: any;
-                        scope?: string | undefined;
-                        backchannel_logout_uri?: string | undefined;
-                        client_name?: string | undefined;
-                        grant_types?: string[] | undefined;
-                        jwks_uri?: string | undefined;
-                        post_logout_redirect_uris?: string[] | undefined;
-                        redirect_uris?: string[] | undefined;
-                    };
-                    params: {
-                        clientId: string;
-                    };
-                    query: unknown;
-                    headers: {
-                        authorization?: string | undefined;
-                    };
-                    response: {
-                        200: Response;
-                        422: {
-                            type: "validation";
-                            on: string;
-                            summary?: string;
-                            message?: string;
-                            found?: unknown;
-                            property?: string;
-                            expected?: string;
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            ":clientId": {
-                delete: {
-                    body: unknown;
-                    params: {
-                        clientId: string;
-                    };
-                    query: unknown;
-                    headers: {
-                        authorization?: string | undefined;
-                    };
-                    response: {
-                        200: Response;
-                        422: {
-                            type: "validation";
-                            on: string;
-                            summary?: string;
-                            message?: string;
-                            found?: unknown;
-                            property?: string;
-                            expected?: string;
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: {
-                    authorization?: string | undefined;
-                };
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: {
-                    access_token?: string | undefined;
-                };
-                params: {};
-                query: unknown;
-                headers: {
-                    authorization?: string | undefined;
-                };
-                response: {
-                    200: Response;
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: {
-                        keys: {
-                            alg: string;
-                            crv: string | undefined;
-                            kid: string;
-                            kty: string | undefined;
-                            use: string;
-                            x: string | undefined;
-                            y: string | undefined;
-                        }[];
-                    };
-                };
-            };
-        };
-    } & {
-        ".well-known": {
-            "openid-configuration": {
-                get: {
-                    body: unknown;
-                    params: {};
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        200: Record<string, unknown>;
-                    };
-                };
-            };
-        };
-    } & {
-        ".well-known": {
-            "oauth-authorization-server": {
-                get: {
-                    body: unknown;
-                    params: {};
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        200: Record<string, unknown>;
-                    };
-                };
-            };
-        };
-    }))) & ({} | ({
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    401: "Authentication required";
-                    200: {
-                        readonly organizations: {
-                            membership: import(".").OrganizationMembership;
-                            organization: import(".").Organization | undefined;
-                        }[];
-                    };
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: {
-                    metadata?: {} | undefined;
-                    name: string;
-                };
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    401: "Authentication required";
-                    403: "Cannot create organizations";
-                    200: {
-                        readonly organization: import(".").Organization;
-                    };
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            ":organizationId": {
-                invitations: {
-                    post: {
-                        body: {
-                            roles?: string[] | undefined;
-                            email: string;
-                        };
-                        params: {
-                            organizationId: string;
-                        };
-                        query: unknown;
-                        headers: unknown;
-                        response: {
-                            401: "Authentication required";
-                            403: "Cannot manage members";
-                            200: {
-                                readonly invitationId: string;
-                                readonly token: string;
-                            };
-                            422: {
-                                type: "validation";
-                                on: string;
-                                summary?: string;
-                                message?: string;
-                                found?: unknown;
-                                property?: string;
-                                expected?: string;
-                            };
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            ":organizationId": {
-                invitations: {
-                    get: {
-                        body: unknown;
-                        params: {
-                            organizationId: string;
-                        };
-                        query: unknown;
-                        headers: unknown;
-                        response: {
-                            401: "Authentication required";
-                            403: "Cannot manage members";
-                            200: {
-                                readonly invitations: {
-                                    email: string;
-                                    expiresAt: number;
-                                    invitationId: string;
-                                    roles: string[];
-                                    state: import(".").InvitationState;
-                                }[];
-                            };
-                            422: {
-                                type: "validation";
-                                on: string;
-                                summary?: string;
-                                message?: string;
-                                found?: unknown;
-                                property?: string;
-                                expected?: string;
-                            };
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            ":organizationId": {
-                invitations: {
-                    ":invitationId": {
-                        delete: {
-                            body: unknown;
-                            params: {
-                                organizationId: string;
-                                invitationId: string;
-                            };
-                            query: unknown;
-                            headers: unknown;
-                            response: {
-                                401: "Authentication required";
-                                403: "Cannot manage members";
-                                404: "Invitation not found";
-                                200: {
-                                    readonly revoked: string;
-                                };
-                                422: {
-                                    type: "validation";
-                                    on: string;
-                                    summary?: string;
-                                    message?: string;
-                                    found?: unknown;
-                                    property?: string;
-                                    expected?: string;
-                                };
-                            };
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            invitations: {
-                accept: {
-                    post: {
-                        body: {
-                            token: string;
-                        };
-                        params: {};
-                        query: unknown;
-                        headers: unknown;
-                        response: {
-                            400: "Invalid or expired invitation";
-                            401: "Authentication required";
-                            200: {
-                                readonly organizationId: string;
-                                readonly roles: string[];
-                            };
-                            422: {
-                                type: "validation";
-                                on: string;
-                                summary?: string;
-                                message?: string;
-                                found?: unknown;
-                                property?: string;
-                                expected?: string;
-                            };
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            ":organizationId": {
-                members: {
-                    get: {
-                        body: unknown;
-                        params: {
-                            organizationId: string;
-                        };
-                        query: unknown;
-                        headers: unknown;
-                        response: {
-                            401: "Authentication required";
-                            403: "Not a member";
-                            200: {
-                                readonly members: import(".").OrganizationMembership[];
-                            };
-                            422: {
-                                type: "validation";
-                                on: string;
-                                summary?: string;
-                                message?: string;
-                                found?: unknown;
-                                property?: string;
-                                expected?: string;
-                            };
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            ":organizationId": {
-                members: {
-                    ":userId": {
-                        delete: {
-                            body: unknown;
-                            params: {
-                                userId: string;
-                                organizationId: string;
-                            };
-                            query: unknown;
-                            headers: unknown;
-                            response: {
-                                401: "Authentication required";
-                                403: "Cannot manage members";
-                                200: {
-                                    readonly removed: string;
-                                };
-                                422: {
-                                    type: "validation";
-                                    on: string;
-                                    summary?: string;
-                                    message?: string;
-                                    found?: unknown;
-                                    property?: string;
-                                    expected?: string;
-                                };
-                            };
-                        };
-                    };
-                };
-            };
-        };
-    }))) & ({} | ({
-        [x: string]: {
-            ":organizationId": {
-                get: {
-                    body: unknown;
-                    params: {
-                        organizationId: string;
-                    };
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        401: "Authentication required";
-                        403: "Cannot manage roles";
-                        200: {
-                            readonly roles: readonly import(".").Role[];
-                        };
-                        422: {
-                            type: "validation";
-                            on: string;
-                            summary?: string;
-                            message?: string;
-                            found?: unknown;
-                            property?: string;
-                            expected?: string;
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            ":organizationId": {
-                members: {
-                    ":userId": {
-                        put: {
-                            body: {
-                                roles: string[];
-                            };
-                            params: {
-                                userId: string;
-                                organizationId: string;
-                            };
-                            query: unknown;
-                            headers: unknown;
-                            response: {
-                                401: "Authentication required";
-                                403: "Cannot manage roles";
-                                404: "Membership not found";
-                                200: {
-                                    readonly roles: string[];
-                                };
-                                422: {
-                                    type: "validation";
-                                    on: string;
-                                    summary?: string;
-                                    message?: string;
-                                    found?: unknown;
-                                    property?: string;
-                                    expected?: string;
-                                };
-                            };
-                        };
-                    };
-                };
-            };
-        };
-    }))) & ({} | ({
-        [x: string]: {
-            session: {
-                get: {
-                    body: unknown;
-                    params: {};
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        401: "Invalid or expired setup link";
-                        200: {
-                            readonly capabilities: import(".").SetupCapability[];
-                            readonly configured: {
-                                readonly oidc: boolean;
-                                readonly saml: boolean;
-                            };
-                            readonly expiresAt: number;
-                            readonly oidc: {
-                                redirectUri: string;
-                            } | undefined;
-                            readonly organizationId: string;
-                            readonly saml: {
-                                acsUrl: string;
-                                entityId: string;
-                                metadataUrl: string;
-                            } | undefined;
-                            readonly scim: {
-                                baseUrl: string;
-                            } | undefined;
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            connection: {
-                saml: {
-                    put: {
-                        body: {
-                            idpSloUrl?: string | undefined;
-                            idpEntityId: string;
-                            idpSsoUrl: string;
-                            idpX509Cert: string;
-                        };
-                        params: {};
-                        query: unknown;
-                        headers: unknown;
-                        response: {
-                            401: "Invalid or expired setup link";
-                            403: "This setup link cannot configure SAML";
-                            501: "SSO is not configured";
-                            200: {
-                                readonly configured: true;
-                                readonly type: "saml";
-                            };
-                            422: {
-                                type: "validation";
-                                on: string;
-                                summary?: string;
-                                message?: string;
-                                found?: unknown;
-                                property?: string;
-                                expected?: string;
-                            };
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            connection: {
-                oidc: {
-                    put: {
-                        body: {
-                            scopes?: string[] | undefined;
-                            redirectUri?: string | undefined;
-                            issuer: string;
-                            clientId: string;
-                            clientSecret: string;
-                        };
-                        params: {};
-                        query: unknown;
-                        headers: unknown;
-                        response: {
-                            401: "Invalid or expired setup link";
-                            403: "This setup link cannot configure OIDC";
-                            501: "SSO is not configured";
-                            200: {
-                                readonly configured: true;
-                                readonly type: "oidc";
-                            };
-                            422: {
-                                type: "validation";
-                                on: string;
-                                summary?: string;
-                                message?: string;
-                                found?: unknown;
-                                property?: string;
-                                expected?: string;
-                            };
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            scim: {
-                token: {
-                    post: {
-                        body: unknown;
-                        params: {};
-                        query: unknown;
-                        headers: unknown;
-                        response: {
-                            401: "Invalid or expired setup link";
-                            403: "This setup link cannot configure SCIM";
-                            501: "SCIM is not configured";
-                            200: {
-                                readonly baseUrl: `${string}/${string}`;
-                                readonly token: string;
-                                readonly tokenId: string;
-                            };
-                        };
-                    };
-                };
-            };
-        };
-    }))) & ({} | ({
-        [x: string]: {
-            register: {
-                options: {
-                    post: {
-                        body: unknown;
-                        params: {};
-                        query: unknown;
-                        headers: unknown;
-                        response: {
-                            401: "Authentication required";
-                            200: {
-                                [x: string]: unknown;
-                            };
-                            422: {
-                                type: "validation";
-                                on: string;
-                                summary?: string;
-                                message?: string;
-                                found?: unknown;
-                                property?: string;
-                                expected?: string;
-                            };
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            register: {
-                verify: {
-                    post: {
-                        body: {};
-                        params: {};
-                        query: unknown;
-                        headers: unknown;
-                        response: {
-                            400: "No registration challenge in progress" | "WebAuthn registration failed";
-                            401: "Authentication required";
-                            200: {
-                                readonly credentialId: string;
-                                readonly verified: true;
-                            };
-                            422: {
-                                type: "validation";
-                                on: string;
-                                summary?: string;
-                                message?: string;
-                                found?: unknown;
-                                property?: string;
-                                expected?: string;
-                            };
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            authenticate: {
-                options: {
-                    post: {
-                        body: unknown;
-                        params: {};
-                        query: unknown;
-                        headers: unknown;
-                        response: {
-                            200: {
-                                [x: string]: unknown;
-                            };
-                            422: {
-                                type: "validation";
-                                on: string;
-                                summary?: string;
-                                message?: string;
-                                found?: unknown;
-                                property?: string;
-                                expected?: string;
-                            };
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            authenticate: {
-                verify: {
-                    post: {
-                        body: {
-                            id: string;
-                        };
-                        params: {};
-                        query: unknown;
-                        headers: unknown;
-                        response: {
-                            400: "No authentication challenge in progress";
-                            401: "Unknown credential" | "WebAuthn authentication failed";
-                            200: {
-                                readonly status: "authenticated";
-                            };
-                            422: {
-                                type: "validation";
-                                on: string;
-                                summary?: string;
-                                message?: string;
-                                found?: unknown;
-                                property?: string;
-                                expected?: string;
-                            };
-                        };
-                    };
-                };
-            };
-        };
-    }))) & ({} | ({
-        [x: string]: {
-            export: {
-                get: {
-                    body: unknown;
-                    params: {};
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        401: "Authentication required";
-                        200: {
-                            [x: string]: unknown;
-                        };
-                        422: {
-                            type: "validation";
-                            on: string;
-                            summary?: string;
-                            message?: string;
-                            found?: unknown;
-                            property?: string;
-                            expected?: string;
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            delete: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    401: "Authentication required";
-                    200: {
-                        readonly deleted: true;
-                    };
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    }))) & ({} | ({
-        htmx: {
-            login: {
-                get: {
-                    body: unknown;
-                    params: {};
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        200: Response;
-                        422: {
-                            type: "validation";
-                            on: string;
-                            summary?: string;
-                            message?: string;
-                            found?: unknown;
-                            property?: string;
-                            expected?: string;
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        htmx: {
-            link: {
-                get: {
-                    body: unknown;
-                    params: {};
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        200: Response;
-                        422: {
-                            type: "validation";
-                            on: string;
-                            summary?: string;
-                            message?: string;
-                            found?: unknown;
-                            property?: string;
-                            expected?: string;
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        htmx: {
-            "connector-links": {
-                get: {
-                    body: unknown;
-                    params: {};
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        200: Response;
-                        422: {
-                            type: "validation";
-                            on: string;
-                            summary?: string;
-                            message?: string;
-                            found?: unknown;
-                            property?: string;
-                            expected?: string;
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        htmx: {
-            "auth-menu": {
-                get: {
-                    body: unknown;
-                    params: {};
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        400: "Cookies are missing";
-                        401: "User is not authenticated";
-                        200: Response;
-                        422: {
-                            type: "validation";
-                            on: string;
-                            summary?: string;
-                            message?: string;
-                            found?: unknown;
-                            property?: string;
-                            expected?: string;
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        htmx: {
-            me: {
-                get: {
-                    body: unknown;
-                    params: {};
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        400: "Cookies are missing";
-                        401: "User is not authenticated";
-                        200: Response;
-                        422: {
-                            type: "validation";
-                            on: string;
-                            summary?: string;
-                            message?: string;
-                            found?: unknown;
-                            property?: string;
-                            expected?: string;
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        htmx: {
-            account: {
-                get: {
-                    body: unknown;
-                    params: {};
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        400: "Cookies are missing";
-                        401: "User is not authenticated";
-                        200: Response;
-                        422: {
-                            type: "validation";
-                            on: string;
-                            summary?: string;
-                            message?: string;
-                            found?: unknown;
-                            property?: string;
-                            expected?: string;
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        htmx: {
-            identities: {
-                get: {
-                    body: unknown;
-                    params: {};
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        400: "Cookies are missing";
-                        401: "User is not authenticated";
-                        200: Response;
-                        422: {
-                            type: "validation";
-                            on: string;
-                            summary?: string;
-                            message?: string;
-                            found?: unknown;
-                            property?: string;
-                            expected?: string;
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        htmx: {
-            identities: {
-                ":id": {
-                    primary: {
-                        post: {
-                            body: unknown;
-                            params: {
-                                id: string;
-                            } & {};
-                            query: unknown;
-                            headers: unknown;
-                            response: {
-                                400: "Cookies are missing";
-                                401: "User is not authenticated";
-                                200: Response;
-                                422: {
-                                    type: "validation";
-                                    on: string;
-                                    summary?: string;
-                                    message?: string;
-                                    found?: unknown;
-                                    property?: string;
-                                    expected?: string;
-                                };
-                            };
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        htmx: {
-            identities: {
-                ":id": {
-                    delete: {
-                        body: unknown;
-                        params: {
-                            id: string;
-                        } & {};
-                        query: unknown;
-                        headers: unknown;
-                        response: {
-                            400: "Cookies are missing";
-                            401: "User is not authenticated";
-                            200: Response;
-                            422: {
-                                type: "validation";
-                                on: string;
-                                summary?: string;
-                                message?: string;
-                                found?: unknown;
-                                property?: string;
-                                expected?: string;
-                            };
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        htmx: {
-            merge: {
-                ":id": {
-                    post: {
-                        body: unknown;
-                        params: {
-                            id: string;
-                        } & {};
-                        query: unknown;
-                        headers: unknown;
-                        response: {
-                            400: "Cookies are missing";
-                            401: "User is not authenticated";
-                            200: Response;
-                            422: {
-                                type: "validation";
-                                on: string;
-                                summary?: string;
-                                message?: string;
-                                found?: unknown;
-                                property?: string;
-                                expected?: string;
-                            };
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        htmx: {
-            merge: {
-                ":id": {
-                    delete: {
-                        body: unknown;
-                        params: {
-                            id: string;
-                        } & {};
-                        query: unknown;
-                        headers: unknown;
-                        response: {
-                            400: "Cookies are missing";
-                            401: "User is not authenticated";
-                            200: Response;
-                            422: {
-                                type: "validation";
-                                on: string;
-                                summary?: string;
-                                message?: string;
-                                found?: unknown;
-                                property?: string;
-                                expected?: string;
-                            };
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        htmx: {
-            "connector-list": {
-                get: {
-                    body: unknown;
-                    params: {};
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        400: "Cookies are missing";
-                        401: "User is not authenticated";
-                        200: Response;
-                        422: {
-                            type: "validation";
-                            on: string;
-                            summary?: string;
-                            message?: string;
-                            found?: unknown;
-                            property?: string;
-                            expected?: string;
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        htmx: {
-            connectors: {
-                grants: {
-                    ":id": {
-                        delete: {
-                            body: unknown;
-                            params: {
-                                id: string;
-                            } & {};
-                            query: unknown;
-                            headers: unknown;
-                            response: {
-                                400: "Cookies are missing";
-                                401: "User is not authenticated";
-                                200: Response;
-                                422: {
-                                    type: "validation";
-                                    on: string;
-                                    summary?: string;
-                                    message?: string;
-                                    found?: unknown;
-                                    property?: string;
-                                    expected?: string;
-                                };
-                            };
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        htmx: {
-            connectors: {
-                bindings: {
-                    ":id": {
-                        delete: {
-                            body: unknown;
-                            params: {
-                                id: string;
-                            } & {};
-                            query: unknown;
-                            headers: unknown;
-                            response: {
-                                400: "Cookies are missing";
-                                401: "User is not authenticated";
-                                200: Response;
-                                422: {
-                                    type: "validation";
-                                    on: string;
-                                    summary?: string;
-                                    message?: string;
-                                    found?: unknown;
-                                    property?: string;
-                                    expected?: string;
-                                };
-                            };
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        htmx: {
-            "login-redirect": {
-                get: {
-                    body: unknown;
-                    params: {};
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        200: Response;
-                        422: {
-                            type: "validation";
-                            on: string;
-                            summary?: string;
-                            message?: string;
-                            found?: unknown;
-                            property?: string;
-                            expected?: string;
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        htmx: {
-            "delete-account": {
-                post: {
-                    body: unknown;
-                    params: {};
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        400: "Cookies are missing";
-                        401: "User is not authenticated";
-                        200: Response;
-                        422: {
-                            type: "validation";
-                            on: string;
-                            summary?: string;
-                            message?: string;
-                            found?: unknown;
-                            property?: string;
-                            expected?: string;
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        htmx: {
-            signout: {
-                get: {
-                    body: unknown;
-                    params: {};
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        200: Response;
-                        422: {
-                            type: "validation";
-                            on: string;
-                            summary?: string;
-                            message?: string;
-                            found?: unknown;
-                            property?: string;
-                            expected?: string;
-                        };
-                    };
-                };
-            };
-        };
-    }))) & ({} | ({
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: {
-                        resource: string;
-                        scopes_supported: string[];
-                        resource_name?: string | undefined;
-                        resource_logo_uri?: string | undefined;
-                        authorization_servers: string[];
-                        bearer_methods_supported: string[];
-                    };
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            get: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                };
-            };
-        };
-    } & {
-        [x: string]: {
-            post: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                };
-            };
-        };
-    })), {
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    }, {
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & {
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    } & {
-        derive: {};
-        resolve: {};
-        schema: {};
-        standaloneSchema: {};
-        response: {};
-    }>;
-}>;
-export * from './actions';
-export type AuthApplications<UserType> = Awaited<ReturnType<typeof createAuthApplications<UserType>>>;
-export { createAuthContext } from './authContext';
-export type { AuthInstance } from './authContext';
-export * from './types';
-export * from './typebox';
-export * from './vault/config';
-export * from './vault/types';
-export { createInMemoryVaultStore } from './vault/inMemoryVaultStore';
-export { createNeonVaultStore, createPostgresVaultStore, vaultEntriesTable } from './vault/postgresVaultStore';
-export { createFederatedTokenStore, getOrRefreshFederatedTokens } from './federation/tokenStore';
-export type { FederatedTokenRefresher, FederatedTokenSet, FederatedTokenStore } from './federation/tokenStore';
-export { decodeSessionUserRecord, type AuthSessionStore, type SessionUserDecoder } from './session/types';
-export { isAuthIntent, isUserSessionId, isValidUser } from './typeGuards';
-export { AuthIdentityConflictError } from './errors';
-export { sessionStore } from './session/state';
-export { createInMemoryAuthSessionStore } from './session/inMemoryStore';
-export { createNeonAuthSessionStore } from './session/neonStore';
-export { providersFromEnv, type ProviderSelection } from './providersFromEnv';
-export { createRedisAuthSessionStore, type RedisSessionClient } from './session/redisStore';
-export { createLinkedProviderCredentialResolver } from './linkedProviders/resolver';
-export { createOAuthLinkedProviderCredentialResolver } from './linkedProviders/oauthResolver';
-export { createOAuthAccountLinkedProviderCredentialResolver, type OAuthLinkedProviderAccount, type OAuthLinkedProviderAccountStore } from './linkedProviders/oauthAccountResolver';
-export { createNeonLinkedProviderStores, createNeonOAuthLinkedProviderCredentialResolver } from './linkedProviders/neonStores';
-export { createInMemoryLinkedProviderStores } from './linkedProviders/inMemoryStores';
-export { protectRoutePlugin } from './routes/protectRoute';
-export { sessionRoutes } from './routes/sessions';
-export { stepUpPlugin } from './routes/stepUp';
-export * from './session/sessionsConfig';
-export { endImpersonation, isImpersonating, startImpersonation } from './session/impersonation';
-export { createAnonymousSession, isAnonymousSession } from './session/anonymous';
-export { addToSessionRing, listRingSessions, readSessionRing, removeFromSessionRing, switchActiveSession } from './session/multiSession';
-export { listUserSessions, refreshUserSessions, revokeUserSessions } from './session/userSessions';
-export type { UserSession } from './session/userSessions';
-export { sessionCleanup } from './session/cleanup';
-export { createAuthHtmxRoutes } from './htmx/routes';
-export { resolveAuthHtmxRenderers } from './htmx/renderers';
-export type { AuthHtmxConfig, AuthHtmxConnectorTarget, AuthHtmxProviderData, AuthHtmxProviderInfo, AuthHtmxRenderOverrides, AuthHtmxRenderersConfig, AuthHtmxUser, AuthIdentityPayload, LinkedProviderPayload } from './htmx/types';
-export * from './utils';
-export { buildClientProviders, resolveClientProviderEntry, resolveProviderClientConfiguration } from './providers/clients';
-export type { OAuth2TokenResponse, OAuth2Client, OAuth2ClientForConfig, CustomProviderCredentials, ProviderConfig, ProviderOption, PKCEProvider, OIDCProvider, RefreshableProvider, RevocableProvider, ScopeRequiredProvider, ProvidersMap, ProviderConfiguration, CredentialsFor } from 'citra';
-export { providers, providerOptions, createCustomOAuth2Client, defineProvider, refreshableProviderOptions, revocableProviderOptions, oidcProviderOptions, pkceProviderOptions, scopeRequiredProviderOptions, decodeJWT, extractPropFromIdentity, isValidProviderOption, isRefreshableOAuth2Client, isRefreshableProviderOption, isOIDCProviderOption, isPKCEProviderOption, isRevocableProviderOption, isRevocableOAuth2Client } from 'citra';
-export * from './crypto';
-export * from './tenancy';
-export * from './credentials/config';
-export * from './credentials/passwordPolicy';
-export * from './credentials/backgroundOps';
-export * from './credentials/emailValidation';
-export { importUser, importUsers, rehashCredentialPassword } from './credentials/import';
-export type { ImportUserResult, ImportUsersOptions, ImportableUser } from './credentials/import';
-export { isLegacyHash, verifyAuth0Pbkdf2, verifyCognitoSha256 } from './credentials/legacyHashers';
-export * from './credentials/types';
-export { credentialRoutes } from './credentials/routes';
-export { credentialsEmailVerification } from './credentials/emailVerification';
-export { credentialsLogin } from './credentials/login';
-export { credentialsPasswordReset } from './credentials/passwordReset';
-export { credentialsRegister } from './credentials/register';
-export { createInMemoryCredentialStore } from './credentials/inMemoryCredentialStore';
-export { createNeonCredentialStore, createPostgresCredentialStore, credentialResetTokensTable, credentialsTable, credentialVerificationTokensTable } from './credentials/postgresCredentialStore';
-export { createNeonDatabase } from './stores/postgres';
-export type { AnyPgDatabase } from './stores/postgres';
-export * from './mfa/config';
-export * from './mfa/types';
-export { consumeBackupCode, generateBackupCodes } from './mfa/backupCodes';
-export { createMfaGate } from './mfa/gate';
-export { mfaChallenge } from './mfa/challenge';
-export { mfaRoutes } from './mfa/routes';
-export { mfaManagementRoutes, type MfaStatus } from './mfa/management';
-export { rotateMfaEncryptionKey } from './mfa/rotation';
-export type { MfaKeyRotationResult } from './mfa/rotation';
-export { mfaTotpRoutes } from './mfa/totp';
-export { isE164Phone, maskPhone, mfaSmsRoutes } from './mfa/sms';
-export { decryptTotpSecret, encryptTotpSecret } from './mfa/secret';
-export { createInMemoryMfaStore } from './mfa/inMemoryMfaStore';
-export { createNeonMfaStore, createPostgresMfaStore, mfaEnrollmentsTable } from './mfa/postgresMfaStore';
-export * from './audit/config';
-export * from './audit/types';
-export { createTamperEvidentSink, hashAuditEvent, verifyAuditChain } from './audit/integrity';
-export type { AuditChainResult, AuditIntegrity } from './audit/integrity';
-export { createSiemLogStream } from './audit/siem';
-export type { SiemEndpoint, SiemFormat } from './audit/siem';
-export * from './abuse/captcha';
-export * from './abuse/config';
-export * from './authorization/config';
-export { protectPermissionPlugin } from './authorization/protectPermission';
-export * from './compliance/config';
-export { complianceRoutes } from './compliance/routes';
-export { createAuditRedactor } from './compliance/redaction';
-export { createSecretCipher } from './compliance/cipher';
-export type { SecretCipher } from './compliance/cipher';
-export * from './lockout/config';
-export * from './lockout/types';
-export { createInMemoryLockoutStore } from './lockout/inMemoryLockoutStore';
-export { createNeonLockoutStore, createPostgresLockoutStore, lockoutsTable } from './lockout/postgresLockoutStore';
-export { createRedisLockoutStore } from './lockout/redisLockoutStore';
-export type { RedisLike } from './stores/redis';
-export { exportAuditCsv } from './audit/export';
-export { createInMemoryAuditSink } from './audit/inMemoryAuditStore';
-export { auditEventsTable, createNeonAuditSink, createPostgresAuditSink } from './audit/postgresAuditStore';
-export * from './sso/types';
-export * from './sso/config';
-export * from './scim/types';
-export * from './scim/config';
-export * from './scim/extensions';
-export { scimRoutes } from './scim/routes';
-export * from './vc/sdJwt';
-export { buildIssuerMetadata, createCredentialOffer, DEFAULT_VCI_ROUTE, exchangePreAuthorizedCode, issueCredential, PRE_AUTHORIZED_CODE_GRANT } from './oidc/vci';
-export type { CredentialConfiguration, CredentialIssueInput, CredentialIssueResult, CredentialNonceRecord, CredentialNonceStore, CredentialOffer, CredentialOfferStore, PreAuthExchangeResult, VciConfig } from './oidc/vci';
-export { createInMemoryCredentialNonceStore, createInMemoryCredentialOfferStore } from './oidc/inMemoryVciStores';
-export { vciRoutes } from './oidc/vciRoutes';
-export * from './vc/statusList';
-export { statusListRoutes, DEFAULT_STATUS_ROUTE } from './vc/statusListRoutes';
-export { buildHolderKeyBindingJwt, createPresentationRequest, parsePresentationToken, verifyPresentationResponse } from './vc/openid4vp';
-export type { CreatePresentationRequestInput, PresentationRequest, PresentationRequestStore, PresentationResponseInput, PresentationVerifyError, PresentationVerifyResult, VerifiedPresentation, Vp4Config } from './vc/openid4vp';
-export { createInMemoryPresentationRequestStore } from './vc/inMemoryVpStores';
-export { vpRoutes, DEFAULT_VP_ROUTE } from './vc/vpRoutes';
-export { createNeonCredentialNonceStore, createNeonCredentialOfferStore, createNeonPresentationRequestStore, createPostgresCredentialNonceStore, createPostgresCredentialOfferStore, createPostgresPresentationRequestStore, vcCredentialNoncesTable, vcCredentialOffersTable, vcPresentationRequestsTable } from './vc/postgresVcStores';
-export { createInMemoryScimTokenStore } from './scim/inMemoryScimTokenStore';
-export { createNeonScimTokenStore, createPostgresScimTokenStore, scimTokensTable } from './scim/postgresScimTokenStore';
-export * from './apikeys/config';
-export * from './apikeys/types';
-export { apiKeysRoutes } from './apikeys/routes';
-export * from './agents/config';
-export * from './agents/types';
-export * from './agents/registration';
-export * from './agents/registrationClient';
-export * from './agents/idJag';
-export * from './agents/oauthGuide';
-export { agentAuthPlugin, agentAuthChallenge } from './agents/routes';
-export { resolveAgentPrincipal, agentHasScopes } from './agents/principal';
-export { createOidcAgentCredentialVerifier } from './agents/oidcAdapter';
-export { createInMemoryAgentDelegationStore, createInMemoryAgentIdentityRegistrationStore, createInMemoryAgentRegistrationStore } from './agents/inMemoryStores';
-export { agentDelegationsTable, agentDelegationsBunSqlTable, agentIdentityRegistrationsTable, agentIdentityRegistrationsBunSqlTable, agentRegistrationsTable, agentRegistrationsBunSqlTable, createBunSqlDrizzleAgentDelegationStore, createBunSqlDrizzleAgentIdentityRegistrationStore, createBunSqlDrizzleAgentRegistrationStore, createNeonAgentDelegationStore, createNeonAgentIdentityRegistrationStore, createNeonAgentRegistrationStore, createDrizzleAgentDelegationStore, createPostgresAgentDelegationStore, createPostgresAgentIdentityRegistrationStore, createPostgresAgentRegistrationStore } from './agents/postgresStores';
-export { createInMemoryAccessTokenStore, createInMemoryApiClientStore, createInMemoryApiKeyStore } from './apikeys/inMemoryStores';
-export { accessTokensTable, apiClientsTable, apiKeysTable, createNeonAccessTokenStore, createNeonApiClientStore, createNeonApiKeyStore, createPostgresAccessTokenStore, createPostgresApiClientStore, createPostgresApiKeyStore } from './apikeys/postgresStores';
-export * from './oidc/config';
-export * from './oidc/clientIdMetadata';
-export * from './oidc/types';
-export { oidcProviderRoutes } from './oidc/routes';
-export { generateSigningKey, jwkThumbprint, signJwt, signingVerificationKeys, toPublicJwk, verifyJwt, verifyJwtWithKeys } from './oidc/keys';
-export type { SigningKey, SigningKeyIdentity } from './oidc/keys';
-export { extractDpopNonceClaim, mintDpopNonce, verifyDpopNonce, verifyDpopProof } from './oidc/dpop';
-export type { DpopResult } from './oidc/dpop';
-export { CLIENT_ASSERTION_TYPE, verifyClientAssertion, verifyJwtSignedByClient } from './oidc/clientAuth';
-export { parseSignedRequestObject } from './oidc/jar';
-export type { JarParseResult } from './oidc/jar';
-export { computeCertThumbprint, extractRfc9440ClientCert, resolveClientCert, verifyCertificateBoundToken } from './oidc/mtls';
-export { createInMemoryAuthorizationCodeStore, createInMemoryBackchannelAuthStore, createInMemoryClientAssertionJtiStore, createInMemoryClientRegistrationTokenStore, createInMemoryDeviceAuthorizationStore, createInMemoryInitialAccessTokenStore, createInMemoryLogoutDeliveryStore, createInMemoryOAuthClientStore, createInMemoryOidcRefreshTokenStore, createInMemoryPushedAuthorizationRequestStore } from './oidc/inMemoryStores';
-export { consumePushedRequest, pushAuthorizationRequest, DEFAULT_PAR_TTL_MS, REQUEST_URI_PREFIX } from './oidc/par';
-export { fetchUserInfo, readUserInfoBearer, userInfoChallengeHeader } from './oidc/userinfo';
-export type { UserInfoResult } from './oidc/userinfo';
-export { fanOutBackchannelLogout, mintLogoutToken, resolvePostLogoutRedirect, verifyIdTokenHint } from './oidc/logout';
-export { createNeonAuthorizationCodeStore, createNeonBackchannelAuthStore, createNeonClientAssertionJtiStore, createNeonClientRegistrationTokenStore, createNeonDeviceAuthorizationStore, createNeonInitialAccessTokenStore, createNeonLogoutDeliveryStore, createNeonOAuthClientStore, createNeonOidcRefreshTokenStore, createNeonPushedAuthorizationRequestStore, createPostgresAuthorizationCodeStore, createPostgresBackchannelAuthStore, createPostgresClientAssertionJtiStore, createPostgresClientRegistrationTokenStore, createPostgresDeviceAuthorizationStore, createPostgresInitialAccessTokenStore, createPostgresLogoutDeliveryStore, createPostgresOAuthClientStore, createPostgresOidcRefreshTokenStore, createPostgresPushedAuthorizationRequestStore, oauthClientAssertionJtisTable, oauthClientRegistrationTokensTable, oauthClientsTable, oauthCodesTable, oauthBackchannelAuthRequestsTable, oauthDeviceAuthorizationsTable, oauthInitialAccessTokensTable, oauthLogoutDeliveriesTable, oauthPushedAuthorizationRequestsTable, oauthRefreshTokensTable } from './oidc/postgresStores';
-export { deleteRegisteredClient, getRegisteredClient, registerClient, updateRegisteredClient, type ClientRegistrationDecision, type ClientRegistrationMetadata, type OnClientRegistration, type RegisterClientResult } from './oidc/registration';
-export * from './adaptive/config';
-export * from './adaptive/fingerprint';
-export * from './adaptive/types';
-export { createInMemoryKnownDeviceStore, createInMemoryLoginHistoryStore } from './adaptive/inMemoryStores';
-export { createNeonKnownDeviceStore, createNeonLoginHistoryStore, createPostgresKnownDeviceStore, createPostgresLoginHistoryStore, knownDevicesTable, loginHistoryTable } from './adaptive/postgresStores';
-export * from './fga/config';
-export * from './fga/schema';
-export * from './fga/types';
-export { createInMemoryWarrantStore, warrantKey } from './fga/inMemoryStores';
-export { createRedisFgaCache, type RedisFgaCacheClient } from './fga/redisCheckCache';
-export { initTracing, withSpan, type TracingConfig } from './telemetry/tracing';
-export { blockMigrations, runMigrations, type BlockMigrations, type BlockName, type Migration } from './migrations';
-export type { MigrationClient, MigrationQueryResult, MigrationRunResult, RunMigrationsOptions } from './migrations/runner';
-export { createNeonWarrantStore, createPostgresWarrantStore, warrantsTable } from './fga/postgresStores';
-export { ssoDiscoveryRoute } from './sso/discoveryRoute';
-export { oidcSsoRoutes } from './sso/oidcRoutes';
-export { samlIdpRoutes } from './sso/samlIdpRoutes';
-export { samlSsoRoutes } from './sso/samlRoutes';
-export { createInMemorySamlServiceProviderStore } from './sso/inMemorySamlServiceProviderStore';
-export { createInMemorySsoConnectionStore } from './sso/inMemorySsoConnectionStore';
-export { createNeonSamlServiceProviderStore, createPostgresSamlServiceProviderStore, samlServiceProvidersTable } from './sso/postgresSamlServiceProviderStore';
-export { createNeonSsoConnectionStore, createPostgresSsoConnectionStore, ssoConnectionsTable } from './sso/postgresSsoConnectionStore';
-export * from './webauthn/adapter';
-export * from './webauthn/config';
-export * from './webauthn/types';
-export { webauthnRoutes } from './webauthn/routes';
-export { createInMemoryWebAuthnCredentialStore } from './webauthn/inMemoryWebAuthnCredentialStore';
-export { createNeonWebAuthnCredentialStore, createPostgresWebAuthnCredentialStore, webauthnCredentialsTable } from './webauthn/postgresWebAuthnCredentialStore';
-export * from './organizations/config';
-export * from './organizations/types';
-export { acceptInvitation, createOrganization, inviteToOrganization, listUserOrganizations } from './organizations/operations';
-export { organizationRoutes } from './organizations/routes';
-export { createInMemoryOrganizationStore } from './organizations/inMemoryOrganizationStore';
-export { createNeonOrganizationStore, createPostgresOrganizationStore, organizationInvitationsTable, organizationMembershipsTable, organizationsTable } from './organizations/postgresOrganizationStore';
-export * from './roles/config';
-export * from './roles/types';
-export { createMembershipPermissionResolver, resolvePermissions } from './roles/resolver';
-export { setMemberRoles } from './roles/operations';
-export { roleRoutes } from './roles/routes';
-export { createInMemoryRoleStore } from './roles/inMemoryRoleStore';
-export { createNeonRoleStore, createPostgresRoleStore, rolesTable } from './roles/postgresRoleStore';
-export * from './passwordless/config';
-export * from './passwordless/types';
-export { passwordlessRoutes } from './passwordless/routes';
-export { createInMemoryPasswordlessTokenStore } from './passwordless/inMemoryPasswordlessTokenStore';
-export { createNeonPasswordlessTokenStore, createPostgresPasswordlessTokenStore, passwordlessTokensTable } from './passwordless/postgresPasswordlessTokenStore';
-export * from './webhooks/config';
-export * from './webhooks/types';
-export { createWebhookDispatcher } from './webhooks/dispatcher';
-export { createInMemoryWebhookDeliveryStore } from './webhooks/inMemoryStore';
-export { createNeonWebhookDeliveryStore, createPostgresWebhookDeliveryStore, webhookDeliveriesTable } from './webhooks/postgresStore';
-export { signWebhook, verifyWebhookSignature } from './webhooks/sign';
-export * from './portal/config';
-export * from './portal/types';
-export { createSetupSession, resolveSetupSession } from './portal/operations';
-export { portalRoutes } from './portal/routes';
-export { createInMemorySetupSessionStore } from './portal/inMemorySetupSessionStore';
-export { createNeonSetupSessionStore, createPostgresSetupSessionStore, setupSessionsTable } from './portal/postgresSetupSessionStore';