@absolutejs/auth 0.55.4 → 0.55.6

package/dist/index.d.ts

@@ -1,12 +1,12 @@
 import { Elysia } from 'elysia';
-import { AuthConfig } from './types';
-export declare const auth: <UserType>({ providersConfiguration, authorizeRoute, cookieSecure, callbackRoute, profileRoute, signoutRoute, statusRoute, refreshRoute, revokeRoute, cleanupIntervalMs, maxSessions, sessionDurationMs, authSessionStore, audit, credentials, customProviders, mfa, passwordless, lockout, sessions, sso, scim, apikeys, agentAuth, oidc, organizations, roles, portal, authorization, compliance, webauthn, webhooks, htmx, tracing, resolveAuthIntent, onAuthorizeSuccess, onAuthorizeError, onProfileSuccess, onProfileError, onCallbackSuccess, onLinkIdentity, onLinkIdentityConflict, onLinkConnector, onCallbackError, onStatus, onRefreshSuccess, onRefreshError, onSignOut, onRevocationSuccess, onRevocationError, onSessionCleanup }: AuthConfig<UserType>) => Promise<Elysia<"", {
+import type { AuthConfig } from './types';
+export declare const auth: <UserType>(configuration: AuthConfig<UserType>) => Promise<Elysia<"", {
     decorator: {};
     store: {
-        session: import("./session/internalData").InternalSessionRecord<UserType>;
-        unregisteredSession: import("./session/internalData").InternalUnregisteredSessionRecord;
+        session: import("./types").SessionRecord<UserType>;
+        unregisteredSession: import("./types").UnregisteredSessionRecord;
     };
-    derive: {
+    derive: ({
         readonly protectRoute: <AuthReturn, AuthFailReturn>(handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
             readonly code: "Bad Request";
             readonly message: "Cookies are missing";
@@ -14,12 +14,68 @@ export declare const auth: <UserType>({ providersConfiguration, authorizeRoute,
             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>(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}">>;
@@ -38,7 +94,64 @@ export declare const auth: <UserType>({ providersConfiguration, authorizeRoute,
             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: {};
@@ -50,9 +163,3287 @@ export declare const auth: <UserType>({ providersConfiguration, authorizeRoute,
     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>(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>(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>(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>> & import("./types").SessionRecord<unknown>;
+            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" | "Invalid provider" | "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" | "Invalid provider" | "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: string]: any;
+                };
+            };
+        };
+    }) & {
+        [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" | "Invalid provider" | "No user session found";
+                    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>(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>(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: string]: any;
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            post: {
+                body: {
+                    token: string;
+                };
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    400: "Invalid or expired verification token";
+                    200: {
+                        readonly status: "email_verified";
+                    };
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            request: {
+                post: {
+                    body: {
+                        email: string;
+                    };
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: {
+                            readonly status: "verification_requested";
+                        };
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            post: {
+                body: {
+                    email: string;
+                    password: string;
+                };
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    401: "Invalid email or password";
+                    403: {
+                        readonly status: "email_not_verified";
+                    };
+                    200: {
+                        readonly status: "mfa_required";
+                    } | {
+                        readonly passwordCompromised: boolean;
+                        readonly status: "authenticated";
+                    };
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                    429: {
+                        readonly retryAfterMs: number | undefined;
+                        readonly status: "account_locked";
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            request: {
+                post: {
+                    body: {
+                        email: string;
+                    };
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: {
+                            readonly status: "reset_requested";
+                        };
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            post: {
+                body: {
+                    token: string;
+                    password: string;
+                };
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    400: "Invalid or expired reset token" | {
+                        readonly message: "Password does not meet the policy";
+                        readonly violations: import(".").PasswordPolicyViolation[];
+                    };
+                    200: {
+                        readonly status: "password_reset";
+                    };
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    })) & ({} | ({
+        [x: string]: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    401: "Authentication required";
+                    200: {
+                        backupCodesRemaining: number;
+                        enabled: boolean;
+                        smsBackup: {
+                            enabled: boolean;
+                            phone: string | null;
+                        };
+                        totp: {
+                            enabled: boolean;
+                        };
+                    };
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            delete: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    401: "Authentication required";
+                    200: {
+                        readonly status: "disabled";
+                    };
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            post: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    401: "Authentication required";
+                    200: {
+                        readonly secret: string;
+                        readonly uri: string;
+                    };
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            post: {
+                body: {
+                    code: string;
+                };
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    400: "No TOTP enrollment in progress" | "Invalid TOTP code";
+                    401: "Authentication required";
+                    200: {
+                        readonly backupCodes: string[];
+                    };
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            post: {
+                body: {
+                    phone: string;
+                };
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    400: "Phone must be in E.164 format";
+                    401: "Authentication required";
+                    501: "SMS MFA is not configured";
+                    200: {
+                        readonly phone: string;
+                    };
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            post: {
+                body: {
+                    code: string;
+                };
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    400: "No SMS enrollment in progress" | "SMS code expired" | "Invalid SMS code";
+                    401: "Authentication required";
+                    200: {
+                        readonly status: "enrolled";
+                    };
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                    429: "Too many attempts";
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            post: {
+                body: {
+                    code?: string | undefined;
+                    action?: "verify" | "send" | undefined;
+                    factor?: "sms" | undefined;
+                };
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    400: "SMS code required" | "No SMS code in progress";
+                    401: "SMS code expired" | "Too many attempts" | "No MFA challenge in progress" | "Invalid MFA code";
+                    200: {
+                        readonly status: "sent";
+                    } | {
+                        readonly status: "authenticated";
+                    };
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    }))) & {}) & ({} | ({
+        [x: string]: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    401: "Authentication required";
+                    501: "Session management requires an authSessionStore";
+                    200: {
+                        readonly sessions: {
+                            authenticatedAt?: number;
+                            current: boolean;
+                            expiresAt: number;
+                            id: import("./types").UserSessionId;
+                        }[];
+                    };
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            ":id": {
+                delete: {
+                    body: unknown;
+                    params: {
+                        id: string;
+                    };
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        400: "Invalid session id";
+                        401: "Authentication required";
+                        501: "Session management requires an authSessionStore";
+                        404: "Session not found";
+                        200: {
+                            readonly revoked: `${string}-${string}-${string}-${string}-${string}`;
+                        };
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    }))) & ({} | ({
+        [x: string]: {
+            get: {
+                body: unknown;
+                params: {
+                    organizationId: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    404: "No OIDC connection is configured for this organization";
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            get: {
+                body: unknown;
+                params: {
+                    organizationId: string;
+                };
+                query: {
+                    code?: string | undefined;
+                    state?: string | undefined;
+                };
+                headers: unknown;
+                response: {
+                    400: "SSO session cookies are missing" | "Invalid SSO callback request" | "SSO organization mismatch" | "OIDC token response is missing an id_token";
+                    404: "No OIDC connection is configured for this organization";
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                    500: "OIDC sign-in failed";
+                };
+            };
+        };
+    }))) & ({} | ({
+        [x: string]: {
+            get: {
+                body: unknown;
+                params: {
+                    organizationId: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    404: "No SAML connection is configured for this organization";
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            post: {
+                body: {
+                    RelayState?: string | undefined;
+                    SAMLResponse: string;
+                };
+                params: {
+                    organizationId: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    404: "No SAML connection is configured for this organization";
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                    500: "SAML sign-in failed";
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            get: {
+                body: unknown;
+                params: {
+                    organizationId: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    404: "No SAML connection is configured for this organization";
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            get: {
+                body: unknown;
+                params: {
+                    organizationId: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            get: {
+                body: unknown;
+                params: {
+                    organizationId: string;
+                };
+                query: {
+                    RelayState?: string | undefined;
+                    SAMLResponse?: string | undefined;
+                    SAMLRequest?: string | undefined;
+                    SigAlg?: string | undefined;
+                    Signature?: string | undefined;
+                };
+                headers: unknown;
+                response: {
+                    400: "Missing SAMLRequest or SAMLResponse" | "Invalid SAML LogoutRequest";
+                    501: "SAML Single Logout is not configured";
+                    404: "No SAML connection is configured for this organization";
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                    500: "SAML logout failed";
+                };
+            };
+        };
+    }))) & ({} | {
+        [x: string]: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    email?: string | undefined;
+                };
+                headers: unknown;
+                response: {
+                    400: "An \"email\" query parameter is required" | "A valid email address is required";
+                    404: "No SSO organization is configured for this email domain" | "No SSO connection is configured for this organization";
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    })) & ({} | ({
+        [x: string]: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            post: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    filter?: string | undefined;
+                };
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            get: {
+                body: unknown;
+                params: {
+                    id: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            put: {
+                body: unknown;
+                params: {
+                    id: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            patch: {
+                body: unknown;
+                params: {
+                    id: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            delete: {
+                body: unknown;
+                params: {
+                    id: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            post: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    filter?: string | undefined;
+                };
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            get: {
+                body: unknown;
+                params: {
+                    id: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            put: {
+                body: unknown;
+                params: {
+                    id: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            patch: {
+                body: unknown;
+                params: {
+                    id: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            delete: {
+                body: unknown;
+                params: {
+                    id: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            get: {
+                body: unknown;
+                params: {
+                    id: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                };
+            };
+        };
+    } & {
+        [x: string]: {
+            get: {
+                body: unknown;
+                params: {
+                    id: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    }))) & ({} | {
+        [x: string]: {
+            post: {
+                body: {
+                    client_id?: string | undefined;
+                    scope?: string | undefined;
+                    grant_type?: string | undefined;
+                    client_secret?: string | undefined;
+                };
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    })) & ({} | ({
+        [x: string]: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    client_id?: string | undefined;
+                    scope?: string | undefined;
+                    nonce?: string | undefined;
+                    claims?: string | undefined;
+                    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: {
+                    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;
+                    code?: 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: {
+                        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 { AuthInstance } from './authInstance';
+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';