@auth0/auth0-spa-js 2.18.0 → 2.18.1

package/dist/typings/mfa/types.d.ts

@@ -1,181 +0,0 @@
-import { MfaGrantTypes } from './constants';
-/**
- * Represents an MFA authenticator enrolled by a user
- */
-export interface Authenticator {
-    /** Unique identifier for the authenticator */
-    id: string;
-    /** Type of authenticator */
-    authenticatorType: AuthenticatorType;
-    /** Whether the authenticator is active */
-    active: boolean;
-    /** Optional friendly name */
-    name?: string;
-    /** ISO 8601 timestamp when created */
-    createdAt?: string;
-    /** ISO 8601 timestamp of last authentication */
-    lastAuth?: string;
-    /** Types of MFA challenges*/
-    type?: string;
-}
-/**
- * Supported authenticator types.
- * Note: Email authenticators use 'oob' type with oobChannel: 'email'
- */
-export type AuthenticatorType = 'otp' | 'oob' | 'recovery-code';
-/**
- * Types of MFA challenges
- */
-export type ChallengeType = 'otp' | 'phone' | 'recovery-code' | 'email' | 'push-notification' | 'totp';
-/**
- * Out-of-band delivery channels.
- * Includes 'email' which is also delivered out-of-band.
- */
-export type OobChannel = 'sms' | 'voice' | 'auth0' | 'email';
-/**
- * Supported MFA factors for enrollment
- */
-export type MfaFactorType = 'otp' | 'sms' | 'email' | 'push' | 'voice';
-/**
- * Base parameters for all enrollment types
- */
-export interface EnrollBaseParams {
-    /** MFA token from mfa_required error */
-    mfaToken: string;
-}
-/**
- * OTP (Time-based One-Time Password) enrollment parameters
- */
-export interface EnrollOtpParams extends EnrollBaseParams {
-    /** The factor type for enrollment */
-    factorType: 'otp';
-}
-/**
- * SMS enrollment parameters
- */
-export interface EnrollSmsParams extends EnrollBaseParams {
-    /** The factor type for enrollment */
-    factorType: 'sms';
-    /** Phone number in E.164 format (required for SMS) */
-    phoneNumber: string;
-}
-/**
- * Voice enrollment parameters
- */
-export interface EnrollVoiceParams extends EnrollBaseParams {
-    /** The factor type for enrollment */
-    factorType: 'voice';
-    /** Phone number in E.164 format (required for voice) */
-    phoneNumber: string;
-}
-/**
- * Email enrollment parameters
- */
-export interface EnrollEmailParams extends EnrollBaseParams {
-    /** The factor type for enrollment */
-    factorType: 'email';
-    /** Email address (optional, uses user's email if not provided) */
-    email?: string;
-}
-/**
- * Push notification enrollment parameters
- */
-export interface EnrollPushParams extends EnrollBaseParams {
-    /** The factor type for enrollment */
-    factorType: 'push';
-}
-/**
- * Union type for all enrollment parameter types
- */
-export type EnrollParams = EnrollOtpParams | EnrollSmsParams | EnrollVoiceParams | EnrollEmailParams | EnrollPushParams;
-/**
- * Response when enrolling an OTP authenticator
- */
-export interface OtpEnrollmentResponse {
-    /** Authenticator type */
-    authenticatorType: 'otp';
-    /** Base32-encoded secret for TOTP generation */
-    secret: string;
-    /** URI for generating QR code (otpauth://...) */
-    barcodeUri: string;
-    /** Recovery codes for account recovery */
-    recoveryCodes?: string[];
-    /** Authenticator ID */
-    id?: string;
-}
-/**
- * Response when enrolling an OOB authenticator
- */
-export interface OobEnrollmentResponse {
-    /** Authenticator type */
-    authenticatorType: 'oob';
-    /** Delivery channel used */
-    oobChannel: OobChannel;
-    /** Out-of-band code for verification */
-    oobCode?: string;
-    /** Binding method (e.g., 'prompt' for user code entry) */
-    bindingMethod?: string;
-    /** Recovery codes (generated when enrolling first MFA factor) */
-    recoveryCodes?: string[];
-    /** Authenticator ID */
-    id?: string;
-    /** URI for QR code (for Push/Guardian enrollment) */
-    barcodeUri?: string;
-}
-/**
- * Union type for all enrollment response types
- */
-export type EnrollmentResponse = OtpEnrollmentResponse | OobEnrollmentResponse;
-/**
- * Parameters for initiating an MFA challenge
- */
-export interface ChallengeAuthenticatorParams {
-    /** MFA token from mfa_required error or MFA-scoped access token */
-    mfaToken: string;
-    /** Type of challenge to initiate */
-    challengeType: 'otp' | 'oob';
-    /** Specific authenticator to challenge (optional) */
-    authenticatorId?: string;
-}
-/**
- * Response from initiating an MFA challenge
- */
-export interface ChallengeResponse {
-    /** Type of challenge created */
-    challengeType: 'otp' | 'oob';
-    /** Out-of-band code (for OOB challenges) */
-    oobCode?: string;
-    /** Binding method for OOB (e.g., 'prompt') */
-    bindingMethod?: string;
-}
-/**
- * Grant types for MFA verification (derived from MfaGrantTypes constants)
- */
-export type MfaGrantType = (typeof MfaGrantTypes)[keyof typeof MfaGrantTypes];
-/**
- * Parameters for verifying an MFA challenge.
- *
- * The grant_type is automatically inferred from which verification field is provided:
- * - `otp` field → MFA-OTP grant type
- * - `oobCode` field → MFA-OOB grant type
- * - `recoveryCode` field → MFA-RECOVERY-CODE grant type
- */
-export interface VerifyParams {
-    /** MFA token from challenge flow */
-    mfaToken: string;
-    /** One-time password (for OTP challenges) */
-    otp?: string;
-    /** Out-of-band code (for OOB challenges) */
-    oobCode?: string;
-    /** Binding code (for OOB challenges with binding) */
-    bindingCode?: string;
-    /** Recovery code (for recovery code verification) */
-    recoveryCode?: string;
-}
-/**
- * Enrollment factor returned by getEnrollmentFactors
- */
-export interface EnrollmentFactor {
-    /** Type of enrollment factor available */
-    type: string;
-}

package/dist/typings/mfa/utils.d.ts

@@ -1,23 +0,0 @@
-import type { EnrollParams, VerifyParams, MfaGrantType } from './types';
-/**
- * Converts factor-based enrollment params to auth-js format
- *
- * @param params - The enrollment parameters with factorType
- * @returns Parameters in auth-js format with authenticatorTypes/oobChannels
- */
-export declare function getAuthJsEnrollParams(params: EnrollParams): {
-    email?: string | undefined;
-    phoneNumber?: string | undefined;
-    oobChannels?: import("./types").OobChannel[] | undefined;
-    mfaToken: string;
-    authenticatorTypes: ["otp"] | ["oob"];
-};
-/**
- * Gets the grant type from verification parameters based on which field is provided.
- *
- * Priority order: otp > oobCode > recoveryCode
- *
- * @param params - The verification parameters
- * @returns The grant type or undefined if no verification field is present
- */
-export declare function getGrantType(params: VerifyParams): MfaGrantType | undefined;

package/dist/typings/promise-utils.d.ts

@@ -1,2 +0,0 @@
-export declare const singlePromise: <T>(cb: () => Promise<T>, key: string) => Promise<T>;
-export declare const retryPromise: (cb: () => Promise<boolean>, maxNumberOfRetries?: number) => Promise<boolean>;

package/dist/typings/scope.d.ts

@@ -1,35 +0,0 @@
-/**
- * @ignore
- */
-/**
- * Returns a string of unique scopes by removing duplicates and unnecessary whitespace.
- *
- * @param {...(string | undefined)[]} scopes - A list of scope strings or undefined values.
- * @returns {string} A string containing unique scopes separated by a single space.
- */
-export declare const getUniqueScopes: (...scopes: (string | undefined)[]) => string;
-/**
- * @ignore
- */
-/**
- * We will check if the developer has created the client with a string or object of audience:scopes. We will inject
- * the base scopes to each audience, and store the base ones inside default key. As well, if the developer created the Auth0Client
- * with a string of scopes, we will store the requested ones with the base scopes inside the default key as well.
- * @param authScopes The scopes requested by the user when creating the Auth0Client
- * @param openIdScope openId scope
- * @param extraScopes Other scopes to accumulate such as offline_access
- * @returns {Record<string, string>} An object with all scopes that are going to be accumulated.
- */
-export declare const injectDefaultScopes: (authScopes: string | Record<string, string> | undefined, openIdScope: string, ...extraScopes: string[]) => Record<string, string>;
-/**
- * @ignore
- */
-/**
- * Will return a string of scopes. If a specific audience was requested and it exist inside the scopes object, we will return those
- * related to that audience that we want to accumulate. If not, we will return the ones stored inside the default key.
- * @param authScopes Object of audience:scopes that are going to be accumulated
- * @param methodScopes The scopes requested for the developer in a specific request
- * @param audience The audience the developer requested for an specific request or the one they configured in the Auth0Client
- * @returns {string} A combination of Auth0Client scopes and the ones requested by the developer for a specific request
- */
-export declare const scopesToRequest: (authScopes: Record<string, string>, methodScopes: string | undefined, audience: string | undefined) => string;

package/dist/typings/storage.d.ts

@@ -1,26 +0,0 @@
-interface ClientStorageOptions {
-    daysUntilExpire?: number;
-    cookieDomain?: string;
-}
-/**
- * Defines a type that handles storage to/from a storage location
- */
-export type ClientStorage = {
-    get<T extends Object>(key: string): T | undefined;
-    save(key: string, value: any, options?: ClientStorageOptions): void;
-    remove(key: string, options?: ClientStorageOptions): void;
-};
-/**
- * A storage protocol for marshalling data to/from cookies
- */
-export declare const CookieStorage: ClientStorage;
-/**
- * Cookie storage that creates a cookie for modern and legacy browsers.
- * See: https://web.dev/samesite-cookie-recipes/#handling-incompatible-clients
- */
-export declare const CookieStorageWithLegacySameSite: ClientStorage;
-/**
- * A storage protocol for marshalling data to/from session storage
- */
-export declare const SessionStorage: ClientStorage;
-export {};

package/dist/typings/transaction-manager.d.ts

@@ -1,33 +0,0 @@
-import { ClientStorage } from './storage';
-export interface LoginTransaction {
-    nonce: string;
-    scope: string;
-    audience: string;
-    appState?: any;
-    code_verifier: string;
-    redirect_uri?: string;
-    organization?: string;
-    state?: string;
-    response_type: 'code';
-}
-export interface ConnectAccountTransaction {
-    appState?: any;
-    audience?: string;
-    auth_session: string;
-    code_verifier: string;
-    redirect_uri: string;
-    scope?: string;
-    state: string;
-    connection: string;
-    response_type: 'connect_code';
-}
-export declare class TransactionManager {
-    private storage;
-    private clientId;
-    private cookieDomain?;
-    private storageKey;
-    constructor(storage: ClientStorage, clientId: string, cookieDomain?: string | undefined);
-    create<T extends Object = LoginTransaction>(transaction: T): void;
-    get<T extends Object = LoginTransaction>(): T | undefined;
-    remove(): void;
-}

package/dist/typings/utils.d.ts

@@ -1,36 +0,0 @@
-import { AuthenticationResult, PopupConfigOptions } from './global';
-export declare const parseAuthenticationResult: (queryString: string) => AuthenticationResult;
-export declare const runIframe: (authorizeUrl: string, eventOrigin: string, timeoutInSeconds?: number) => Promise<AuthenticationResult>;
-export declare const openPopup: (url: string) => Window | null;
-export declare const runPopup: (config: PopupConfigOptions) => Promise<AuthenticationResult>;
-export declare const getCrypto: () => Crypto;
-export declare const createRandomString: () => string;
-export declare const encode: (value: string) => string;
-export declare const decode: (value: string) => string;
-/**
- * Strips any property that is not present in ALLOWED_AUTH0CLIENT_PROPERTIES
- * @param auth0Client - The full auth0Client object
- * @param excludeEnv - If true, excludes the 'env' property from the result
- * @returns The stripped auth0Client object
- */
-export declare const stripAuth0Client: (auth0Client: any, excludeEnv?: boolean) => any;
-export declare const createQueryParams: ({ clientId: client_id, ...params }: any) => string;
-export declare const sha256: (s: string) => Promise<any>;
-export declare const urlDecodeB64: (input: string) => string;
-export declare const bufferToBase64UrlEncoded: (input: number[] | Uint8Array) => string;
-export declare const validateCrypto: () => void;
-/**
- * @ignore
- */
-export declare const getDomain: (domainUrl: string) => string;
-/**
- * @ignore
- */
-export declare const getTokenIssuer: (issuer: string | undefined, domainUrl: string) => string;
-export declare const parseNumber: (value: any) => number | undefined;
-/**
- * Ponyfill for `Object.fromEntries()`, which is not available until ES2020.
- *
- * When the target of this project reaches ES2020, this can be removed.
- */
-export declare const fromEntries: <T = any>(iterable: Iterable<[PropertyKey, T]>) => Record<PropertyKey, T>;

package/dist/typings/version.d.ts

@@ -1,2 +0,0 @@
-declare const _default: "2.18.0";
-export default _default;

package/dist/typings/worker/token.worker.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/typings/worker/worker.types.d.ts

@@ -1,15 +0,0 @@
-import { FetchOptions } from '../global';
-/**
- * @ts-ignore
- */
-export type WorkerRefreshTokenMessage = {
-    timeout: number;
-    fetchUrl: string;
-    fetchOptions: FetchOptions;
-    useFormData?: boolean;
-    useMrrt?: boolean;
-    auth: {
-        audience: string;
-        scope: string;
-    };
-};

package/dist/typings/worker/worker.utils.d.ts

@@ -1,7 +0,0 @@
-import { WorkerRefreshTokenMessage } from './worker.types';
-/**
- * Sends the specified message to the web worker
- * @param message The message to send
- * @param to The worker to send the message to
- */
-export declare const sendMessage: (message: WorkerRefreshTokenMessage, to: Worker) => Promise<unknown>;