@absolutejs/auth 0.55.0 → 0.55.2

package/dist/agents/routes.d.ts

@@ -1,23 +1,15 @@
-import { Elysia } from 'elysia';
 import { type AgentAuthConfig } from './config';
-import type { AgentPrincipal } from './types';
+import { agentAuthChallenge } from './context';
 import { agentRegistrationDiscoveryMetadata } from './registration';
-type AgentAuthFailure = {
-    code: 'Forbidden' | 'Unauthorized';
-    message: 'Agent is not authenticated' | 'Insufficient agent scopes';
-};
-export declare const agentAuthChallenge: ({ config, error, requiredScopes }: {
-    config: AgentAuthConfig;
-    error?: "invalid_token" | "insufficient_scope";
-    requiredScopes?: string[];
-}) => string;
-export declare const agentResourceMetadataUrl: (config: AgentAuthConfig) => string;
-export { agentRegistrationDiscoveryMetadata };
-export declare const agentAuthPlugin: (config?: AgentAuthConfig) => Elysia<"", {
+export { agentAuthChallenge, agentRegistrationDiscoveryMetadata };
+export declare const agentAuthPlugin: (config?: AgentAuthConfig) => import("elysia").default<"", {
     decorator: {};
     store: {};
     derive: {
-        readonly protectAgent: <AuthReturn, AuthFailReturn>(requiredScopes: string[], handleAuth: (principal: AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: AgentAuthFailure) => AuthFailReturn | Promise<AuthFailReturn>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn>>>;
+        readonly protectAgent: <AuthReturn, AuthFailReturn>(requiredScopes: string[], handleAuth: (principal: import("./types").AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: {
+            code: "Forbidden" | "Unauthorized";
+            message: "Agent is not authenticated" | "Insufficient agent scopes";
+        }) => AuthFailReturn | Promise<AuthFailReturn>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn>>>;
     };
     resolve: {};
 }, {
@@ -30,7 +22,10 @@ export declare const agentAuthPlugin: (config?: AgentAuthConfig) => Elysia<"", {
     macroFn: {};
     parser: {};
     response: import("elysia").ExtractErrorFromHandle<{
-        readonly protectAgent: <AuthReturn, AuthFailReturn>(requiredScopes: string[], handleAuth: (principal: AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: AgentAuthFailure) => AuthFailReturn | Promise<AuthFailReturn>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn>>>;
+        readonly protectAgent: <AuthReturn, AuthFailReturn>(requiredScopes: string[], handleAuth: (principal: import("./types").AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: {
+            code: "Forbidden" | "Unauthorized";
+            message: "Agent is not authenticated" | "Insufficient agent scopes";
+        }) => AuthFailReturn | Promise<AuthFailReturn>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn>>>;
     }>;
 }, {}, {
     derive: {};
@@ -44,11 +39,14 @@ export declare const agentAuthPlugin: (config?: AgentAuthConfig) => Elysia<"", {
     schema: {};
     standaloneSchema: {};
     response: {};
-}> | Elysia<"", {
+}> | import("elysia").default<"", {
     decorator: {};
     store: {};
     derive: {
-        readonly protectAgent: <AuthReturn, AuthFailReturn>(requiredScopes: string[], handleAuth: (principal: AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: AgentAuthFailure) => AuthFailReturn | Promise<AuthFailReturn>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn>>>;
+        readonly protectAgent: <AuthReturn, AuthFailReturn>(requiredScopes: string[], handleAuth: (principal: import("./types").AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: {
+            code: "Forbidden" | "Unauthorized";
+            message: "Agent is not authenticated" | "Insufficient agent scopes";
+        }) => AuthFailReturn | Promise<AuthFailReturn>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn>>>;
     };
     resolve: {};
 }, {
@@ -61,7 +59,10 @@ export declare const agentAuthPlugin: (config?: AgentAuthConfig) => Elysia<"", {
     macroFn: {};
     parser: {};
     response: import("elysia").ExtractErrorFromHandle<{
-        readonly protectAgent: <AuthReturn, AuthFailReturn>(requiredScopes: string[], handleAuth: (principal: AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: AgentAuthFailure) => AuthFailReturn | Promise<AuthFailReturn>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn>>>;
+        readonly protectAgent: <AuthReturn, AuthFailReturn>(requiredScopes: string[], handleAuth: (principal: import("./types").AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: {
+            code: "Forbidden" | "Unauthorized";
+            message: "Agent is not authenticated" | "Insufficient agent scopes";
+        }) => AuthFailReturn | Promise<AuthFailReturn>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn>>>;
     }>;
 }, {
     [x: string]: {
@@ -94,11 +95,14 @@ export declare const agentAuthPlugin: (config?: AgentAuthConfig) => Elysia<"", {
     schema: {};
     standaloneSchema: {};
     response: {};
-}> | Elysia<"", {
+}> | import("elysia").default<"", {
     decorator: {};
     store: {};
     derive: {
-        readonly protectAgent: <AuthReturn, AuthFailReturn>(requiredScopes: string[], handleAuth: (principal: AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: AgentAuthFailure) => AuthFailReturn | Promise<AuthFailReturn>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn>>>;
+        readonly protectAgent: <AuthReturn, AuthFailReturn>(requiredScopes: string[], handleAuth: (principal: import("./types").AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: {
+            code: "Forbidden" | "Unauthorized";
+            message: "Agent is not authenticated" | "Insufficient agent scopes";
+        }) => AuthFailReturn | Promise<AuthFailReturn>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn>>>;
     };
     resolve: {};
 }, {
@@ -111,7 +115,10 @@ export declare const agentAuthPlugin: (config?: AgentAuthConfig) => Elysia<"", {
     macroFn: {};
     parser: {};
     response: import("elysia").ExtractErrorFromHandle<{
-        readonly protectAgent: <AuthReturn, AuthFailReturn>(requiredScopes: string[], handleAuth: (principal: AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: AgentAuthFailure) => AuthFailReturn | Promise<AuthFailReturn>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn>>>;
+        readonly protectAgent: <AuthReturn, AuthFailReturn>(requiredScopes: string[], handleAuth: (principal: import("./types").AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: {
+            code: "Forbidden" | "Unauthorized";
+            message: "Agent is not authenticated" | "Insufficient agent scopes";
+        }) => AuthFailReturn | Promise<AuthFailReturn>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn>>>;
     }>;
 }, {
     [x: string]: {

package/dist/apikeys/routes.d.ts

@@ -46,9 +46,9 @@ export declare const apiKeysRoutes: ({ accessTokenStore, accessTokenTtlMs, apiCl
     [x: string]: {
         post: {
             body: {
-                grant_type?: string | undefined;
-                scope?: string | undefined;
                 client_id?: string | undefined;
+                scope?: string | undefined;
+                grant_type?: string | undefined;
                 client_secret?: string | undefined;
             };
             params: {};

package/dist/authInstance.d.ts

@@ -0,0 +1,12 @@
+import type { Elysia } from 'elysia';
+import type { agentAuthContextPlugin } from './agents/context';
+import type { protectRoutePlugin } from './routes/protectRoute';
+import type { stepUpPlugin } from './routes/stepUp';
+/** Merge the stable context contributed by independent Auth plugins without
+ * exposing the configurable route graph in consumer declarations. */
+type MergeAuthContext<Base, Extra> = Base extends Elysia<infer Path, infer Singleton, infer Definitions, infer Metadata, infer Routes, infer Ephemeral, infer Volatile> ? Extra extends Elysia<infer ExtraPath, infer ExtraSingleton, infer ExtraDefinitions, infer ExtraMetadata, infer ExtraRoutes, infer ExtraEphemeral, infer ExtraVolatile> ? Elysia<Path & ExtraPath, Singleton & ExtraSingleton, Definitions & ExtraDefinitions, Metadata & ExtraMetadata, Routes & ExtraRoutes, Ephemeral & ExtraEphemeral, Volatile & ExtraVolatile> : never : never;
+/** The consumer-facing context contributed by `auth()`. Configurable auth
+ * routes are available at runtime but intentionally omitted from this type:
+ * their user-defined paths cannot form useful literal route declarations. */
+export type AuthInstance<UserType> = MergeAuthContext<MergeAuthContext<ReturnType<typeof protectRoutePlugin<UserType>>, ReturnType<typeof stepUpPlugin<UserType>>>, ReturnType<typeof agentAuthContextPlugin>>;
+export {};

package/dist/authorization/protectPermission.d.ts

@@ -17,7 +17,7 @@ export declare const protectPermissionPlugin: <UserType>({ authSessionStore, emi
         unregisteredSession: import("..").UnregisteredSessionRecord;
     };
     derive: {
-        readonly protectPermission: <AuthReturn, AuthFailReturn>(check: PermissionCheck, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: PermissionFailError) => AuthFailReturn) => Promise<AuthReturn | import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | NonNullable<AuthFailReturn> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaCustomStatusResponse<"Forbidden", "Insufficient permissions", 403>>;
+        readonly protectPermission: <AuthReturn, AuthFailReturn>(check: PermissionCheck, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: PermissionFailError) => AuthFailReturn) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn> | import("elysia").ElysiaCustomStatusResponse<"Forbidden", "Insufficient permissions", 403>>;
     };
     resolve: {};
 }, {
@@ -34,7 +34,7 @@ export declare const protectPermissionPlugin: <UserType>({ authSessionStore, emi
     macroFn: {};
     parser: {};
     response: import("elysia").ExtractErrorFromHandle<{
-        readonly protectPermission: <AuthReturn, AuthFailReturn>(check: PermissionCheck, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: PermissionFailError) => AuthFailReturn) => Promise<AuthReturn | import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | NonNullable<AuthFailReturn> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaCustomStatusResponse<"Forbidden", "Insufficient permissions", 403>>;
+        readonly protectPermission: <AuthReturn, AuthFailReturn>(check: PermissionCheck, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: PermissionFailError) => AuthFailReturn) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn> | import("elysia").ElysiaCustomStatusResponse<"Forbidden", "Insufficient permissions", 403>>;
     }>;
 }, {}, {
     derive: {};

package/dist/credentials/login.d.ts

@@ -39,10 +39,6 @@ export declare const credentialsLogin: <UserType>({ authSessionStore, checkBreac
                     readonly passwordCompromised: boolean;
                     readonly status: "authenticated";
                 };
-                429: {
-                    readonly retryAfterMs: number | undefined;
-                    readonly status: "account_locked";
-                };
                 422: {
                     type: "validation";
                     on: string;
@@ -52,6 +48,10 @@ export declare const credentialsLogin: <UserType>({ authSessionStore, checkBreac
                     property?: string;
                     expected?: string;
                 };
+                429: {
+                    readonly retryAfterMs: number | undefined;
+                    readonly status: "account_locked";
+                };
             };
         };
     };

package/dist/credentials/routes.d.ts

@@ -107,10 +107,6 @@ export declare const credentialRoutes: <UserType>(config: CredentialRouteProps<U
                     readonly passwordCompromised: boolean;
                     readonly status: "authenticated";
                 };
-                429: {
-                    readonly retryAfterMs: number | undefined;
-                    readonly status: "account_locked";
-                };
                 422: {
                     type: "validation";
                     on: string;
@@ -120,6 +116,10 @@ export declare const credentialRoutes: <UserType>(config: CredentialRouteProps<U
                     property?: string;
                     expected?: string;
                 };
+                429: {
+                    readonly retryAfterMs: number | undefined;
+                    readonly status: "account_locked";
+                };
             };
         };
     };

package/dist/index.d.ts

@@ -1,18 +1,5 @@
 import { Elysia } from 'elysia';
-import { agentAuthPlugin } from './agents/routes';
-import { protectRoutePlugin } from './routes/protectRoute';
-import { stepUpPlugin } from './routes/stepUp';
 import { AuthConfig } from './types';
-/** The minimal reference instance capturing ONLY the global, consumer-facing
- *  context `auth()` contributes: the `protectRoute` + step-up derives, typed by
- *  `UserType`. `auth()` also mounts ~28 route plugins, but their paths are
- *  CONFIGURABLE (`authorizeRoute`, `callbackRoute`, …), so Elysia keys those
- *  routes by `string` — there is no literal route type to expose, and inferring
- *  the whole chain trips TS7056 / a 2^N union blow-up. This typed context is the
- *  precise surface consumers actually use (`protectRoute((user) => …)` yields
- *  `UserType`); the routes are reached by path at runtime / direct fetch. */
-type MergeAuthContext<Base, Extra> = Base extends Elysia<infer Path, infer Singleton, infer Definitions, infer Metadata, infer Routes, infer Ephemeral, infer Volatile> ? Extra extends Elysia<infer ExtraPath, infer ExtraSingleton, infer ExtraDefinitions, infer ExtraMetadata, infer ExtraRoutes, infer ExtraEphemeral, infer ExtraVolatile> ? Elysia<Path & ExtraPath, Singleton & ExtraSingleton, Definitions & ExtraDefinitions, Metadata & ExtraMetadata, Routes & ExtraRoutes, Ephemeral & ExtraEphemeral, Volatile & ExtraVolatile> : never : never;
-export type AuthInstance<UserType> = MergeAuthContext<MergeAuthContext<ReturnType<typeof protectRoutePlugin<UserType>>, ReturnType<typeof stepUpPlugin<UserType>>>, ReturnType<typeof agentAuthPlugin>>;
 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<"", {
     decorator: {};
     store: {
@@ -45,12 +32,7 @@ export declare const auth: <UserType>({ providersConfiguration, authorizeRoute,
 } & {
     decorator: {};
     store: {};
-    derive: {
-        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: {};
 }, {
     typebox: {};
@@ -96,133 +78,14 @@ export declare const auth: <UserType>({ providersConfiguration, authorizeRoute,
     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: {};
-}> | 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>>;
-    };
-    resolve: {};
-} & {
-    decorator: {};
-    store: {
-        session: import("./types").SessionRecord<UserType>;
-        unregisteredSession: import("./types").UnregisteredSessionRecord;
-    };
-    derive: {
-        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>>;
-    };
-    resolve: {};
 } & {
-    decorator: {};
-    store: {};
-    derive: {
-        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: {};
-}, {
-    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: 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>>>;
-    }>;
-}, {
-    [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[];
-                };
-            };
-        };
-    };
-}, {
     derive: {};
     resolve: {};
     schema: {};
@@ -234,38 +97,7 @@ export declare const auth: <UserType>({ providersConfiguration, authorizeRoute,
     schema: {};
     standaloneSchema: {};
     response: {};
-}> | 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>>;
-    };
-    resolve: {};
-} & {
-    decorator: {};
-    store: {
-        session: import("./types").SessionRecord<UserType>;
-        unregisteredSession: import("./types").UnregisteredSessionRecord;
-    };
-    derive: {
-        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>>;
-    };
-    resolve: {};
 } & {
-    decorator: {};
-    store: {};
     derive: {
         readonly protectAgent: <AuthReturn, AuthFailReturn_2>(requiredScopes: string[], handleAuth: (principal: import(".").AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: {
             code: "Forbidden" | "Unauthorized";
@@ -273,149 +105,17 @@ export declare const auth: <UserType>({ providersConfiguration, authorizeRoute,
         }) => AuthFailReturn_2 | Promise<AuthFailReturn_2>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn_2>>>;
     };
     resolve: {};
-}, {
-    typebox: {};
-    error: {};
-}, {
-    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: 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>>>;
     }>;
-}, {
-    [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: {};
 }>>;
 export * from './actions';
+export type { AuthInstance } from './authInstance';
 export * from './types';
 export * from './typebox';
 export * from './vault/config';