@absolutejs/auth 0.75.7 → 0.76.1

package/dist/index.d.ts

@@ -9,134 +9,54 @@ export declare const auth: <UserType>(configuration: AuthConfig<UserType>) => Pr
         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_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 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 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: {};
@@ -160,22 +80,14 @@ export declare const auth: <UserType>(configuration: AuthConfig<UserType>) => Pr
     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: {};
@@ -189,16 +101,10 @@ export declare const auth: <UserType>(configuration: AuthConfig<UserType>) => Pr
     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: {};
@@ -212,28 +118,16 @@ export declare const auth: <UserType>(configuration: AuthConfig<UserType>) => Pr
     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: {};
@@ -242,16 +136,10 @@ export declare const auth: <UserType>(configuration: AuthConfig<UserType>) => Pr
     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: {};
@@ -271,134 +159,54 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
             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: {};
@@ -422,22 +230,14 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
         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: {};
@@ -451,16 +251,10 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
         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: {};
@@ -474,28 +268,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
         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: {};
@@ -504,16 +286,10 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
         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: {};
@@ -1160,38 +936,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
             session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
             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: import(".").AuthHtmxUser | null;
-            };
+        derive: {} | {
             readonly authPrincipal: import("./principal").AuthPrincipal<import(".").AuthHtmxUser> | undefined;
-        } & {
-            readonly protectRoute: {
-                <AuthReturn, AuthFailReturn = never>(handleAuth: (user: import(".").AuthHtmxUser) => 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: import(".").AuthHtmxUser) => 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 protectRoute: <AuthReturn, AuthFailReturn = never>(handleAuth: (user: import(".").AuthHtmxUser) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
+                readonly code: "Bad Request";
+                readonly message: "Cookies are missing";
+            } | {
+                readonly code: "Unauthorized";
+                readonly message: "User is not authenticated";
+            }) => AuthFailReturn) | undefined) => import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | AuthReturn | Promise<AuthReturn> | NonNullable<AuthFailReturn>;
+        };
     }, {
         typebox: {};
         error: [];
@@ -1214,22 +968,14 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
         macroFn: {};
         parser: {};
         response: import("elysia/types").ExtractErrorFromHandle<{
-            readonly protectRoute: {
-                <AuthReturn, AuthFailReturn = never>(handleAuth: (user: import(".").AuthHtmxUser) => 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: import(".").AuthHtmxUser) => 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<import(".").AuthHtmxUser> | undefined;
+            readonly protectRoute: <AuthReturn, AuthFailReturn = never>(handleAuth: (user: import(".").AuthHtmxUser) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
+                readonly code: "Bad Request";
+                readonly message: "Cookies are missing";
+            } | {
+                readonly code: "Unauthorized";
+                readonly message: "User is not authenticated";
+            }) => AuthFailReturn) | undefined) => import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | AuthReturn | Promise<AuthReturn> | NonNullable<AuthFailReturn>;
         }>;
     } & {
         schema: {};
@@ -1430,6 +1176,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
                     200: {
                         backupCodesRemaining: number;
                         enabled: boolean;
+                        factors: import(".").MfaPublicFactor[];
                         smsBackup: {
                             enabled: boolean;
                             phone: string | null;
@@ -1478,16 +1225,52 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
                 error: never;
             };
         };
+    } & {
+        [x: string]: {
+            factors: {
+                ":factorId": {
+                    delete: {
+                        body: unknown;
+                        params: {
+                            factorId: string;
+                        };
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            401: "Recent authentication required" | "Authentication required";
+                            404: "MFA factor not found";
+                            200: {
+                                readonly status: "removed";
+                            };
+                            422: {
+                                type: "validation";
+                                title: "Validation Error";
+                                status: 422;
+                                detail?: string;
+                                on: string;
+                                found?: unknown;
+                                property?: string;
+                                expected?: string;
+                            };
+                        };
+                        error: never;
+                    };
+                };
+            };
+        };
     } & {
         [x: string]: {
             post: {
-                body: unknown;
+                body: {
+                    label?: string | undefined;
+                };
                 params: {};
                 query: unknown;
                 headers: unknown;
                 response: {
                     401: "Recent authentication required" | "Authentication required";
                     200: {
+                        readonly factorId: string;
                         readonly secret: string;
                         readonly uri: string;
                     };
@@ -1509,6 +1292,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
         [x: string]: {
             post: {
                 body: {
+                    factorId?: string | undefined;
                     code: string;
                 };
                 params: {};
@@ -1538,6 +1322,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
         [x: string]: {
             post: {
                 body: {
+                    label?: string | undefined;
                     phone: string;
                 };
                 params: {};
@@ -1548,6 +1333,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
                     401: "Recent authentication required" | "Authentication required";
                     501: "SMS MFA is not configured";
                     200: {
+                        readonly factorId: string;
                         readonly phone: string;
                     };
                     422: {
@@ -1570,6 +1356,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
         [x: string]: {
             post: {
                 body: {
+                    factorId?: string | undefined;
                     code: string;
                 };
                 params: {};
@@ -1597,13 +1384,46 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
                 error: never;
             };
         };
+    } & {
+        [x: string]: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    401: "No MFA challenge in progress";
+                    200: {
+                        backupCodesAvailable: boolean;
+                        factors: Array<{
+                            id: string;
+                            label: string;
+                            phone: string | null;
+                            type: "sms" | "totp";
+                        }>;
+                    };
+                    422: {
+                        type: "validation";
+                        title: "Validation Error";
+                        status: 422;
+                        detail?: string;
+                        on: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+                error: never;
+            };
+        };
     } & {
         [x: string]: {
             post: {
                 body: {
                     code?: string | undefined;
                     action?: "verify" | "send" | undefined;
-                    factor?: "sms" | undefined;
+                    factorId?: string | undefined;
+                    factor?: "sms" | "backup_codes" | "totp" | undefined;
                 };
                 params: {};
                 query: unknown;
@@ -1612,6 +1432,8 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
                     400: string;
                     401: "SMS code expired" | "Too many attempts" | "SMS challenge is no longer active" | "No MFA challenge in progress" | "Invalid MFA code";
                     200: {
+                        readonly factorId: string;
+                        readonly phone: string;
                         readonly status: "sent";
                     } | {
                         readonly status: "authenticated";
@@ -3703,9 +3525,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
                     query: unknown;
                     headers: unknown;
                     response: {
-                        400: "Cookies are missing";
-                        401: "User is not authenticated";
-                        200: Response;
+                        200: {};
                         422: {
                             type: "validation";
                             title: "Validation Error";
@@ -3734,9 +3554,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
                             query: unknown;
                             headers: unknown;
                             response: {
-                                400: "Cookies are missing";
-                                401: "User is not authenticated";
-                                200: Response;
+                                200: {};
                                 422: {
                                     type: "validation";
                                     title: "Validation Error";
@@ -3766,9 +3584,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
                         query: unknown;
                         headers: unknown;
                         response: {
-                            400: "Cookies are missing";
-                            401: "User is not authenticated";
-                            200: Response;
+                            200: {};
                             422: {
                                 type: "validation";
                                 title: "Validation Error";
@@ -3797,9 +3613,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
                         query: unknown;
                         headers: unknown;
                         response: {
-                            400: "Cookies are missing";
-                            401: "User is not authenticated";
-                            200: Response;
+                            200: {};
                             422: {
                                 type: "validation";
                                 title: "Validation Error";
@@ -3828,9 +3642,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
                         query: unknown;
                         headers: unknown;
                         response: {
-                            400: "Cookies are missing";
-                            401: "User is not authenticated";
-                            200: Response;
+                            200: {};
                             422: {
                                 type: "validation";
                                 title: "Validation Error";
@@ -3887,9 +3699,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
                             query: unknown;
                             headers: unknown;
                             response: {
-                                400: "Cookies are missing";
-                                401: "User is not authenticated";
-                                200: Response;
+                                200: {};
                                 422: {
                                     type: "validation";
                                     title: "Validation Error";
@@ -3920,9 +3730,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
                             query: unknown;
                             headers: unknown;
                             response: {
-                                400: "Cookies are missing";
-                                401: "User is not authenticated";
-                                200: Response;
+                                200: {};
                                 422: {
                                     type: "validation";
                                     title: "Validation Error";
@@ -3974,9 +3782,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
                     query: unknown;
                     headers: unknown;
                     response: {
-                        400: "Cookies are missing";
-                        401: "User is not authenticated";
-                        200: Response;
+                        200: {};
                         422: {
                             type: "validation";
                             title: "Validation Error";
@@ -4186,9 +3992,9 @@ export * from './mfa/types';
 export * from './verification/types';
 export { consumeBackupCode, generateBackupCodes } from './mfa/backupCodes';
 export { createMfaGate } from './mfa/gate';
-export { mfaChallenge } from './mfa/challenge';
+export { mfaChallenge, type MfaChallengeOptions } from './mfa/challenge';
 export { mfaRoutes } from './mfa/routes';
-export { mfaManagementRoutes, type MfaStatus } from './mfa/management';
+export { mfaManagementRoutes, type MfaPublicFactor, type MfaStatus } from './mfa/management';
 export { rotateMfaEncryptionKey } from './mfa/rotation';
 export type { MfaKeyRotationResult } from './mfa/rotation';
 export { mfaTotpRoutes } from './mfa/totp';