@absolutejs/auth 0.75.7 → 0.76.1

package/dist/agents/routes.d.ts

@@ -7,16 +7,10 @@ export declare const agentAuthPlugin: (config?: AgentAuthConfig) => Elysia<"", "
     decorator: {};
     store: {};
     derive: {
-        readonly protectAgent: {
-            <AuthReturn, AuthFailReturn = never>(requiredScopes: string[], handleAuth: (principal: import("./types").AgentPrincipal) => Promise<AuthReturn>, handleAuthFail?: (error: {
-                code: "Forbidden" | "Unauthorized";
-                message: "Agent is not authenticated" | "Insufficient agent scopes";
-            }) => AuthFailReturn): Promise<Response | AuthReturn | Awaited<AuthFailReturn>>;
-            <AuthReturn, AuthFailReturn = never>(requiredScopes: string[], handleAuth: (principal: import("./types").AgentPrincipal) => AuthReturn, handleAuthFail?: (error: {
-                code: "Forbidden" | "Unauthorized";
-                message: "Agent is not authenticated" | "Insufficient agent scopes";
-            }) => AuthFailReturn): Promise<Response | AuthReturn | 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>>>;
     };
 }, {
     typebox: {};

package/dist/authContext.d.ts

@@ -20,134 +20,54 @@ export declare const createAuthContext: <UserType>({ agentAuth, accessTokens, au
         unregisteredSession: import("./types").UnregisteredSessionRecord;
     };
     derive: ({
-        readonly absoluteAuthStatus: {
-            error: {
-                readonly code: "Bad Request";
-                readonly message: "Cookies are missing";
-            };
-            user: null;
-            impersonator?: undefined;
-        } | {
-            error: null;
-            impersonator: import("./types").Impersonator | undefined;
-            user: NonNullable<UserType> | null;
-        };
         readonly authPrincipal: import("./principal").AuthPrincipal<UserType> | undefined;
+        readonly protectRoute: <AuthReturn, AuthFailReturn = never>(handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
+            readonly code: "Bad Request";
+            readonly message: "Cookies are missing";
+        } | {
+            readonly code: "Unauthorized";
+            readonly message: "User is not authenticated";
+        }) => AuthFailReturn) | undefined) => import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | AuthReturn | Promise<AuthReturn> | NonNullable<AuthFailReturn>;
     } & {
-        readonly protectRoute: {
-            <AuthReturn, AuthFailReturn = never>(handleAuth: (user: UserType) => 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").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401>) | AuthReturn | Awaited<AuthFailReturn>>;
-            <AuthReturn, AuthFailReturn_1 = never>(handleAuth: (user: UserType) => AuthReturn, handleAuthFail?: ((error: {
-                readonly code: "Bad Request";
-                readonly message: "Cookies are missing";
-            } | {
-                readonly code: "Unauthorized";
-                readonly message: "User is not authenticated";
-            }) => AuthFailReturn_1) | undefined): Promise<(import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401>) | AuthReturn | Awaited<AuthFailReturn_1>>;
-        };
-    } & {
-        readonly requireRecentAuth: {
-            <AuthReturn, AuthFailReturn_2 = never>(maxAgeMs: number, handleAuth: (user: UserType) => Promise<AuthReturn>, handleAuthFail?: ((error: {
-                readonly code: "Unauthorized";
-                readonly message: "Recent authentication required";
-            }) => AuthFailReturn_2) | undefined): Promise<import("elysia").ElysiaStatus<"Unauthorized", "Recent authentication required", 401> | AuthReturn | Awaited<AuthFailReturn_2>>;
-            <AuthReturn, AuthFailReturn_3 = never>(maxAgeMs: number, handleAuth: (user: UserType) => AuthReturn, handleAuthFail?: ((error: {
-                readonly code: "Unauthorized";
-                readonly message: "Recent authentication required";
-            }) => AuthFailReturn_3) | undefined): Promise<import("elysia").ElysiaStatus<"Unauthorized", "Recent authentication required", 401> | AuthReturn | Awaited<AuthFailReturn_3>>;
-        };
+        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").ElysiaStatus<"Unauthorized", "Recent authentication required", 401> | AuthReturn | NonNullable<AuthFailReturn_1>>;
     } & {
-        readonly protectAgent: {
-            <AuthReturn, AuthFailReturn_4 = never>(requiredScopes: string[], handleAuth: (principal: import(".").AgentPrincipal) => Promise<AuthReturn>, handleAuthFail?: (error: {
-                code: "Forbidden" | "Unauthorized";
-                message: "Agent is not authenticated" | "Insufficient agent scopes";
-            }) => AuthFailReturn_4): Promise<Response | AuthReturn | Awaited<AuthFailReturn_4>>;
-            <AuthReturn, AuthFailReturn_5 = never>(requiredScopes: string[], handleAuth: (principal: import(".").AgentPrincipal) => AuthReturn, handleAuthFail?: (error: {
-                code: "Forbidden" | "Unauthorized";
-                message: "Agent is not authenticated" | "Insufficient agent scopes";
-            }) => AuthFailReturn_5): Promise<Response | AuthReturn | Awaited<AuthFailReturn_5>>;
-        };
+        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 absoluteAuthStatus: {
-            error: {
-                readonly code: "Bad Request";
-                readonly message: "Cookies are missing";
-            };
-            user: null;
-            impersonator?: undefined;
-        } | {
-            error: null;
-            impersonator: import("./types").Impersonator | undefined;
-            user: NonNullable<UserType> | null;
-        };
         readonly authPrincipal: import("./principal").AuthPrincipal<UserType> | undefined;
+        readonly protectRoute: <AuthReturn, AuthFailReturn = never>(handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
+            readonly code: "Bad Request";
+            readonly message: "Cookies are missing";
+        } | {
+            readonly code: "Unauthorized";
+            readonly message: "User is not authenticated";
+        }) => AuthFailReturn) | undefined) => import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | AuthReturn | Promise<AuthReturn> | NonNullable<AuthFailReturn>;
     } & {
-        readonly protectRoute: {
-            <AuthReturn, AuthFailReturn = never>(handleAuth: (user: UserType) => 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").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401>) | AuthReturn | Awaited<AuthFailReturn>>;
-            <AuthReturn, AuthFailReturn_1 = never>(handleAuth: (user: UserType) => AuthReturn, handleAuthFail?: ((error: {
-                readonly code: "Bad Request";
-                readonly message: "Cookies are missing";
-            } | {
-                readonly code: "Unauthorized";
-                readonly message: "User is not authenticated";
-            }) => AuthFailReturn_1) | undefined): Promise<(import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401>) | AuthReturn | Awaited<AuthFailReturn_1>>;
-        };
-    } & {
-        readonly requireRecentAuth: {
-            <AuthReturn, AuthFailReturn_2 = never>(maxAgeMs: number, handleAuth: (user: UserType) => Promise<AuthReturn>, handleAuthFail?: ((error: {
-                readonly code: "Unauthorized";
-                readonly message: "Recent authentication required";
-            }) => AuthFailReturn_2) | undefined): Promise<import("elysia").ElysiaStatus<"Unauthorized", "Recent authentication required", 401> | AuthReturn | Awaited<AuthFailReturn_2>>;
-            <AuthReturn, AuthFailReturn_3 = never>(maxAgeMs: number, handleAuth: (user: UserType) => AuthReturn, handleAuthFail?: ((error: {
-                readonly code: "Unauthorized";
-                readonly message: "Recent authentication required";
-            }) => AuthFailReturn_3) | undefined): Promise<import("elysia").ElysiaStatus<"Unauthorized", "Recent authentication required", 401> | AuthReturn | Awaited<AuthFailReturn_3>>;
-        };
+        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").ElysiaStatus<"Unauthorized", "Recent authentication required", 401> | AuthReturn | NonNullable<AuthFailReturn_1>>;
     } & {
-        readonly protectPermission: {
-            <AuthReturn, AuthFailReturn_6 = never>(check: import(".").PermissionCheck, handleAuth: (user: UserType) => 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_6) | undefined): Promise<(import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaStatus<"Forbidden", "Insufficient permissions", 403> | import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401>) | AuthReturn | Awaited<AuthFailReturn_6>>;
-            <AuthReturn, AuthFailReturn_7 = never>(check: import(".").PermissionCheck, handleAuth: (user: UserType) => 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_7) | undefined): Promise<(import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaStatus<"Forbidden", "Insufficient permissions", 403> | import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401>) | AuthReturn | Awaited<AuthFailReturn_7>>;
-        };
+        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").ElysiaStatus<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaStatus<"Forbidden", "Insufficient permissions", 403> | AuthReturn | NonNullable<AuthFailReturn_3>>;
     } & {
-        readonly protectAgent: {
-            <AuthReturn, AuthFailReturn_4 = never>(requiredScopes: string[], handleAuth: (principal: import(".").AgentPrincipal) => Promise<AuthReturn>, handleAuthFail?: (error: {
-                code: "Forbidden" | "Unauthorized";
-                message: "Agent is not authenticated" | "Insufficient agent scopes";
-            }) => AuthFailReturn_4): Promise<Response | AuthReturn | Awaited<AuthFailReturn_4>>;
-            <AuthReturn, AuthFailReturn_5 = never>(requiredScopes: string[], handleAuth: (principal: import(".").AgentPrincipal) => AuthReturn, handleAuthFail?: (error: {
-                code: "Forbidden" | "Unauthorized";
-                message: "Agent is not authenticated" | "Insufficient agent scopes";
-            }) => AuthFailReturn_5): Promise<Response | AuthReturn | Awaited<AuthFailReturn_5>>;
-        };
+        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>>>;
     });
 }, {
     typebox: {};
@@ -171,22 +91,14 @@ export declare const createAuthContext: <UserType>({ agentAuth, accessTokens, au
     macroFn: {};
     parser: {};
     response: import("elysia/types").ExtractErrorFromHandle<{
-        readonly protectRoute: {
-            <AuthReturn, AuthFailReturn = never>(handleAuth: (user: UserType) => 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").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401>) | AuthReturn | Awaited<AuthFailReturn>>;
-            <AuthReturn, AuthFailReturn_1 = never>(handleAuth: (user: UserType) => AuthReturn, handleAuthFail?: ((error: {
-                readonly code: "Bad Request";
-                readonly message: "Cookies are missing";
-            } | {
-                readonly code: "Unauthorized";
-                readonly message: "User is not authenticated";
-            }) => AuthFailReturn_1) | undefined): Promise<(import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401>) | AuthReturn | Awaited<AuthFailReturn_1>>;
-        };
+        readonly authPrincipal: import("./principal").AuthPrincipal<UserType> | undefined;
+        readonly protectRoute: <AuthReturn, AuthFailReturn = never>(handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
+            readonly code: "Bad Request";
+            readonly message: "Cookies are missing";
+        } | {
+            readonly code: "Unauthorized";
+            readonly message: "User is not authenticated";
+        }) => AuthFailReturn) | undefined) => import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | AuthReturn | Promise<AuthReturn> | NonNullable<AuthFailReturn>;
     }>;
 } & {
     schema: {};
@@ -200,16 +112,10 @@ export declare const createAuthContext: <UserType>({ agentAuth, accessTokens, au
     macroFn: {};
     parser: {};
     response: import("elysia/types").ExtractErrorFromHandle<{
-        readonly requireRecentAuth: {
-            <AuthReturn, AuthFailReturn_2 = never>(maxAgeMs: number, handleAuth: (user: UserType) => Promise<AuthReturn>, handleAuthFail?: ((error: {
-                readonly code: "Unauthorized";
-                readonly message: "Recent authentication required";
-            }) => AuthFailReturn_2) | undefined): Promise<import("elysia").ElysiaStatus<"Unauthorized", "Recent authentication required", 401> | AuthReturn | Awaited<AuthFailReturn_2>>;
-            <AuthReturn, AuthFailReturn_3 = never>(maxAgeMs: number, handleAuth: (user: UserType) => AuthReturn, handleAuthFail?: ((error: {
-                readonly code: "Unauthorized";
-                readonly message: "Recent authentication required";
-            }) => AuthFailReturn_3) | undefined): Promise<import("elysia").ElysiaStatus<"Unauthorized", "Recent authentication required", 401> | AuthReturn | Awaited<AuthFailReturn_3>>;
-        };
+        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").ElysiaStatus<"Unauthorized", "Recent authentication required", 401> | AuthReturn | NonNullable<AuthFailReturn_1>>;
     }>;
 } & (import("elysia/types").DefaultMetadata | {
     schema: {};
@@ -223,28 +129,16 @@ export declare const createAuthContext: <UserType>({ agentAuth, accessTokens, au
     macroFn: {};
     parser: {};
     response: import("elysia/types").ExtractErrorFromHandle<{
-        readonly protectPermission: {
-            <AuthReturn, AuthFailReturn_6 = never>(check: import(".").PermissionCheck, handleAuth: (user: UserType) => 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_6) | undefined): Promise<(import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaStatus<"Forbidden", "Insufficient permissions", 403> | import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401>) | AuthReturn | Awaited<AuthFailReturn_6>>;
-            <AuthReturn, AuthFailReturn_7 = never>(check: import(".").PermissionCheck, handleAuth: (user: UserType) => 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_7) | undefined): Promise<(import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaStatus<"Forbidden", "Insufficient permissions", 403> | import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401>) | AuthReturn | Awaited<AuthFailReturn_7>>;
-        };
+        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").ElysiaStatus<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaStatus<"Forbidden", "Insufficient permissions", 403> | AuthReturn | NonNullable<AuthFailReturn_3>>;
     }>;
 })) & {
     schema: {};
@@ -253,16 +147,10 @@ export declare const createAuthContext: <UserType>({ agentAuth, accessTokens, au
     macroFn: {};
     parser: {};
     response: import("elysia/types").ExtractErrorFromHandle<{
-        readonly protectAgent: {
-            <AuthReturn, AuthFailReturn_4 = never>(requiredScopes: string[], handleAuth: (principal: import(".").AgentPrincipal) => Promise<AuthReturn>, handleAuthFail?: (error: {
-                code: "Forbidden" | "Unauthorized";
-                message: "Agent is not authenticated" | "Insufficient agent scopes";
-            }) => AuthFailReturn_4): Promise<Response | AuthReturn | Awaited<AuthFailReturn_4>>;
-            <AuthReturn, AuthFailReturn_5 = never>(requiredScopes: string[], handleAuth: (principal: import(".").AgentPrincipal) => AuthReturn, handleAuthFail?: (error: {
-                code: "Forbidden" | "Unauthorized";
-                message: "Agent is not authenticated" | "Insufficient agent scopes";
-            }) => AuthFailReturn_5): Promise<Response | AuthReturn | Awaited<AuthFailReturn_5>>;
-        };
+        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>>>;
     }>;
 }, {}, import("elysia/types").DefaultEphemeral, {
     derive: {};

package/dist/authorization/protectPermission.d.ts

@@ -1,4 +1,4 @@
-import { Elysia, StatusMap, type ElysiaStatus } from 'elysia';
+import { Elysia } from 'elysia';
 import type { AuthorizationPluginProps, PermissionCheck } from './config';
 type PermissionFailError = {
     readonly code: 'Bad Request';
@@ -10,11 +10,6 @@ type PermissionFailError = {
     readonly code: 'Unauthorized';
     readonly message: 'User is not authenticated';
 };
-type PermissionFailureResponse = ElysiaStatus<'Bad Request', 'Cookies are missing', (typeof StatusMap)['Bad Request']> | ElysiaStatus<'Forbidden', 'Insufficient permissions', (typeof StatusMap)['Forbidden']> | ElysiaStatus<'Unauthorized', 'User is not authenticated', (typeof StatusMap)['Unauthorized']>;
-type ProtectPermission<UserType> = {
-    <AuthReturn, AuthFailReturn = never>(check: PermissionCheck, handleAuth: (user: UserType) => Promise<AuthReturn>, handleAuthFail?: (error: PermissionFailError) => AuthFailReturn): Promise<PermissionFailureResponse | AuthReturn | Awaited<AuthFailReturn>>;
-    <AuthReturn, AuthFailReturn = never>(check: PermissionCheck, handleAuth: (user: UserType) => AuthReturn, handleAuthFail?: (error: PermissionFailError) => AuthFailReturn): Promise<PermissionFailureResponse | AuthReturn | Awaited<AuthFailReturn>>;
-};
 export declare const protectPermissionPlugin: <UserType>({ authSessionStore, emit, hasPermission }: AuthorizationPluginProps<UserType>) => Elysia<"", "local", {
     decorator: {};
     store: {
@@ -22,7 +17,7 @@ export declare const protectPermissionPlugin: <UserType>({ authSessionStore, emi
         unregisteredSession: import("..").UnregisteredSessionRecord;
     };
     derive: {
-        readonly protectPermission: ProtectPermission<UserType>;
+        readonly protectPermission: <AuthReturn, AuthFailReturn>(check: PermissionCheck, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: PermissionFailError) => AuthFailReturn) => Promise<import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401> | AuthReturn | import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | NonNullable<AuthFailReturn> | import("elysia").ElysiaStatus<"Forbidden", "Insufficient permissions", 403>>;
     };
 }, {
     typebox: {};
@@ -39,7 +34,7 @@ export declare const protectPermissionPlugin: <UserType>({ authSessionStore, emi
     macroFn: {};
     parser: {};
     response: import("elysia/types").ExtractErrorFromHandle<{
-        readonly protectPermission: ProtectPermission<UserType>;
+        readonly protectPermission: <AuthReturn, AuthFailReturn>(check: PermissionCheck, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: PermissionFailError) => AuthFailReturn) => Promise<import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401> | AuthReturn | import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | NonNullable<AuthFailReturn> | import("elysia").ElysiaStatus<"Forbidden", "Insufficient permissions", 403>>;
     }>;
 }, {}, import("elysia/types").DefaultEphemeral, import("elysia/types").DefaultEphemeral>;
 export {};

package/dist/cli/migrate.js

@@ -2729,6 +2729,7 @@ var mfaEnrollmentsTable = pgTable9("auth_mfa_enrollments", {
   backup_code_hashes: jsonb4("backup_code_hashes").$type().notNull().default([]),
   created_at_ms: bigint7("created_at_ms", { mode: "number" }).notNull(),
   last_used_at_ms: bigint7("last_used_at_ms", { mode: "number" }),
+  mfa_factors: jsonb4("mfa_factors").$type(),
   sms_challenge_id: text4("sms_challenge_id"),
   sms_code_sent_at_ms: bigint7("sms_code_sent_at_ms", { mode: "number" }),
   sms_failed_attempts: smallint("sms_failed_attempts").notNull().default(0),
@@ -2736,6 +2737,7 @@ var mfaEnrollmentsTable = pgTable9("auth_mfa_enrollments", {
     mode: "number"
   }),
   sms_pending_code_hash: text4("sms_pending_code_hash"),
+  sms_pending_factor_id: text4("sms_pending_factor_id"),
   sms_pending_purpose: text4("sms_pending_purpose").$type(),
   sms_phone: varchar9("sms_phone", { length: PHONE_LENGTH }),
   sms_provider_reference: text4("sms_provider_reference"),
@@ -3172,12 +3174,7 @@ var renderChunk = (chunk) => {
   return "";
 };
 var formatSqlTemplate = (value) => value.queryChunks.map(renderChunk).join("");
-var columnSqlType = (column) => {
-  const dimensions = Reflect.get(column, "dimensions");
-  const elementType = column.getSQLType();
-  return typeof dimensions === "number" && dimensions > 0 ? `${elementType}${"[]".repeat(dimensions)}` : elementType;
-};
-var formatScalarDefault = (value) => {
+var formatDefault = (value) => {
   if (value === null || value === undefined)
     return "NULL";
   if (is(value, SQL))
@@ -3188,17 +3185,15 @@ var formatScalarDefault = (value) => {
     return value ? "true" : "false";
   if (typeof value === "number")
     return String(value);
-  if (typeof value === "object") {
+  if (Array.isArray(value) || typeof value === "object") {
     return `'${JSON.stringify(value)}'::jsonb`;
   }
   return String(value);
 };
-var formatArrayDefault = (values) => `ARRAY[${values.map((value) => Array.isArray(value) ? formatArrayDefault(value) : formatScalarDefault(value)).join(", ")}]`;
-var formatDefault = (column, value) => {
+var columnSqlType = (column) => {
   const dimensions = Reflect.get(column, "dimensions");
-  if (Array.isArray(value) && typeof dimensions === "number" && dimensions > 0)
-    return `${formatArrayDefault(value)}::${columnSqlType(column)}`;
-  return formatScalarDefault(value);
+  const elementType = column.getSQLType();
+  return typeof dimensions === "number" && dimensions > 0 ? `${elementType}${"[]".repeat(dimensions)}` : elementType;
 };
 var columnSql = (column) => {
   const parts = [`"${column.name}"`, columnSqlType(column)];
@@ -3207,7 +3202,7 @@ var columnSql = (column) => {
   if (column.notNull && !column.primary)
     parts.push("NOT NULL");
   if (column.hasDefault && column.default !== undefined) {
-    parts.push(`DEFAULT ${formatDefault(column, column.default)}`);
+    parts.push(`DEFAULT ${formatDefault(column.default)}`);
   }
   if (column.isUnique)
     parts.push("UNIQUE");
@@ -3326,6 +3321,14 @@ var mfaSmsAtomicChallengeMigration = {
   id: "0005_sms_atomic_challenge",
   sql: 'ALTER TABLE "auth_mfa_enrollments" ADD COLUMN IF NOT EXISTS "sms_challenge_id" text;'
 };
+var mfaMultipleFactorsMigration = {
+  id: "0006_multiple_factors",
+  sql: [
+    'ALTER TABLE "auth_mfa_enrollments" ADD COLUMN IF NOT EXISTS "mfa_factors" jsonb;',
+    'ALTER TABLE "auth_mfa_enrollments" ADD COLUMN IF NOT EXISTS "sms_pending_factor_id" text;'
+  ].join(`
+`)
+};
 var oidcResourceAudienceMigration = {
   id: "0002_resource_audience",
   sql: [
@@ -3407,7 +3410,8 @@ var blockMigrations = {
       mfaSmsColumnsMigration,
       mfaTotpLockoutMigration,
       mfaSmsDeliveryPolicyMigration,
-      mfaSmsAtomicChallengeMigration
+      mfaSmsAtomicChallengeMigration,
+      mfaMultipleFactorsMigration
     ]
   },
   oidc: {
@@ -3648,5 +3652,5 @@ var main = async () => {
 };
 await main();
 
-//# debugId=7AED48AC2EB444BB64756E2164756E21
+//# debugId=56E24220E33BD93664756E2164756E21
 //# sourceMappingURL=migrate.js.map