@absolutejs/auth 0.56.4 → 0.56.5

package/dist/audit/postgresAuditStore.d.ts

@@ -0,0 +1,116 @@
+import { type AnyPgDatabase } from '../stores/postgres';
+import type { AuditSink } from './types';
+export declare const auditEventsTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "auth_audit_events";
+    schema: undefined;
+    columns: {
+        at_ms: import("drizzle-orm/pg-core").PgBuildColumn<"auth_audit_events", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgBigInt53Builder>, {
+            name: string;
+            tableName: "auth_audit_events";
+            dataType: "number int53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        id: import("drizzle-orm/pg-core").PgBuildColumn<"auth_audit_events", import("drizzle-orm/pg-core").SetIsPrimaryKey<import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>>, {
+            name: string;
+            tableName: "auth_audit_events";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        ip: import("drizzle-orm/pg-core").PgBuildColumn<"auth_audit_events", import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>, {
+            name: string;
+            tableName: "auth_audit_events";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        metadata_json: import("drizzle-orm/pg-core").PgBuildColumn<"auth_audit_events", import("drizzle-orm/pg-core").Set$Type<import("drizzle-orm/pg-core").PgJsonbBuilder, Record<string, unknown>>, {
+            name: string;
+            tableName: "auth_audit_events";
+            dataType: "object json";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        organization_id: import("drizzle-orm/pg-core").PgBuildColumn<"auth_audit_events", import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>, {
+            name: string;
+            tableName: "auth_audit_events";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        type: import("drizzle-orm/pg-core").PgBuildColumn<"auth_audit_events", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>>, {
+            name: string;
+            tableName: "auth_audit_events";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        user_id: import("drizzle-orm/pg-core").PgBuildColumn<"auth_audit_events", import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>, {
+            name: string;
+            tableName: "auth_audit_events";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+    };
+    dialect: "pg";
+}>;
+export declare const createNeonAuditSink: (databaseUrl: string) => AuditSink;
+export declare const createPostgresAuditSink: <DB extends AnyPgDatabase>(db: DB) => AuditSink;

package/dist/audit/siem.d.ts

@@ -0,0 +1,11 @@
+import type { AuditSink } from './types';
+export type SiemFormat = 'datadog' | 'generic' | 'splunk';
+export type SiemEndpoint = {
+    format?: SiemFormat;
+    headers?: Record<string, string>;
+    token?: string;
+    url: string;
+};
+export declare const createSiemLogStream: ({ endpoints }: {
+    endpoints: SiemEndpoint[];
+}) => AuditSink;

package/dist/audit/types.d.ts

@@ -0,0 +1,19 @@
+import type { OrganizationId } from '../tenancy';
+export type AuditEventType = 'account_deleted' | 'agent_credential_issued' | 'agent_delegated' | 'agent_registered' | 'agent_revoked' | 'authorization_denied' | 'credentials_login' | 'credentials_login_failed' | 'data_exported' | 'email_verified' | 'identity_conflict' | 'impersonation_ended' | 'impersonation_started' | 'invitation_accepted' | 'invitation_created' | 'logout' | 'membership_removed' | 'mfa_challenge' | 'mfa_challenge_failed' | 'mfa_enrolled' | 'oauth_login' | 'organization_created' | 'password_reset' | 'passwordless_login' | 'register' | 'role_assigned' | 'scim_provision' | 'scim_token_created' | 'session_revoked' | 'setup_session_created' | 'sso_connection_configured' | 'sso_login' | 'token_refreshed' | 'token_revoked' | 'webauthn_authenticated' | 'webauthn_registered';
+export type AuditEvent = {
+    at: number;
+    ip?: string;
+    metadata?: Record<string, unknown>;
+    organizationId?: OrganizationId;
+    type: AuditEventType;
+    userId?: string;
+};
+export type AuditEventFilter = {
+    limit?: number;
+    userId?: string;
+};
+export type AuditSink = {
+    append: (event: AuditEvent) => Promise<void>;
+    list?: (filter?: AuditEventFilter) => Promise<AuditEvent[]>;
+    prune?: (before: number) => Promise<number>;
+};

package/dist/audit/wrap.d.ts

@@ -0,0 +1,9 @@
+import type { CredentialsConfig } from '../credentials/config';
+import type { MfaConfig } from '../mfa/config';
+import type { OnCallbackSuccess, OnRevocationSuccess, OnSignOut } from '../types';
+import type { AuditEmitter } from './config';
+export declare const composeCallbackAudit: <UserType>(onCallbackSuccess: OnCallbackSuccess<UserType>, emit: AuditEmitter) => (context: Parameters<NonNullable<OnCallbackSuccess<UserType>>>[0]) => Promise<void | Response | import("..").StatusReturn>;
+export declare const composeCredentialsAudit: <UserType>(credentials: CredentialsConfig<UserType>, emit: AuditEmitter, getUserId?: (user: UserType) => string) => CredentialsConfig<UserType>;
+export declare const composeMfaAudit: <UserType>(mfa: MfaConfig<UserType>, emit: AuditEmitter) => MfaConfig<UserType>;
+export declare const composeRevocationAudit: (onRevocationSuccess: OnRevocationSuccess, emit: AuditEmitter) => (context: Parameters<NonNullable<OnRevocationSuccess>>[0]) => Promise<void | undefined>;
+export declare const composeSignOutAudit: <UserType>(onSignOut: OnSignOut<UserType>, emit: AuditEmitter) => (context: Parameters<NonNullable<OnSignOut<UserType>>>[0]) => Promise<void | undefined>;

package/dist/authContext.d.ts

@@ -0,0 +1,193 @@
+import { Elysia } from 'elysia';
+import type { AgentAuthConfig } from './agents/config';
+import type { AuditEmitter } from './audit/config';
+import type { AuthorizationConfig } from './authorization/config';
+import type { AuthSessionStore } from './session/types';
+export declare const createAuthContext: <UserType>({ agentAuth, authSessionStore, authorization, emit, seedSource }: {
+    agentAuth?: AgentAuthConfig;
+    authSessionStore?: AuthSessionStore<UserType>;
+    authorization?: AuthorizationConfig<UserType>;
+    emit?: AuditEmitter;
+    seedSource?: object;
+}) => Elysia<"", {
+    decorator: {};
+    store: {
+        session: import("./types").SessionRecord<UserType>;
+        unregisteredSession: import("./types").UnregisteredSessionRecord;
+    };
+    derive: ({
+        readonly protectRoute: <AuthReturn, AuthFailReturn>(handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
+            readonly code: "Bad Request";
+            readonly message: "Cookies are missing";
+        } | {
+            readonly code: "Unauthorized";
+            readonly message: "User is not authenticated";
+        }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
+    } & {
+        readonly requireRecentAuth: <AuthReturn, AuthFailReturn_1>(maxAgeMs: number, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
+            readonly code: "Unauthorized";
+            readonly message: "Recent authentication required";
+        }) => AuthFailReturn_1) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "Recent authentication required", 401> | AuthReturn | NonNullable<AuthFailReturn_1>>;
+    } & {
+        readonly protectAgent: <AuthReturn, AuthFailReturn_2>(requiredScopes: string[], handleAuth: (principal: import(".").AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: {
+            code: "Forbidden" | "Unauthorized";
+            message: "Agent is not authenticated" | "Insufficient agent scopes";
+        }) => AuthFailReturn_2 | Promise<AuthFailReturn_2>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn_2>>>;
+    }) | ({
+        readonly protectRoute: <AuthReturn, AuthFailReturn>(handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
+            readonly code: "Bad Request";
+            readonly message: "Cookies are missing";
+        } | {
+            readonly code: "Unauthorized";
+            readonly message: "User is not authenticated";
+        }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
+    } & {
+        readonly requireRecentAuth: <AuthReturn, AuthFailReturn_1>(maxAgeMs: number, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
+            readonly code: "Unauthorized";
+            readonly message: "Recent authentication required";
+        }) => AuthFailReturn_1) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "Recent authentication required", 401> | AuthReturn | NonNullable<AuthFailReturn_1>>;
+    } & {
+        readonly protectPermission: <AuthReturn, AuthFailReturn_3>(check: import(".").PermissionCheck, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
+            readonly code: "Bad Request";
+            readonly message: "Cookies are missing";
+        } | {
+            readonly code: "Forbidden";
+            readonly message: "Insufficient permissions";
+        } | {
+            readonly code: "Unauthorized";
+            readonly message: "User is not authenticated";
+        }) => AuthFailReturn_3) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaCustomStatusResponse<"Forbidden", "Insufficient permissions", 403> | AuthReturn | NonNullable<AuthFailReturn_3>>;
+    } & {
+        readonly protectAgent: <AuthReturn, AuthFailReturn_2>(requiredScopes: string[], handleAuth: (principal: import(".").AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: {
+            code: "Forbidden" | "Unauthorized";
+            message: "Agent is not authenticated" | "Insufficient agent scopes";
+        }) => AuthFailReturn_2 | Promise<AuthFailReturn_2>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn_2>>>;
+    });
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+} & {
+    typebox: {};
+    error: {};
+}, ({
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+} & {
+    schema: import("elysia").UnwrapRoute<{
+        cookie: import("@sinclair/typebox").TObject<{
+            user_session_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"${string}-${string}-${string}-${string}-${string}">>;
+        }>;
+    }, {}, "">;
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: import("elysia").ExtractErrorFromHandle<{
+        readonly protectRoute: <AuthReturn, AuthFailReturn>(handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
+            readonly code: "Bad Request";
+            readonly message: "Cookies are missing";
+        } | {
+            readonly code: "Unauthorized";
+            readonly message: "User is not authenticated";
+        }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
+    }>;
+} & {
+    schema: import("elysia").UnwrapRoute<{
+        cookie: import("@sinclair/typebox").TObject<{
+            user_session_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"${string}-${string}-${string}-${string}-${string}">>;
+        }>;
+    }, {}, "">;
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: import("elysia").ExtractErrorFromHandle<{
+        readonly requireRecentAuth: <AuthReturn, AuthFailReturn_1>(maxAgeMs: number, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
+            readonly code: "Unauthorized";
+            readonly message: "Recent authentication required";
+        }) => AuthFailReturn_1) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "Recent authentication required", 401> | AuthReturn | NonNullable<AuthFailReturn_1>>;
+    }>;
+} & ({
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+} | {
+    schema: import("elysia").UnwrapRoute<{
+        cookie: import("@sinclair/typebox").TObject<{
+            user_session_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"${string}-${string}-${string}-${string}-${string}">>;
+        }>;
+    }, {}, "">;
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: import("elysia").ExtractErrorFromHandle<{
+        readonly protectPermission: <AuthReturn, AuthFailReturn_3>(check: import(".").PermissionCheck, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
+            readonly code: "Bad Request";
+            readonly message: "Cookies are missing";
+        } | {
+            readonly code: "Forbidden";
+            readonly message: "Insufficient permissions";
+        } | {
+            readonly code: "Unauthorized";
+            readonly message: "User is not authenticated";
+        }) => AuthFailReturn_3) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaCustomStatusResponse<"Forbidden", "Insufficient permissions", 403> | AuthReturn | NonNullable<AuthFailReturn_3>>;
+    }>;
+})) & {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: import("elysia").ExtractErrorFromHandle<{
+        readonly protectAgent: <AuthReturn, AuthFailReturn_2>(requiredScopes: string[], handleAuth: (principal: import(".").AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: {
+            code: "Forbidden" | "Unauthorized";
+            message: "Agent is not authenticated" | "Insufficient agent scopes";
+        }) => AuthFailReturn_2 | Promise<AuthFailReturn_2>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn_2>>>;
+    }>;
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, ({
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+} & {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}) | ({
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+} & {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+} & {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+})>;
+export type AuthInstance<UserType> = ReturnType<typeof createAuthContext<UserType>>;

package/dist/authorization/config.d.ts

@@ -0,0 +1,19 @@
+import type { AuditEmitter } from '../audit/config';
+import type { AuthSessionStore } from '../session/types';
+import type { OrganizationId } from '../tenancy';
+export type PermissionContext<UserType> = {
+    organizationId?: OrganizationId;
+    permission: string;
+    user: UserType;
+};
+export type AuthorizationConfig<UserType> = {
+    hasPermission: (context: PermissionContext<UserType>) => boolean | Promise<boolean>;
+};
+export type PermissionCheck = {
+    organizationId?: OrganizationId;
+    permission: string;
+};
+export type AuthorizationPluginProps<UserType> = AuthorizationConfig<UserType> & {
+    authSessionStore?: AuthSessionStore<UserType>;
+    emit?: AuditEmitter;
+};

package/dist/authorization/protectPermission.d.ts

@@ -0,0 +1,52 @@
+import { Elysia } from 'elysia';
+import type { AuthorizationPluginProps, PermissionCheck } from './config';
+type PermissionFailError = {
+    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';
+};
+export declare const protectPermissionPlugin: <UserType>({ authSessionStore, emit, hasPermission }: AuthorizationPluginProps<UserType>) => Elysia<"", {
+    decorator: {};
+    store: {
+        session: import("..").SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
+    };
+    derive: {
+        readonly protectPermission: <AuthReturn, AuthFailReturn>(check: PermissionCheck, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: PermissionFailError) => AuthFailReturn) => Promise<AuthReturn | import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | NonNullable<AuthFailReturn> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaCustomStatusResponse<"Forbidden", "Insufficient permissions", 403>>;
+    };
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: import("elysia").UnwrapRoute<{
+        cookie: import("@sinclair/typebox").TObject<{
+            user_session_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"${string}-${string}-${string}-${string}-${string}">>;
+        }>;
+    }, {}, "">;
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: import("elysia").ExtractErrorFromHandle<{
+        readonly protectPermission: <AuthReturn, AuthFailReturn>(check: PermissionCheck, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: PermissionFailError) => AuthFailReturn) => Promise<AuthReturn | import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | NonNullable<AuthFailReturn> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaCustomStatusResponse<"Forbidden", "Insufficient permissions", 403>>;
+    }>;
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export {};

package/dist/compliance/cipher.d.ts

@@ -0,0 +1,11 @@
+export type SecretCipher = {
+    decrypt: (ciphertext: string) => Promise<string>;
+    encrypt: (plaintext: string) => Promise<string>;
+    needsReencryption?: (ciphertext: string) => boolean;
+};
+export declare const createSecretCipher: (keyMaterial: string) => SecretCipher;
+export declare const createVersionedSecretCipher: ({ currentVersion, keys, legacyKey }: {
+    currentVersion: number;
+    keys: Readonly<Record<number, string>>;
+    legacyKey?: string;
+}) => SecretCipher;

package/dist/compliance/config.d.ts

@@ -0,0 +1,18 @@
+import type { AuditEmitter } from '../audit/config';
+import type { AuthSessionStore } from '../session/types';
+import type { RouteString } from '../types';
+export type ComplianceConfig<UserType> = {
+    complianceRoute?: RouteString;
+    deleteUserData: (context: {
+        user: UserType;
+        userId?: string;
+    }) => void | Promise<void>;
+    exportUserData: (context: {
+        user: UserType;
+    }) => Record<string, unknown> | Promise<Record<string, unknown>>;
+    getUserId?: (user: UserType) => string;
+};
+export type CompliancePluginProps<UserType> = ComplianceConfig<UserType> & {
+    authSessionStore?: AuthSessionStore<UserType>;
+    emit?: AuditEmitter;
+};

package/dist/compliance/redaction.d.ts

@@ -0,0 +1,8 @@
+import type { AuditEvent } from '../audit/types';
+type AuditRedactorOptions = {
+    dropFields?: string[];
+    hashFields?: string[];
+    redactIp?: boolean;
+};
+export declare const createAuditRedactor: ({ dropFields, hashFields, redactIp }: AuditRedactorOptions) => (event: AuditEvent) => Promise<AuditEvent>;
+export {};

package/dist/compliance/routes.d.ts

@@ -0,0 +1,89 @@
+import { Elysia } from 'elysia';
+import type { CompliancePluginProps } from './config';
+export declare const complianceRoutes: <UserType>({ authSessionStore, complianceRoute, deleteUserData, emit, exportUserData, getUserId }: CompliancePluginProps<UserType>) => Elysia<"", {
+    decorator: {};
+    store: {
+        session: import("..").SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
+    };
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        export: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    401: "Authentication required";
+                    200: {
+                        [x: string]: unknown;
+                    };
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        delete: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                401: "Authentication required";
+                200: {
+                    readonly deleted: true;
+                };
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+} & {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const SECONDS_IN_A_MINUTE = 60;
+export declare const MILLISECONDS_IN_A_SECOND = 1000;
+export declare const MILLISECONDS_IN_A_MINUTE: number;
+export declare const MINUTES_IN_AN_HOUR = 60;
+export declare const HOURS_IN_A_DAY = 24;
+export declare const MILLISECONDS_IN_A_DAY: number;
+export declare const MILLISECONDS_IN_AN_HOUR: number;
+export declare const COOKIE_MINUTES = 30;
+export declare const COOKIE_DURATION: number;
+export declare const DEFAULT_MAX_SESSIONS = 10000;

package/dist/credentials/backgroundOps.d.ts

@@ -0,0 +1,45 @@
+export type BreachRecord = {
+    addedDate: string;
+    dataClasses?: string[];
+    name: string;
+};
+export type EmailBreachEvent = {
+    breaches: BreachRecord[];
+    email: string;
+};
+export type EmailBreachScanInput = {
+    hibpApiKey: string;
+    iterateEmails: (cursor: string | undefined) => Promise<{
+        emails: string[];
+        nextCursor: string | undefined;
+    }>;
+    onBreachFound: (event: EmailBreachEvent) => Promise<void> | void;
+    pauseMs?: number;
+    truncateResponse?: boolean;
+};
+export type EmailBreachScanResult = {
+    breached: number;
+    scanned: number;
+};
+export declare const runEmailBreachScan: (input: EmailBreachScanInput) => Promise<EmailBreachScanResult>;
+export type InactiveUserCandidate = {
+    createdAt?: number;
+    lastLoginAt: number | null;
+    userId: string;
+};
+export type PruneInactiveUsersInput = {
+    dryRun?: boolean;
+    iterateUsers: (cursor: string | undefined) => Promise<{
+        nextCursor: string | undefined;
+        users: InactiveUserCandidate[];
+    }>;
+    now?: () => number;
+    olderThanDays: number;
+    onDelete: (userId: string) => Promise<void> | void;
+};
+export type PruneInactiveUsersResult = {
+    dryRun: boolean;
+    prunedUserIds: string[];
+    scanned: number;
+};
+export declare const pruneInactiveUsers: (input: PruneInactiveUsersInput) => Promise<PruneInactiveUsersResult>;