@absolutejs/auth 0.69.4 → 0.69.6

package/dist/client/solid.d.ts

@@ -0,0 +1,86 @@
+import { type Accessor } from 'solid-js';
+import type { AuthClient, AuthClientError } from './createAuthClient';
+type Mutator<Args, Data> = (args: Args) => Promise<{
+    data: Data | null;
+    error: AuthClientError | null;
+}>;
+type MutationState<Args, Data> = {
+    data: Accessor<Data | null>;
+    error: Accessor<AuthClientError | null>;
+    isPending: Accessor<boolean>;
+    mutate: Mutator<Args, Data>;
+    reset: () => void;
+};
+export declare const useMagicLink: (client: AuthClient) => MutationState<{
+    email: string;
+}, {
+    ok: true;
+}>;
+export declare const useMfaChallenge: (client: AuthClient) => MutationState<{
+    code: string;
+}, {
+    status: "authenticated";
+}>;
+export declare const usePasskeyAutofill: (client: AuthClient) => {
+    cancel: () => void;
+    data: Accessor<{
+        status: "authenticated";
+    } | null>;
+    error: Accessor<AuthClientError | null>;
+    isPending: Accessor<boolean>;
+    start: () => Promise<void>;
+};
+export declare const usePasswordReset: (client: AuthClient) => MutationState<{
+    email: string;
+}, {
+    ok: true;
+}>;
+export declare const useSessions: (client: AuthClient) => {
+    data: Accessor<unknown[] | null>;
+    error: Accessor<AuthClientError | null>;
+    isPending: Accessor<boolean>;
+    refetch: () => Promise<void>;
+    revoke: (sessionId: string) => Promise<{
+        data: null;
+        error: AuthClientError;
+    } | {
+        data: {
+            ok: true;
+        };
+        error: null;
+    }>;
+};
+export declare const useSignIn: (client: AuthClient) => MutationState<{
+    email: string;
+    password: string;
+}, {
+    passwordCompromised?: boolean;
+    status: "authenticated" | "mfa_required";
+}>;
+export declare const useSignOut: (client: AuthClient) => MutationState<unknown, null>;
+export declare const useSignUp: (client: AuthClient) => MutationState<{
+    [extra: string]: unknown;
+    email: string;
+    password: string;
+}, {
+    status: "authenticated";
+} | {
+    status: "verification_required";
+}>;
+export declare const useUpgradeToPasskey: (client: AuthClient) => {
+    error: Accessor<AuthClientError | null>;
+    isPending: Accessor<boolean>;
+    passkeys: Accessor<unknown[] | null>;
+    refetch: () => Promise<void>;
+    register: () => Promise<{
+        data: null;
+        error: AuthClientError;
+    } | {
+        data: {
+            ok: true;
+        };
+        error: null;
+    }>;
+    shouldPrompt: () => boolean;
+};
+export {};

package/dist/client/svelte.d.ts

@@ -0,0 +1,86 @@
+import { type Writable } from 'svelte/store';
+import type { AuthClient, AuthClientError } from './createAuthClient';
+type Mutator<Args, Data> = (args: Args) => Promise<{
+    data: Data | null;
+    error: AuthClientError | null;
+}>;
+type MutationState<Args, Data> = {
+    data: Writable<Data | null>;
+    error: Writable<AuthClientError | null>;
+    isPending: Writable<boolean>;
+    mutate: Mutator<Args, Data>;
+    reset: () => void;
+};
+export declare const useMagicLink: (client: AuthClient) => MutationState<{
+    email: string;
+}, {
+    ok: true;
+}>;
+export declare const useMfaChallenge: (client: AuthClient) => MutationState<{
+    code: string;
+}, {
+    status: "authenticated";
+}>;
+export declare const usePasskeyAutofill: (client: AuthClient) => {
+    cancel: () => void;
+    data: Writable<{
+        status: "authenticated";
+    } | null>;
+    error: Writable<AuthClientError | null>;
+    isPending: Writable<boolean>;
+    start: () => Promise<void>;
+};
+export declare const usePasswordReset: (client: AuthClient) => MutationState<{
+    email: string;
+}, {
+    ok: true;
+}>;
+export declare const useSessions: (client: AuthClient) => {
+    data: Writable<unknown[] | null>;
+    error: Writable<AuthClientError | null>;
+    isPending: Writable<boolean>;
+    refetch: () => Promise<void>;
+    revoke: (sessionId: string) => Promise<{
+        data: null;
+        error: AuthClientError;
+    } | {
+        data: {
+            ok: true;
+        };
+        error: null;
+    }>;
+};
+export declare const useSignIn: (client: AuthClient) => MutationState<{
+    email: string;
+    password: string;
+}, {
+    passwordCompromised?: boolean;
+    status: "authenticated" | "mfa_required";
+}>;
+export declare const useSignOut: (client: AuthClient) => MutationState<unknown, null>;
+export declare const useSignUp: (client: AuthClient) => MutationState<{
+    [extra: string]: unknown;
+    email: string;
+    password: string;
+}, {
+    status: "authenticated";
+} | {
+    status: "verification_required";
+}>;
+export declare const useUpgradeToPasskey: (client: AuthClient) => {
+    error: Writable<AuthClientError | null>;
+    isPending: Writable<boolean>;
+    passkeys: Writable<unknown[] | null>;
+    refetch: () => Promise<void>;
+    register: () => Promise<{
+        data: null;
+        error: AuthClientError;
+    } | {
+        data: {
+            ok: true;
+        };
+        error: null;
+    }>;
+    shouldPrompt: Writable<boolean>;
+};
+export {};

package/dist/client/vue.d.ts

@@ -0,0 +1,88 @@
+import { type Ref } from 'vue';
+import type { AuthClient, AuthClientError } from './createAuthClient';
+type Mutator<Args, Data> = (args: Args) => Promise<{
+    data: Data | null;
+    error: AuthClientError | null;
+}>;
+type MutationState<Args, Data> = {
+    data: Ref<Data | null>;
+    error: Ref<AuthClientError | null>;
+    isPending: Ref<boolean>;
+    mutate: Mutator<Args, Data>;
+    reset: () => void;
+};
+export declare const useMagicLink: (client: AuthClient) => MutationState<{
+    email: string;
+}, {
+    ok: true;
+}>;
+export declare const useMfaChallenge: (client: AuthClient) => MutationState<{
+    code: string;
+}, {
+    status: "authenticated";
+}>;
+export declare const usePasskeyAutofill: (client: AuthClient) => {
+    cancel: () => void;
+    data: Ref<{
+        status: "authenticated";
+    } | null, {
+        status: "authenticated";
+    } | null>;
+    error: Ref<AuthClientError | null, AuthClientError | null>;
+    isPending: Ref<boolean, boolean>;
+    start: () => Promise<void>;
+};
+export declare const usePasswordReset: (client: AuthClient) => MutationState<{
+    email: string;
+}, {
+    ok: true;
+}>;
+export declare const useSessions: (client: AuthClient) => {
+    data: Ref<unknown[] | null, unknown[] | null>;
+    error: Ref<AuthClientError | null, AuthClientError | null>;
+    isPending: Ref<boolean, boolean>;
+    refetch: () => Promise<void>;
+    revoke: (sessionId: string) => Promise<{
+        data: null;
+        error: AuthClientError;
+    } | {
+        data: {
+            ok: true;
+        };
+        error: null;
+    }>;
+};
+export declare const useSignIn: (client: AuthClient) => MutationState<{
+    email: string;
+    password: string;
+}, {
+    passwordCompromised?: boolean;
+    status: "authenticated" | "mfa_required";
+}>;
+export declare const useSignOut: (client: AuthClient) => MutationState<unknown, null>;
+export declare const useSignUp: (client: AuthClient) => MutationState<{
+    [extra: string]: unknown;
+    email: string;
+    password: string;
+}, {
+    status: "authenticated";
+} | {
+    status: "verification_required";
+}>;
+export declare const useUpgradeToPasskey: (client: AuthClient) => {
+    error: Ref<AuthClientError | null, AuthClientError | null>;
+    isPending: Ref<boolean, boolean>;
+    passkeys: Ref<unknown[] | null, unknown[] | null>;
+    refetch: () => Promise<void>;
+    register: () => Promise<{
+        data: null;
+        error: AuthClientError;
+    } | {
+        data: {
+            ok: true;
+        };
+        error: null;
+    }>;
+    shouldPrompt: Ref<boolean, boolean>;
+};
+export {};

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

@@ -0,0 +1,53 @@
+import type { FgaSchema, Warrant, WarrantStore } from './types';
+export type FgaCache = {
+    clear: () => void | Promise<void>;
+    get: (key: string) => boolean | undefined | Promise<boolean | undefined>;
+    set: (key: string, value: boolean) => void | Promise<void>;
+};
+export type FgaConfig = {
+    cache?: FgaCache;
+    maxDepth?: number;
+    schema: FgaSchema;
+    warrantStore: WarrantStore;
+};
+export type CheckQuery = {
+    relation: string;
+    resourceId: string;
+    resourceType: string;
+    subjectId: string;
+    subjectType: string;
+};
+export type Subject = {
+    subjectId: string;
+    subjectType: string;
+};
+export type ObjectQuery = {
+    relation: string;
+    resourceType: string;
+    subjectId: string;
+    subjectType: string;
+};
+export declare const check: (config: FgaConfig, query: CheckQuery) => Promise<boolean>;
+export declare const createInMemoryCheckCache: ({ maxEntries, ttlMs }?: {
+    maxEntries?: number;
+    ttlMs?: number;
+}) => FgaCache;
+export declare const createFgaEngine: (config: FgaConfig) => {
+    check: (query: CheckQuery) => Promise<boolean>;
+    deleteWarrant: (warrant: Warrant) => Promise<void>;
+    listObjects: (query: ObjectQuery) => Promise<string[]>;
+    listSubjects: (query: {
+        relation: string;
+        resourceId: string;
+        resourceType: string;
+    }) => Promise<Subject[]>;
+    writeWarrant: (warrant: Warrant) => Promise<void>;
+};
+export declare const deleteWarrant: (config: FgaConfig, warrant: Warrant) => Promise<void>;
+export declare const listObjects: (config: FgaConfig, query: ObjectQuery) => Promise<string[]>;
+export declare const listSubjects: (config: FgaConfig, query: {
+    relation: string;
+    resourceId: string;
+    resourceType: string;
+}) => Promise<Subject[]>;
+export declare const writeWarrant: (config: FgaConfig, warrant: Warrant) => Promise<void>;

package/dist/fga/inMemoryStores.d.ts

@@ -0,0 +1,3 @@
+import type { Warrant, WarrantStore } from './types';
+export declare const createInMemoryWarrantStore: () => WarrantStore;
+export declare const warrantKey: (warrant: Warrant) => string;

package/dist/fga/postgresStores.d.ts

@@ -0,0 +1,116 @@
+import { type AnyPgDatabase } from '../stores/postgres';
+import type { WarrantStore } from './types';
+export declare const warrantsTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "auth_fga_warrants";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgBuildColumn<"auth_fga_warrants", import("drizzle-orm/pg-core").SetIsPrimaryKey<import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>>, {
+            name: string;
+            tableName: "auth_fga_warrants";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        relation: import("drizzle-orm/pg-core").PgBuildColumn<"auth_fga_warrants", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>>, {
+            name: string;
+            tableName: "auth_fga_warrants";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        resource_id: import("drizzle-orm/pg-core").PgBuildColumn<"auth_fga_warrants", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>>, {
+            name: string;
+            tableName: "auth_fga_warrants";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        resource_type: import("drizzle-orm/pg-core").PgBuildColumn<"auth_fga_warrants", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>>, {
+            name: string;
+            tableName: "auth_fga_warrants";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        subject_id: import("drizzle-orm/pg-core").PgBuildColumn<"auth_fga_warrants", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>>, {
+            name: string;
+            tableName: "auth_fga_warrants";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        subject_relation: import("drizzle-orm/pg-core").PgBuildColumn<"auth_fga_warrants", import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>, {
+            name: string;
+            tableName: "auth_fga_warrants";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        subject_type: import("drizzle-orm/pg-core").PgBuildColumn<"auth_fga_warrants", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>>, {
+            name: string;
+            tableName: "auth_fga_warrants";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+    };
+    dialect: "pg";
+}>;
+export declare const createNeonWarrantStore: (databaseUrl: string) => WarrantStore;
+export declare const createPostgresWarrantStore: <DB extends AnyPgDatabase>(db: DB) => WarrantStore;

package/dist/fga/redisCheckCache.d.ts

@@ -0,0 +1,11 @@
+import type { RedisLike } from '../stores/redis';
+import type { FgaCache } from './config';
+export type RedisFgaCacheClient = RedisLike & {
+    keys?: (pattern: string) => Promise<string[]>;
+};
+type CreateRedisFgaCacheOptions = {
+    keyPrefix?: string;
+    ttlMs?: number;
+};
+export declare const createRedisFgaCache: (redis: RedisFgaCacheClient, { keyPrefix, ttlMs }?: CreateRedisFgaCacheOptions) => FgaCache;
+export {};

package/dist/fga/schema.d.ts

@@ -0,0 +1,2 @@
+import type { FgaSchema } from './types';
+export declare const parseSchema: (dsl: string) => FgaSchema;

package/dist/fga/types.d.ts

@@ -0,0 +1,28 @@
+export type Warrant = {
+    relation: string;
+    resourceId: string;
+    resourceType: string;
+    subjectId: string;
+    subjectRelation?: string;
+    subjectType: string;
+};
+export type WarrantStore = {
+    deleteWarrant: (warrant: Warrant) => Promise<void>;
+    listForResource: (resourceType: string, resourceId: string, relation: string) => Promise<Warrant[]>;
+    listResourceIds: (resourceType: string) => Promise<string[]>;
+    saveWarrant: (warrant: Warrant) => Promise<void>;
+};
+export type RelationRule = {
+    kind: 'computedUserset';
+    relation: string;
+} | {
+    kind: 'self';
+} | {
+    kind: 'tupleToUserset';
+    relation: string;
+    viaRelation: string;
+} | {
+    kind: 'union';
+    rules: RelationRule[];
+};
+export type FgaSchema = Record<string, Record<string, RelationRule>>;

package/dist/fingerprint-client/index.d.ts

@@ -0,0 +1,26 @@
+export type FingerprintSignals = {
+    audio?: number;
+    canvas?: string;
+    deviceMemory?: number;
+    fonts?: string[];
+    hardwareConcurrency?: number;
+    languages?: readonly string[];
+    pixelRatio?: number;
+    platform?: string;
+    screen?: {
+        colorDepth: number;
+        height: number;
+        width: number;
+    };
+    timezone?: string;
+    userAgent?: string;
+    webgl?: {
+        renderer?: string;
+        vendor?: string;
+    };
+};
+export type DeviceFingerprint = {
+    deviceId: string;
+    signals: FingerprintSignals;
+};
+export declare const collectDeviceFingerprint: () => Promise<DeviceFingerprint>;

package/dist/htmx/index.d.ts

@@ -0,0 +1,2 @@
+export { escapeHtml, resolveAuthHtmxRenderers } from './renderers';
+export type { AuthHtmxClient, AuthHtmxConnectorTarget, AuthHtmxProviderData, AuthHtmxProviderInfo, AuthHtmxRenderersConfig, AuthHtmxRenderOverrides, AuthHtmxUser, AuthIdentityMergeRequestSummary, AuthIdentityPayload, AuthIdentitySummary, LinkedProviderBindingSummary, LinkedProviderGrantSummary, LinkedProviderPayload, ResolvedAuthHtmxRenderers } from './types';