@absolutejs/auth 0.25.0 → 0.26.0-beta.0

package/dist/{oauthLinkedProviderResolver.d.ts → linkedProviders/oauthResolver.d.ts}

@@ -1,5 +1,5 @@
 import type { LinkedProviderBindingStore, LinkedProviderGrantStore } from '@absolutejs/linked-providers';
-import type { OAuth2ConfigurationOptions } from './types';
+import type { OAuth2ConfigurationOptions } from '../types';
 export type CreateOAuthLinkedProviderCredentialResolverOptions = {
     grantStore: LinkedProviderGrantStore;
     bindingStore: LinkedProviderBindingStore;

package/dist/lockout/config.d.ts

@@ -0,0 +1,17 @@
+import type { LockoutStore } from './types';
+export type LockoutConfig = {
+    lockoutStore: LockoutStore;
+    lockoutMs?: number;
+    maxAttempts?: number;
+    windowMs?: number;
+};
+export type LockoutState = {
+    locked: boolean;
+    retryAfterMs?: number;
+};
+export type LockoutGuard = {
+    check: (key: string) => Promise<LockoutState>;
+    recordFailure: (key: string) => Promise<void>;
+    recordSuccess: (key: string) => Promise<void>;
+};
+export declare const createLockoutGuard: ({ lockoutMs, lockoutStore, maxAttempts, windowMs }: LockoutConfig) => LockoutGuard;

package/dist/lockout/inMemoryLockoutStore.d.ts

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

package/dist/lockout/postgresLockoutStore.d.ts

@@ -0,0 +1,81 @@
+import { type AnyPgDatabase } from '../stores/postgres';
+import type { LockoutStore } from './types';
+export declare const lockoutsTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "auth_lockouts";
+    schema: undefined;
+    columns: {
+        failed_attempts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "failed_attempts";
+            tableName: "auth_lockouts";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        key: import("drizzle-orm/pg-core").PgColumn<{
+            name: "key";
+            tableName: "auth_lockouts";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 320;
+        }>;
+        locked_until_ms: import("drizzle-orm/pg-core").PgColumn<{
+            name: "locked_until_ms";
+            tableName: "auth_lockouts";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        window_started_at_ms: import("drizzle-orm/pg-core").PgColumn<{
+            name: "window_started_at_ms";
+            tableName: "auth_lockouts";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const createNeonLockoutStore: (databaseUrl: string) => LockoutStore;
+export declare const createPostgresLockoutStore: (db: AnyPgDatabase) => LockoutStore;

package/dist/lockout/types.d.ts

@@ -0,0 +1,12 @@
+export type LockoutRecord = {
+    failedAttempts: number;
+    key: string;
+    lockedUntil?: number;
+    windowStartedAt: number;
+};
+export type LockoutStore = {
+    get: (key: string) => Promise<LockoutRecord | undefined>;
+    increment: (key: string, windowMs: number) => Promise<LockoutRecord>;
+    lock: (key: string, lockedUntil: number) => Promise<void>;
+    reset: (key: string) => Promise<void>;
+};

package/dist/mfa/backupCodes.d.ts

@@ -0,0 +1,5 @@
+export declare const consumeBackupCode: (code: string, hashes: string[]) => Promise<string[] | undefined>;
+export declare const generateBackupCodes: (count: number) => Promise<{
+    codes: string[];
+    hashes: string[];
+}>;

package/dist/mfa/challenge.d.ts

@@ -0,0 +1,65 @@
+import { Elysia } from 'elysia';
+import { type MfaRouteProps } from './config';
+export declare const mfaChallenge: <UserType>({ authSessionStore, challengeRoute, encryptionKey, getChallengeUser, getUserId, mfaStore, onMfaChallengeError, onMfaChallengeSuccess, sessionDurationMs }: MfaRouteProps<UserType>) => Elysia<"", {
+    decorator: {};
+    store: {
+        session: import("..").SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
+    };
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        post: {
+            body: {
+                code: string;
+            };
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: {
+                    readonly status: "authenticated";
+                };
+                401: "No MFA challenge in progress" | "Invalid MFA code";
+                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/mfa/config.d.ts

@@ -0,0 +1,32 @@
+import type { AuthSessionStore } from '../session/types';
+import type { RouteString, UserSessionId } from '../types';
+import type { MFAStore } from './types';
+export declare const DEFAULT_BACKUP_CODE_COUNT = 10;
+export declare const DEFAULT_MFA_ISSUER = "AbsoluteAuth";
+export declare const DEFAULT_MFA_SESSION_TTL_MS: number;
+export type MfaConfig<UserType> = {
+    mfaStore: MFAStore;
+    getUserId: (user: UserType) => string;
+    getChallengeUser: (userIdentity: Record<string, unknown>) => Promise<UserType | null | undefined> | UserType | null | undefined;
+    backupCodeCount?: number;
+    challengeRoute?: RouteString;
+    encryptionKey?: string;
+    issuer?: string;
+    onMfaChallengeError?: (context: {
+        error: unknown;
+        userId?: string;
+    }) => void | Promise<void>;
+    onMfaChallengeSuccess?: (context: {
+        user: UserType;
+        userSessionId: UserSessionId;
+    }) => void | Promise<void>;
+    onMfaEnrolled?: (context: {
+        userId: string;
+    }) => void | Promise<void>;
+    sessionDurationMs?: number;
+    totpSetupRoute?: RouteString;
+    totpVerifyRoute?: RouteString;
+};
+export type MfaRouteProps<UserType> = MfaConfig<UserType> & {
+    authSessionStore?: AuthSessionStore<UserType>;
+};

package/dist/mfa/gate.d.ts

@@ -0,0 +1,2 @@
+import type { MfaConfig } from './config';
+export declare const createMfaGate: <UserType>({ getUserId, mfaStore }: MfaConfig<UserType>) => (user: UserType) => Promise<boolean>;

package/dist/mfa/inMemoryMfaStore.d.ts

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

package/dist/mfa/postgresMfaStore.d.ts

@@ -0,0 +1,134 @@
+import { type AnyPgDatabase } from '../stores/postgres';
+import type { MFAStore } from './types';
+export declare const mfaEnrollmentsTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "auth_mfa_enrollments";
+    schema: undefined;
+    columns: {
+        backup_code_hashes: import("drizzle-orm/pg-core").PgColumn<{
+            name: "backup_code_hashes";
+            tableName: "auth_mfa_enrollments";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: string[];
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[];
+        }>;
+        created_at_ms: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at_ms";
+            tableName: "auth_mfa_enrollments";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        last_used_at_ms: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_used_at_ms";
+            tableName: "auth_mfa_enrollments";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        totp_secret_ciphertext: import("drizzle-orm/pg-core").PgColumn<{
+            name: "totp_secret_ciphertext";
+            tableName: "auth_mfa_enrollments";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        totp_verified: import("drizzle-orm/pg-core").PgColumn<{
+            name: "totp_verified";
+            tableName: "auth_mfa_enrollments";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updated_at_ms: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at_ms";
+            tableName: "auth_mfa_enrollments";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        user_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "user_id";
+            tableName: "auth_mfa_enrollments";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+    };
+    dialect: "pg";
+}>;
+export declare const createNeonMfaStore: (databaseUrl: string) => MFAStore;
+export declare const createPostgresMfaStore: (db: AnyPgDatabase) => MFAStore;

package/dist/mfa/routes.d.ts

@@ -0,0 +1,117 @@
+import { Elysia } from 'elysia';
+import type { MfaRouteProps } from './config';
+export declare const mfaRoutes: <UserType>(config: MfaRouteProps<UserType>) => Elysia<"", {
+    decorator: {};
+    store: {
+        session: import("..").SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
+    };
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: {
+                    readonly secret: string;
+                    readonly uri: string;
+                };
+                401: "Authentication required";
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        post: {
+            body: {
+                code: string;
+            };
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: {
+                    readonly backupCodes: string[];
+                };
+                400: "No TOTP enrollment in progress" | "Invalid TOTP code";
+                401: "Authentication required";
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        post: {
+            body: {
+                code: string;
+            };
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: {
+                    readonly status: "authenticated";
+                };
+                401: "No MFA challenge in progress" | "Invalid MFA code";
+                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/mfa/secret.d.ts

@@ -0,0 +1,2 @@
+export declare const decryptTotpSecret: (ciphertext: string, encryptionKey?: string) => Promise<string>;
+export declare const encryptTotpSecret: (secret: string, encryptionKey?: string) => Promise<string>;

package/dist/mfa/totp.d.ts

@@ -0,0 +1,91 @@
+import { Elysia } from 'elysia';
+import { type MfaRouteProps } from './config';
+export declare const mfaTotpRoutes: <UserType>({ authSessionStore, backupCodeCount, encryptionKey, getUserId, issuer, mfaStore, onMfaEnrolled, totpSetupRoute, totpVerifyRoute }: MfaRouteProps<UserType>) => Elysia<"", {
+    decorator: {};
+    store: {
+        session: import("..").SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
+    };
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: {
+                    readonly secret: string;
+                    readonly uri: string;
+                };
+                401: "Authentication required";
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        post: {
+            body: {
+                code: string;
+            };
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: {
+                    readonly backupCodes: string[];
+                };
+                400: "No TOTP enrollment in progress" | "Invalid TOTP code";
+                401: "Authentication required";
+                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/mfa/types.d.ts

@@ -0,0 +1,16 @@
+export type MfaFactorType = 'backup_codes' | 'totp';
+export type MfaEnrollment = {
+    backupCodeHashes: string[];
+    createdAt: number;
+    lastUsedAt?: number;
+    totpSecretCiphertext?: string;
+    totpVerified: boolean;
+    updatedAt: number;
+    userId: string;
+};
+export type MFAStore = {
+    getEnrollment: (userId: string) => Promise<MfaEnrollment | undefined>;
+    removeEnrollment: (userId: string) => Promise<void>;
+    saveEnrollment: (enrollment: MfaEnrollment) => Promise<void>;
+};
+export declare const isMfaEnrolled: (enrollment: MfaEnrollment | undefined) => boolean;

package/dist/{providerClients.d.ts → providers/clients.d.ts}

@@ -1,24 +1,23 @@
 import { CredentialsFor, OAuth2Client, ProviderOption } from 'citra';
-import { OAuth2ConfigurationOptions, OAuth2ProviderClientConfiguration, ClientProviderEntry, ClientProviderGroup } from './types';
-export declare const normalizeProvidersConfiguration: (providersConfiguration: OAuth2ConfigurationOptions) => Record<ProviderOption, Record<string, OAuth2ProviderClientConfiguration<ProviderOption>>>;
-export declare const resolveProviderClientConfiguration: ({ clientName, providerName, providersConfiguration }: {
-    providerName: ProviderOption;
-    clientName?: string;
-    providersConfiguration: OAuth2ConfigurationOptions;
-}) => {
-    error: "Client provider not found";
-    config?: undefined;
-} | {
-    config: OAuth2ProviderClientConfiguration<"42" | "amazoncognito" | "anilist" | "apple" | "atlassian" | "auth0" | "authentik" | "autodesk" | "battlenet" | "bitbucket" | "box" | "bungie" | "coinbase" | "discord" | "donationalerts" | "dribbble" | "dropbox" | "epicgames" | "etsy" | "facebook" | "figma" | "gitea" | "github" | "gitlab" | "google" | "intuit" | "kakao" | "keycloak" | "kick" | "lichess" | "line" | "linear" | "linkedin" | "mastodon" | "mercadolibre" | "mercadopago" | "microsoftentraid" | "myanimelist" | "naver" | "notion" | "okta" | "osu" | "patreon" | "polar" | "polaraccesslink" | "polarteampro" | "reddit" | "roblox" | "salesforce" | "shikimori" | "slack" | "spotify" | "startgg" | "strava" | "synology" | "tiktok" | "tiltify" | "tumblr" | "twitch" | "twitter" | "vk" | "withings" | "workos" | "yahoo" | "yandex" | "zoom"> | undefined;
-    error?: undefined;
-} | {
-    error: "Client variant is required";
-    config?: undefined;
-} | {
-    error: "Client variant not found";
-    config?: undefined;
+import { OAuth2ConfigurationOptions, OAuth2ProviderClientConfiguration, ClientProviderEntry, ClientProviderGroup } from '../types';
+export declare const buildClientProviders: (providersConfiguration: OAuth2ConfigurationOptions, createOAuth2ClientFn: <P extends ProviderOption>(providerName: P, config: CredentialsFor<P>) => Promise<OAuth2Client<P>>) => Promise<{
+    [k: string]: {
+        entries: {
+            [k: string]: {
+                clientName: string | undefined;
+                providerInstance: import("citra").BaseOAuth2Client<"42" | "amazoncognito" | "anilist" | "apple" | "atlassian" | "auth0" | "authentik" | "autodesk" | "battlenet" | "bitbucket" | "box" | "bungie" | "coinbase" | "discord" | "donationalerts" | "dribbble" | "dropbox" | "epicgames" | "etsy" | "facebook" | "figma" | "gitea" | "github" | "gitlab" | "google" | "intuit" | "kakao" | "keycloak" | "kick" | "lichess" | "line" | "linear" | "linkedin" | "mastodon" | "mercadolibre" | "mercadopago" | "microsoftentraid" | "myanimelist" | "naver" | "notion" | "okta" | "osu" | "patreon" | "polar" | "polaraccesslink" | "polarteampro" | "reddit" | "roblox" | "salesforce" | "shikimori" | "slack" | "spotify" | "startgg" | "strava" | "synology" | "tiktok" | "tiltify" | "tumblr" | "twitch" | "twitter" | "vk" | "withings" | "workos" | "yahoo" | "yandex" | "zoom">;
+                scope: string[] | undefined;
+                searchParams: [string, string][] | undefined;
+            };
+        };
+        isSingleClient: boolean;
+    };
+}>;
+export declare const normalizeProvidersConfiguration: (providersConfiguration: OAuth2ConfigurationOptions) => {
+    [k: string]: {
+        [k: string]: OAuth2ProviderClientConfiguration<"42" | "amazoncognito" | "anilist" | "apple" | "atlassian" | "auth0" | "authentik" | "autodesk" | "battlenet" | "bitbucket" | "box" | "bungie" | "coinbase" | "discord" | "donationalerts" | "dribbble" | "dropbox" | "epicgames" | "etsy" | "facebook" | "figma" | "gitea" | "github" | "gitlab" | "google" | "intuit" | "kakao" | "keycloak" | "kick" | "lichess" | "line" | "linear" | "linkedin" | "mastodon" | "mercadolibre" | "mercadopago" | "microsoftentraid" | "myanimelist" | "naver" | "notion" | "okta" | "osu" | "patreon" | "polar" | "polaraccesslink" | "polarteampro" | "reddit" | "roblox" | "salesforce" | "shikimori" | "slack" | "spotify" | "startgg" | "strava" | "synology" | "tiktok" | "tiltify" | "tumblr" | "twitch" | "twitter" | "vk" | "withings" | "workos" | "yahoo" | "yandex" | "zoom">;
+    };
 };
-export declare const buildClientProviders: (providersConfiguration: OAuth2ConfigurationOptions, createOAuth2ClientFn: <P extends ProviderOption>(providerName: P, config: CredentialsFor<P>) => Promise<OAuth2Client<P>>) => Promise<Record<string, ClientProviderGroup>>;
 export declare const resolveClientProviderEntry: ({ clientName, clientProviders, providerName }: {
     providerName: string | undefined;
     clientName?: string;
@@ -39,3 +38,20 @@ export declare const resolveClientProviderEntry: ({ clientName, clientProviders,
     error: "Client variant not found";
     entry?: undefined;
 };
+export declare const resolveProviderClientConfiguration: ({ clientName, providerName, providersConfiguration }: {
+    providerName: ProviderOption;
+    clientName?: string;
+    providersConfiguration: OAuth2ConfigurationOptions;
+}) => {
+    error: "Client provider not found";
+    config?: undefined;
+} | {
+    config: OAuth2ProviderClientConfiguration<"42" | "amazoncognito" | "anilist" | "apple" | "atlassian" | "auth0" | "authentik" | "autodesk" | "battlenet" | "bitbucket" | "box" | "bungie" | "coinbase" | "discord" | "donationalerts" | "dribbble" | "dropbox" | "epicgames" | "etsy" | "facebook" | "figma" | "gitea" | "github" | "gitlab" | "google" | "intuit" | "kakao" | "keycloak" | "kick" | "lichess" | "line" | "linear" | "linkedin" | "mastodon" | "mercadolibre" | "mercadopago" | "microsoftentraid" | "myanimelist" | "naver" | "notion" | "okta" | "osu" | "patreon" | "polar" | "polaraccesslink" | "polarteampro" | "reddit" | "roblox" | "salesforce" | "shikimori" | "slack" | "spotify" | "startgg" | "strava" | "synology" | "tiktok" | "tiltify" | "tumblr" | "twitch" | "twitter" | "vk" | "withings" | "workos" | "yahoo" | "yandex" | "zoom"> | undefined;
+    error?: undefined;
+} | {
+    error: "Client variant is required";
+    config?: undefined;
+} | {
+    error: "Client variant not found";
+    config?: undefined;
+};