@absolutejs/auth 0.55.4 → 0.55.6

package/dist/agents/routes.d.ts

@@ -1,8 +1,9 @@
+import { Elysia } from 'elysia';
 import { type AgentAuthConfig } from './config';
 import { agentAuthChallenge } from './context';
 import { agentRegistrationDiscoveryMetadata } from './registration';
 export { agentAuthChallenge, agentRegistrationDiscoveryMetadata };
-export declare const agentAuthPlugin: (config?: AgentAuthConfig) => import("elysia").default<"", {
+export declare const agentAuthPlugin: (config?: AgentAuthConfig) => Elysia<"", {
     decorator: {};
     store: {};
     derive: {
@@ -27,6 +28,132 @@ export declare const agentAuthPlugin: (config?: AgentAuthConfig) => import("elys
             message: "Agent is not authenticated" | "Insufficient agent scopes";
         }) => AuthFailReturn | Promise<AuthFailReturn>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn>>>;
     }>;
+}, {} | {
+    [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: {};
+}>;
+export declare const agentAuthRoutes: (config?: AgentAuthConfig) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
 }, {}, {
     derive: {};
     resolve: {};
@@ -39,15 +166,10 @@ export declare const agentAuthPlugin: (config?: AgentAuthConfig) => import("elys
     schema: {};
     standaloneSchema: {};
     response: {};
-}> | import("elysia").default<"", {
+}> | Elysia<"", {
     decorator: {};
     store: {};
-    derive: {
-        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: {};
     resolve: {};
 }, {
     typebox: {};
@@ -58,12 +180,7 @@ export declare const agentAuthPlugin: (config?: AgentAuthConfig) => import("elys
     macro: {};
     macroFn: {};
     parser: {};
-    response: import("elysia").ExtractErrorFromHandle<{
-        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>>>;
-    }>;
+    response: {};
 }, {
     [x: string]: {
         get: {
@@ -95,15 +212,10 @@ export declare const agentAuthPlugin: (config?: AgentAuthConfig) => import("elys
     schema: {};
     standaloneSchema: {};
     response: {};
-}> | import("elysia").default<"", {
+}> | Elysia<"", {
     decorator: {};
     store: {};
-    derive: {
-        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: {};
     resolve: {};
 }, {
     typebox: {};
@@ -114,12 +226,7 @@ export declare const agentAuthPlugin: (config?: AgentAuthConfig) => import("elys
     macro: {};
     macroFn: {};
     parser: {};
-    response: import("elysia").ExtractErrorFromHandle<{
-        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>>>;
-    }>;
+    response: {};
 }, {
     [x: string]: {
         get: {

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/authContext.d.ts

@@ -0,0 +1,193 @@
+import { Elysia } from 'elysia';
+import type { AgentAuthConfig } from './agents/config';
+import type { AuditEmitter } from './audit/config';
+import type { AuthorizationConfig } from './authorization/config';
+import type { AuthSessionStore } from './session/types';
+export declare const createAuthContext: <UserType>({ agentAuth, authSessionStore, authorization, emit, seedSource }: {
+    agentAuth?: AgentAuthConfig;
+    authSessionStore?: AuthSessionStore<UserType>;
+    authorization?: AuthorizationConfig<UserType>;
+    emit?: AuditEmitter;
+    seedSource?: object;
+}) => 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: {};
+})>;
+export type AuthInstance<UserType> = ReturnType<typeof createAuthContext<UserType>>;

package/dist/authorization/protectPermission.d.ts

@@ -13,11 +13,11 @@ type PermissionFailError = {
 export declare const protectPermissionPlugin: <UserType>({ authSessionStore, emit, hasPermission }: AuthorizationPluginProps<UserType>) => Elysia<"", {
     decorator: {};
     store: {
-        session: import("../session/internalData").InternalSessionRecord<UserType>;
-        unregisteredSession: import("../session/internalData").InternalUnregisteredSessionRecord;
+        session: import("..").SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
     };
     derive: {
-        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>>;
+        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>>;
     };
     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<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>>;
+        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>>;
     }>;
 }, {}, {
     derive: {};

package/dist/compliance/routes.d.ts

@@ -3,8 +3,8 @@ import type { CompliancePluginProps } from './config';
 export declare const complianceRoutes: <UserType>({ authSessionStore, complianceRoute, deleteUserData, emit, exportUserData, getUserId }: CompliancePluginProps<UserType>) => Elysia<"", {
     decorator: {};
     store: {
-        session: import("../session/internalData").InternalSessionRecord<UserType>;
-        unregisteredSession: import("../session/internalData").InternalUnregisteredSessionRecord;
+        session: import("..").SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
     };
     derive: {};
     resolve: {};

package/dist/credentials/login.d.ts

@@ -3,8 +3,8 @@ import { type CredentialRouteProps } from './config';
 export declare const credentialsLogin: <UserType>({ authSessionStore, checkBreachesOnLogin, cookieSecure, credentialStore, getUserByEmail, isMfaRequired, lockoutGuard, loginRoute, onCredentialsLoginError, onCredentialsLoginSuccess, passwordVerifier, rehashOnLogin, requireEmailVerification, sessionDurationMs }: CredentialRouteProps<UserType>) => Elysia<"", {
     decorator: {};
     store: {
-        session: import("../session/internalData").InternalSessionRecord<UserType>;
-        unregisteredSession: import("../session/internalData").InternalUnregisteredSessionRecord;
+        session: import("..").SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
     };
     derive: {};
     resolve: {};
@@ -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/register.d.ts

@@ -3,8 +3,8 @@ import { type CredentialRouteProps } from './config';
 export declare const credentialsRegister: <UserType>({ authSessionStore, cookieSecure, credentialStore, onCreateCredentialUser, onCredentialsLoginSuccess, onRegistrationSuccess, onSendEmail, passwordPolicy, registerRoute, requireEmailVerification, sessionDurationMs, verificationTokenDurationMs }: CredentialRouteProps<UserType>) => Elysia<"", {
     decorator: {};
     store: {
-        session: import("../session/internalData").InternalSessionRecord<UserType>;
-        unregisteredSession: import("../session/internalData").InternalUnregisteredSessionRecord;
+        session: import("..").SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
     };
     derive: {};
     resolve: {};

package/dist/credentials/routes.d.ts

@@ -3,8 +3,8 @@ import type { CredentialRouteProps } from './config';
 export declare const credentialRoutes: <UserType>(config: CredentialRouteProps<UserType>) => Elysia<"", {
     decorator: {};
     store: {
-        session: import("../session/internalData").InternalSessionRecord<UserType>;
-        unregisteredSession: import("../session/internalData").InternalUnregisteredSessionRecord;
+        session: import("..").SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
     };
     derive: {};
     resolve: {};
@@ -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";
+                };
             };
         };
     };