@absolutejs/auth 0.59.0 → 0.59.1

package/dist/index.d.ts

@@ -0,0 +1,3643 @@
+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: "Recent authentication required" | "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: "Recent authentication required" | "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: "Recent authentication required" | "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: string;
+                    401: "Recent authentication required" | "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;
+                    };
+                    429: string;
+                    503: string;
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            post: {
+                body: {
+                    code: string;
+                };
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    400: string;
+                    401: "Recent authentication required" | "Authentication required";
+                    200: {
+                        readonly status: "enrolled";
+                    };
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                    429: string;
+                    503: string;
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            post: {
+                body: {
+                    code?: string | undefined;
+                    action?: "verify" | "send" | undefined;
+                    factor?: "sms" | undefined;
+                };
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    400: string;
+                    401: "SMS code expired" | "Too many attempts" | "SMS challenge is no longer active" | "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;
+                    };
+                    429: string;
+                    503: 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 * from './verification/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';