/**
 * An object carrying the SlashID SDK version information
 */
export const version: {
    major: string;
    minor: string;
    patch: string;
    raw: string;
};
interface ConfigurationParameters {
    basePath?: string;
    fetchApi?: FetchAPI;
    middleware?: Middleware[];
    queryParamsStringify?: (params: HTTPQuery) => string;
    username?: string;
    password?: string;
    apiKey?: string | ((name: string) => string);
    accessToken?: string | Promise<string> | ((name?: string, scopes?: string[]) => string | Promise<string>);
    headers?: HTTPHeaders;
    credentials?: RequestCredentials;
}
declare class Configuration {
    constructor(configuration?: ConfigurationParameters);
    set config(configuration: Configuration);
    get basePath(): string;
    get fetchApi(): FetchAPI | undefined;
    get middleware(): Middleware[];
    get queryParamsStringify(): (params: HTTPQuery) => string;
    get username(): string | undefined;
    get password(): string | undefined;
    get apiKey(): ((name: string) => string) | undefined;
    get accessToken(): ((name?: string, scopes?: string[]) => string | Promise<string>) | undefined;
    get headers(): HTTPHeaders | undefined;
    get credentials(): RequestCredentials | undefined;
}
type FetchAPI = WindowOrWorkerGlobalScope['fetch'];
type Json = any;
type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD';
type HTTPHeaders = {
    [key: string]: string;
};
type HTTPQuery = {
    [key: string]: string | number | null | boolean | Array<string | number | null | boolean> | Set<string | number | null | boolean> | HTTPQuery;
};
type HTTPBody = Json | FormData | URLSearchParams;
type HTTPRequestInit = {
    headers?: HTTPHeaders;
    method: HTTPMethod;
    credentials?: RequestCredentials;
    body?: HTTPBody;
};
type InitOverrideFunction = (requestContext: {
    init: HTTPRequestInit;
    context: RequestOpts;
}) => Promise<RequestInit>;
interface FetchParams {
    url: string;
    init: RequestInit;
}
interface RequestOpts {
    path: string;
    method: HTTPMethod;
    headers: HTTPHeaders;
    query?: HTTPQuery;
    body?: HTTPBody;
}
interface RequestContext {
    fetch: FetchAPI;
    url: string;
    init: RequestInit;
}
interface ResponseContext {
    fetch: FetchAPI;
    url: string;
    init: RequestInit;
    response: Response;
}
interface ErrorContext {
    fetch: FetchAPI;
    url: string;
    init: RequestInit;
    error: unknown;
    response?: Response;
}
interface Middleware {
    pre?(context: RequestContext): Promise<FetchParams | void>;
    post?(context: ResponseContext): Promise<Response | void>;
    onError?(context: ErrorContext): Promise<Response | void>;
}
interface ApiResponse<T> {
    raw: Response;
    value(): Promise<T>;
}
/**
 *
 * @export
 * @interface APIPagination
 */
interface APIPagination {
    /**
     *
     * @type {number}
     * @memberof APIPagination
     */
    limit: number;
    /**
     *
     * @type {number}
     * @memberof APIPagination
     */
    offset: number;
    /**
     *
     * @type {number}
     * @memberof APIPagination
     */
    total_count: number;
}
/**
 *
 * @export
 * @interface APIMeta
 */
interface APIMeta {
    /**
     *
     * @type {APIPagination}
     * @memberof APIMeta
     */
    pagination?: APIPagination;
}
/**
 *
 * @export
 * @interface APIResponseError
 */
interface _APIResponseError1 {
    /**
     *
     * @type {number}
     * @memberof APIResponseError
     */
    httpcode?: number;
    /**
     *
     * @type {string}
     * @memberof APIResponseError
     */
    message?: string;
}
/**
 *
 * @export
 * @interface APIResponseBase
 */
interface APIResponseBase {
    /**
     *
     * @type {APIMeta}
     * @memberof APIResponseBase
     */
    meta?: APIMeta;
    /**
     *
     * @type {Array<APIResponseError>}
     * @memberof APIResponseBase
     */
    errors?: Array<_APIResponseError1>;
}
/**
 * SlashID API v1.1
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * Do not edit the class manually.
 */
/**
 *
 * @export
 */
declare const Region: {
    readonly UsIowa: "us-iowa";
    readonly EuropeBelgium: "europe-belgium";
    readonly AsiaJapan: "asia-japan";
    readonly EuropeEngland: "europe-england";
    readonly AustraliaSydney: "australia-sydney";
};
type Region = (typeof Region)[keyof typeof Region];
/**
 * Structure to create an anonymous person
 * @export
 * @interface AnonymousPersonCreateReq
 */
interface AnonymousPersonCreateReq {
    /**
     *
     * @type {Region}
     * @memberof AnonymousPersonCreateReq
     */
    region?: Region;
}
/**
 * SlashID API v1.1
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * Do not edit the class manually.
 */
/**
 *
 * @export
 */
declare const ChallengeType: {
    readonly UiCustomization: "ui_customization";
    readonly AuthnContextUpdate: "authn_context_update";
    readonly Proxy: "proxy";
    readonly WebauthnCreate: "webauthn_create";
    readonly WebauthnGet: "webauthn_get";
    readonly Nonce: "nonce";
    readonly Otp: "otp";
    readonly Oidc: "oidc";
    readonly Saml: "saml";
    readonly PasswordSet: "password_set";
    readonly PasswordVerify: "password_verify";
    readonly PasswordReset: "password_reset";
    readonly TotpRegister: "totp_register";
    readonly TotpVerify: "totp_verify";
};
type ChallengeType = (typeof ChallengeType)[keyof typeof ChallengeType];
/**
 *
 * @export
 * @interface NonceAttestationData
 */
interface NonceAttestationData {
    /**
     *
     * @type {string}
     * @memberof NonceAttestationData
     */
    challenge?: string;
}
/**
 *
 * @export
 * @interface NonceAttestation
 */
interface NonceAttestation {
    /**
     *
     * @type {string}
     * @memberof NonceAttestation
     */
    challenge_id: string;
    /**
     *
     * @type {ChallengeType}
     * @memberof NonceAttestation
     */
    challenge_type: ChallengeType;
    /**
     *
     * @type {NonceAttestationData}
     * @memberof NonceAttestation
     */
    data?: NonceAttestationData;
}
/**
 *
 * @export
 * @interface OTPAttestationData
 */
interface OTPAttestationData {
    /**
     *
     * @type {string}
     * @memberof OTPAttestationData
     */
    otp?: string;
}
/**
 *
 * @export
 * @interface OTPAttestation
 */
interface OTPAttestation {
    /**
     *
     * @type {string}
     * @memberof OTPAttestation
     */
    challenge_id: string;
    /**
     *
     * @type {ChallengeType}
     * @memberof OTPAttestation
     */
    challenge_type: ChallengeType;
    /**
     *
     * @type {OTPAttestationData}
     * @memberof OTPAttestation
     */
    data?: OTPAttestationData;
}
/**
 *
 * @export
 * @interface PasswordResetAttestationData
 */
interface PasswordResetAttestationData {
    /**
     *
     * @type {string}
     * @memberof PasswordResetAttestationData
     */
    password: string;
}
/**
 *
 * @export
 * @interface PasswordResetAttestation
 */
interface PasswordResetAttestation {
    /**
     *
     * @type {string}
     * @memberof PasswordResetAttestation
     */
    challenge_id: string;
    /**
     *
     * @type {ChallengeType}
     * @memberof PasswordResetAttestation
     */
    challenge_type: ChallengeType;
    /**
     *
     * @type {PasswordResetAttestationData}
     * @memberof PasswordResetAttestation
     */
    data?: PasswordResetAttestationData;
}
/**
 *
 * @export
 * @interface PasswordSetAttestationData
 */
interface PasswordSetAttestationData {
    /**
     *
     * @type {string}
     * @memberof PasswordSetAttestationData
     */
    password: string;
}
/**
 *
 * @export
 * @interface PasswordSetAttestation
 */
interface PasswordSetAttestation {
    /**
     *
     * @type {string}
     * @memberof PasswordSetAttestation
     */
    challenge_id: string;
    /**
     *
     * @type {ChallengeType}
     * @memberof PasswordSetAttestation
     */
    challenge_type: ChallengeType;
    /**
     *
     * @type {PasswordSetAttestationData}
     * @memberof PasswordSetAttestation
     */
    data?: PasswordSetAttestationData;
}
/**
 *
 * @export
 * @interface PasswordVerifyAttestationData
 */
interface PasswordVerifyAttestationData {
    /**
     *
     * @type {string}
     * @memberof PasswordVerifyAttestationData
     */
    password: string;
}
/**
 *
 * @export
 * @interface PasswordVerifyAttestation
 */
interface PasswordVerifyAttestation {
    /**
     *
     * @type {string}
     * @memberof PasswordVerifyAttestation
     */
    challenge_id: string;
    /**
     *
     * @type {ChallengeType}
     * @memberof PasswordVerifyAttestation
     */
    challenge_type: ChallengeType;
    /**
     *
     * @type {PasswordVerifyAttestationData}
     * @memberof PasswordVerifyAttestation
     */
    data?: PasswordVerifyAttestationData;
}
/**
 *
 * @export
 * @interface TOTPRegisterAttestationData
 */
interface TOTPRegisterAttestationData {
    /**
     *
     * @type {string}
     * @memberof TOTPRegisterAttestationData
     */
    otp?: string;
}
/**
 *
 * @export
 * @interface TOTPRegisterAttestation
 */
interface TOTPRegisterAttestation {
    /**
     *
     * @type {string}
     * @memberof TOTPRegisterAttestation
     */
    challenge_id: string;
    /**
     *
     * @type {ChallengeType}
     * @memberof TOTPRegisterAttestation
     */
    challenge_type: ChallengeType;
    /**
     *
     * @type {TOTPRegisterAttestationData}
     * @memberof TOTPRegisterAttestation
     */
    data?: TOTPRegisterAttestationData;
}
/**
 *
 * @export
 * @interface TOTPVerifyAttestationData
 */
interface TOTPVerifyAttestationData {
    /**
     *
     * @type {string}
     * @memberof TOTPVerifyAttestationData
     */
    otp?: string;
}
/**
 *
 * @export
 * @interface TOTPVerifyAttestation
 */
interface TOTPVerifyAttestation {
    /**
     *
     * @type {string}
     * @memberof TOTPVerifyAttestation
     */
    challenge_id: string;
    /**
     *
     * @type {ChallengeType}
     * @memberof TOTPVerifyAttestation
     */
    challenge_type: ChallengeType;
    /**
     *
     * @type {TOTPVerifyAttestationData}
     * @memberof TOTPVerifyAttestation
     */
    data?: TOTPVerifyAttestationData;
}
/**
 *
 * @export
 * @interface WebAuthnCreateAttestation
 */
interface WebAuthnCreateAttestation {
    /**
     *
     * @type {string}
     * @memberof WebAuthnCreateAttestation
     */
    challenge_id: string;
    /**
     *
     * @type {ChallengeType}
     * @memberof WebAuthnCreateAttestation
     */
    challenge_type: ChallengeType;
    /**
     *
     * @type {object}
     * @memberof WebAuthnCreateAttestation
     */
    data?: object;
}
/**
 *
 * @export
 * @interface WebAuthnGetAttestation
 */
interface WebAuthnGetAttestation {
    /**
     *
     * @type {string}
     * @memberof WebAuthnGetAttestation
     */
    challenge_id: string;
    /**
     *
     * @type {ChallengeType}
     * @memberof WebAuthnGetAttestation
     */
    challenge_type: ChallengeType;
    /**
     *
     * @type {object}
     * @memberof WebAuthnGetAttestation
     */
    data?: object;
}
/**
 * @type Attestation
 *
 * @export
 */
type Attestation = ({
    challenge_type: 'nonce';
} & NonceAttestation) | ({
    challenge_type: 'otp';
} & OTPAttestation) | ({
    challenge_type: 'password_reset';
} & PasswordResetAttestation) | ({
    challenge_type: 'password_set';
} & PasswordSetAttestation) | ({
    challenge_type: 'password_verify';
} & PasswordVerifyAttestation) | ({
    challenge_type: 'totp_register';
} & TOTPRegisterAttestation) | ({
    challenge_type: 'totp_verify';
} & TOTPVerifyAttestation) | ({
    challenge_type: 'webauthn_create';
} & WebAuthnCreateAttestation) | ({
    challenge_type: 'webauthn_get';
} & WebAuthnGetAttestation);
/**
 * SlashID API v1.1
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * Do not edit the class manually.
 */
/**
 * Allowed login factor
 * @export
 */
declare const _FactorMethod1: {
    readonly Webauthn: "webauthn";
    readonly EmailLink: "email_link";
    readonly SmsLink: "sms_link";
    readonly OtpViaSms: "otp_via_sms";
    readonly OtpViaEmail: "otp_via_email";
    readonly Totp: "totp";
    readonly Oidc: "oidc";
    readonly Saml: "saml";
    readonly Api: "api";
    readonly DirectId: "direct_id";
    readonly Password: "password";
    readonly Impersonate: "impersonate";
    readonly Anonymous: "anonymous";
};
type _FactorMethod1 = (typeof _FactorMethod1)[keyof typeof _FactorMethod1];
/**
 * SlashID API v1.1
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * Do not edit the class manually.
 */
/**
 *
 * @export
 */
export const PersonHandleType: {
    readonly EmailAddress: "email_address";
    readonly PhoneNumber: "phone_number";
    readonly Username: "username";
};
export type PersonHandleType = (typeof PersonHandleType)[keyof typeof PersonHandleType];
/**
 *
 * @export
 * @interface PersonHandle
 */
interface PersonHandle {
    /**
     *
     * @type {PersonHandleType}
     * @memberof PersonHandle
     */
    type: PersonHandleType;
    /**
     *
     * @type {string}
     * @memberof PersonHandle
     */
    value: string;
}
/**
 *
 * @export
 * @interface Authentication
 */
interface Authentication {
    /**
     *
     * @type {PersonHandle}
     * @memberof Authentication
     */
    handle: PersonHandle;
    /**
     * RFC3339 timestamp
     * @type {Date}
     * @memberof Authentication
     */
    timestamp: Date;
    /**
     *
     * @type {FactorMethod}
     * @memberof Authentication
     */
    method: _FactorMethod1;
}
/**
 *
 * @export
 * @interface EmailLinkMethodOptions
 */
interface EmailLinkMethodOptions {
    /**
     *
     * @type {FactorMethod}
     * @memberof EmailLinkMethodOptions
     */
    method: _FactorMethod1;
    /**
     * URI to redirect to after resolving the challenge.
     * @type {string}
     * @memberof EmailLinkMethodOptions
     */
    redirect_target?: string;
}
/**
 * SlashID API v1.1
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * Do not edit the class manually.
 */
/**
 *
 * @export
 */
declare const OAuthProvider: {
    readonly Google: "google";
    readonly Github: "github";
    readonly Bitbucket: "bitbucket";
    readonly Gitlab: "gitlab";
    readonly Facebook: "facebook";
    readonly Line: "line";
    readonly Azuread: "azuread";
    readonly Okta: "okta";
    readonly Apple: "apple";
};
type OAuthProvider = (typeof OAuthProvider)[keyof typeof OAuthProvider];
/**
 * SlashID API v1.1
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * Do not edit the class manually.
 */
/**
 * Determines whether the OIDC call should fetch groups data.
 * @export
 */
declare const OIDCGroupsOptions: {
    readonly True: "true";
    readonly False: "false";
};
type OIDCGroupsOptions = (typeof OIDCGroupsOptions)[keyof typeof OIDCGroupsOptions];
/**
 * SlashID API v1.1
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * Do not edit the class manually.
 */
/**
 * Determines how the OIDC login page is presented to the user; defaults to popup.
 * @export
 */
declare const OIDCUXMode: {
    readonly Popup: "popup";
    readonly Redirect: "redirect";
};
type OIDCUXMode = (typeof OIDCUXMode)[keyof typeof OIDCUXMode];
/**
 *
 * @export
 * @interface OIDCMethodOptions
 */
interface OIDCMethodOptions {
    /**
     *
     * @type {FactorMethod}
     * @memberof OIDCMethodOptions
     */
    method: _FactorMethod1;
    /**
     *
     * @type {string}
     * @memberof OIDCMethodOptions
     */
    client_id: string;
    /**
     *
     * @type {OAuthProvider}
     * @memberof OIDCMethodOptions
     */
    provider: OAuthProvider;
    /**
     *
     * @type {OIDCUXMode}
     * @memberof OIDCMethodOptions
     * @deprecated
     */
    ux_mode?: OIDCUXMode;
    /**
     * URL to redirect to after login at the third-party IdP.
     * @type {string}
     * @memberof OIDCMethodOptions
     */
    redirect_target?: string;
    /**
     *
     * @type {OIDCGroupsOptions}
     * @memberof OIDCMethodOptions
     */
    requires_groups?: OIDCGroupsOptions;
    /**
     *
     * @type {string}
     * @memberof OIDCMethodOptions
     */
    pkce_code_challenge?: string;
    /**
     *
     * @type {string}
     * @memberof OIDCMethodOptions
     */
    csrf_token?: string;
}
/**
 *
 * @export
 * @interface OTPViaEmailMethodOptions
 */
interface OTPViaEmailMethodOptions {
    /**
     *
     * @type {FactorMethod}
     * @memberof OTPViaEmailMethodOptions
     */
    method: _FactorMethod1;
}
/**
 *
 * @export
 * @interface OTPViaSMSMethodOptions
 */
interface OTPViaSMSMethodOptions {
    /**
     *
     * @type {FactorMethod}
     * @memberof OTPViaSMSMethodOptions
     */
    method: _FactorMethod1;
}
/**
 *
 * @export
 * @interface PasswordMethodOptions
 */
interface PasswordMethodOptions {
    /**
     *
     * @type {FactorMethod}
     * @memberof PasswordMethodOptions
     */
    method: _FactorMethod1;
}
/**
 * SlashID API v1.1
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * Do not edit the class manually.
 */
/**
 * Determines how the SSO login page is presented to the user; defaults to popup.
 * @export
 */
declare const SSOUXMode: {
    readonly Popup: "popup";
    readonly Redirect: "redirect";
};
type SSOUXMode = (typeof SSOUXMode)[keyof typeof SSOUXMode];
/**
 *
 * @export
 * @interface SAMLMethodOptions
 */
interface SAMLMethodOptions {
    /**
     *
     * @type {FactorMethod}
     * @memberof SAMLMethodOptions
     */
    method: _FactorMethod1;
    /**
     *
     * @type {string}
     * @memberof SAMLMethodOptions
     */
    provider_credentials_id: string;
    /**
     *
     * @type {SSOUXMode}
     * @memberof SAMLMethodOptions
     */
    ux_mode?: SSOUXMode;
    /**
     * URL to redirect to after login at the third-party IdP.
     * @type {string}
     * @memberof SAMLMethodOptions
     */
    redirect_target?: string;
    /**
     *
     * @type {string}
     * @memberof SAMLMethodOptions
     */
    pkce_code_challenge?: string;
    /**
     *
     * @type {string}
     * @memberof SAMLMethodOptions
     */
    csrf_token?: string;
}
/**
 *
 * @export
 * @interface SMSLinkMethodOptions
 */
interface SMSLinkMethodOptions {
    /**
     *
     * @type {FactorMethod}
     * @memberof SMSLinkMethodOptions
     */
    method: _FactorMethod1;
    /**
     * URI to redirect to after resolving the challenge.
     * @type {string}
     * @memberof SMSLinkMethodOptions
     */
    redirect_target?: string;
}
/**
 *
 * @export
 * @interface TOTPMethodOptions
 */
interface TOTPMethodOptions {
    /**
     *
     * @type {FactorMethod}
     * @memberof TOTPMethodOptions
     */
    method: _FactorMethod1;
}
/**
 * SlashID API v1.1
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * Do not edit the class manually.
 */
/**
 *
 * @export
 */
declare const WebAuthnAttestation: {
    readonly None: "none";
    readonly Indirect: "indirect";
    readonly Direct: "direct";
};
type WebAuthnAttestation = (typeof WebAuthnAttestation)[keyof typeof WebAuthnAttestation];
/**
 * SlashID API v1.1
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * Do not edit the class manually.
 */
/**
 *
 * @export
 */
export const WebAuthnAuthenticatorAttachment: {
    readonly Any: "any";
    readonly Platform: "platform";
    readonly CrossPlatform: "cross_platform";
};
export type WebAuthnAuthenticatorAttachment = (typeof WebAuthnAuthenticatorAttachment)[keyof typeof WebAuthnAuthenticatorAttachment];
/**
 * SlashID API v1.1
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * Do not edit the class manually.
 */
/**
 *
 * @export
 */
declare const WebAuthnResidentKey: {
    readonly Discouraged: "discouraged";
    readonly Preferred: "preferred";
    readonly Required: "required";
};
type WebAuthnResidentKey = (typeof WebAuthnResidentKey)[keyof typeof WebAuthnResidentKey];
/**
 * SlashID API v1.1
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * Do not edit the class manually.
 */
/**
 *
 * @export
 */
declare const WebAuthnUserVerification: {
    readonly Discouraged: "discouraged";
    readonly Preferred: "preferred";
    readonly Required: "required";
};
type WebAuthnUserVerification = (typeof WebAuthnUserVerification)[keyof typeof WebAuthnUserVerification];
/**
 *
 * @export
 * @interface WebAuthnMethodOptions
 */
interface WebAuthnMethodOptions {
    /**
     *
     * @type {FactorMethod}
     * @memberof WebAuthnMethodOptions
     */
    method: _FactorMethod1;
    /**
     *
     * @type {string}
     * @memberof WebAuthnMethodOptions
     */
    scope?: string;
    /**
     *
     * @type {Array<string>}
     * @memberof WebAuthnMethodOptions
     */
    available_credential_ids?: Array<string>;
    /**
     *
     * @type {WebAuthnAuthenticatorAttachment}
     * @memberof WebAuthnMethodOptions
     */
    attachment?: WebAuthnAuthenticatorAttachment;
    /**
     *
     * @type {WebAuthnUserVerification}
     * @memberof WebAuthnMethodOptions
     */
    user_verification?: WebAuthnUserVerification;
    /**
     *
     * @type {WebAuthnResidentKey}
     * @memberof WebAuthnMethodOptions
     */
    resident_key?: WebAuthnResidentKey;
    /**
     *
     * @type {WebAuthnAttestation}
     * @memberof WebAuthnMethodOptions
     */
    attestation?: WebAuthnAttestation;
}
/**
 * @type FactorOptions
 *
 * @export
 */
type FactorOptions = ({
    method: 'email_link';
} & EmailLinkMethodOptions) | ({
    method: 'oidc';
} & OIDCMethodOptions) | ({
    method: 'otp_via_email';
} & OTPViaEmailMethodOptions) | ({
    method: 'otp_via_sms';
} & OTPViaSMSMethodOptions) | ({
    method: 'password';
} & PasswordMethodOptions) | ({
    method: 'saml';
} & SAMLMethodOptions) | ({
    method: 'sms_link';
} & SMSLinkMethodOptions) | ({
    method: 'totp';
} & TOTPMethodOptions) | ({
    method: 'webauthn';
} & WebAuthnMethodOptions);
/**
 *
 * @export
 * @interface Factor
 */
interface _Factor1 {
    /**
     *
     * @type {FactorMethod}
     * @memberof Factor
     */
    method?: _FactorMethod1;
    /**
     *
     * @type {FactorOptions}
     * @memberof Factor
     */
    options?: FactorOptions;
}
/**
 *
 * @export
 * @interface AuthnContextUpdateChallengeOptions
 */
interface AuthnContextUpdateChallengeOptions {
    /**
     *
     * @type {string}
     * @memberof AuthnContextUpdateChallengeOptions
     */
    target_org_id: string;
    /**
     *
     * @type {Factor}
     * @memberof AuthnContextUpdateChallengeOptions
     */
    factor?: _Factor1;
}
/**
 *
 * @export
 * @interface AuthnContextUpdateChallenge
 */
interface AuthnContextUpdateChallenge {
    /**
     *
     * @type {string}
     * @memberof AuthnContextUpdateChallenge
     */
    id: string;
    /**
     *
     * @type {ChallengeType}
     * @memberof AuthnContextUpdateChallenge
     */
    type: ChallengeType;
    /**
     *
     * @type {FactorMethod}
     * @memberof AuthnContextUpdateChallenge
     */
    authentication_method: _FactorMethod1;
    /**
     *
     * @type {AuthnContextUpdateChallengeOptions}
     * @memberof AuthnContextUpdateChallenge
     */
    options: AuthnContextUpdateChallengeOptions;
}
/**
 * SlashID API v1.1
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * Do not edit the class manually.
 */
/**
 *
 * @export
 */
declare const PasswordValidationRuleName: {
    readonly Length: "length";
    readonly PasswordVariants: "password_variants";
    readonly AdminVariants: "admin_variants";
    readonly UserVariants: "user_variants";
    readonly AlphanumericSequences1: "alphanumeric_sequences_1";
    readonly AlphanumericSequences2: "alphanumeric_sequences_2";
    readonly NumericSequencesAscending: "numeric_sequences_ascending";
    readonly NumericSequencesDescending: "numeric_sequences_descending";
    readonly NumericSubsequencesAscending: "numeric_subsequences_ascending";
    readonly NumericSubsequencesDescending: "numeric_subsequences_descending";
    readonly CommonPasswordXkcd: "common_password_xkcd";
};
type PasswordValidationRuleName = (typeof PasswordValidationRuleName)[keyof typeof PasswordValidationRuleName];
/**
 *
 * @export
 * @interface NonceChallengeOptions
 */
interface NonceChallengeOptions {
    /**
     *
     * @type {string}
     * @memberof NonceChallengeOptions
     */
    challenge?: string;
}
/**
 *
 * @export
 * @interface NonceChallenge
 */
interface NonceChallenge {
    /**
     *
     * @type {string}
     * @memberof NonceChallenge
     */
    id: string;
    /**
     *
     * @type {ChallengeType}
     * @memberof NonceChallenge
     */
    type: ChallengeType;
    /**
     *
     * @type {FactorMethod}
     * @memberof NonceChallenge
     */
    authentication_method: _FactorMethod1;
    /**
     *
     * @type {NonceChallengeOptions}
     * @memberof NonceChallenge
     */
    options?: NonceChallengeOptions;
}
/**
 *
 * @export
 * @interface OIDCChallengeOptions
 */
interface OIDCChallengeOptions {
    /**
     *
     * @type {string}
     * @memberof OIDCChallengeOptions
     */
    auth_code_url: string;
}
/**
 *
 * @export
 * @interface OIDCChallenge
 */
interface OIDCChallenge {
    /**
     *
     * @type {string}
     * @memberof OIDCChallenge
     */
    id: string;
    /**
     *
     * @type {ChallengeType}
     * @memberof OIDCChallenge
     */
    type: ChallengeType;
    /**
     *
     * @type {FactorMethod}
     * @memberof OIDCChallenge
     */
    authentication_method: _FactorMethod1;
    /**
     *
     * @type {OIDCChallengeOptions}
     * @memberof OIDCChallenge
     */
    options: OIDCChallengeOptions;
}
/**
 *
 * @export
 * @interface OTPChallenge
 */
interface OTPChallenge {
    /**
     *
     * @type {string}
     * @memberof OTPChallenge
     */
    id: string;
    /**
     *
     * @type {ChallengeType}
     * @memberof OTPChallenge
     */
    type: ChallengeType;
    /**
     *
     * @type {FactorMethod}
     * @memberof OTPChallenge
     */
    authentication_method: _FactorMethod1;
}
/**
 * SlashID API v1.1
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * Do not edit the class manually.
 */
/**
 *
 * @export
 */
declare const PatternMatchType: {
    readonly Match: "must_match";
    readonly NotMatch: "must_not_match";
};
type PatternMatchType = (typeof PatternMatchType)[keyof typeof PatternMatchType];
/**
 * SlashID API v1.1
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * Do not edit the class manually.
 */
/**
 *
 * @export
 */
declare const PatternQualifier: {
    readonly CaseInsensitive: "case_insensitive";
};
type PatternQualifier = (typeof PatternQualifier)[keyof typeof PatternQualifier];
/**
 *
 * @export
 * @interface RegexPasswordValidationRule
 */
interface RegexPasswordValidationRule {
    /**
     *
     * @type {PasswordValidationRuleName}
     * @memberof RegexPasswordValidationRule
     */
    name: PasswordValidationRuleName;
    /**
     *
     * @type {string}
     * @memberof RegexPasswordValidationRule
     */
    pattern: string;
    /**
     *
     * @type {PatternMatchType}
     * @memberof RegexPasswordValidationRule
     */
    match_type: PatternMatchType;
    /**
     *
     * @type {Array<PatternQualifier>}
     * @memberof RegexPasswordValidationRule
     */
    pattern_qualifiers?: Array<PatternQualifier>;
}
/**
 *
 * @export
 * @interface PasswordValidationRuleset
 */
interface PasswordValidationRuleset {
    /**
     *
     * @type {Array<RegexPasswordValidationRule>}
     * @memberof PasswordValidationRuleset
     */
    regular_expressions?: Array<RegexPasswordValidationRule>;
}
/**
 *
 * @export
 * @interface PasswordResetChallengeOptions
 */
interface PasswordResetChallengeOptions {
    /**
     *
     * @type {PasswordValidationRuleset}
     * @memberof PasswordResetChallengeOptions
     */
    validation_rules: PasswordValidationRuleset;
}
/**
 *
 * @export
 * @interface PasswordResetChallenge
 */
interface PasswordResetChallenge {
    /**
     *
     * @type {string}
     * @memberof PasswordResetChallenge
     */
    id: string;
    /**
     *
     * @type {ChallengeType}
     * @memberof PasswordResetChallenge
     */
    type: ChallengeType;
    /**
     *
     * @type {FactorMethod}
     * @memberof PasswordResetChallenge
     */
    authentication_method: _FactorMethod1;
    /**
     *
     * @type {PasswordResetChallengeOptions}
     * @memberof PasswordResetChallenge
     */
    options: PasswordResetChallengeOptions;
}
/**
 *
 * @export
 * @interface PasswordSetChallengeOptions
 */
interface PasswordSetChallengeOptions {
    /**
     *
     * @type {PasswordValidationRuleset}
     * @memberof PasswordSetChallengeOptions
     */
    validation_rules: PasswordValidationRuleset;
}
/**
 *
 * @export
 * @interface PasswordSetChallenge
 */
interface PasswordSetChallenge {
    /**
     *
     * @type {string}
     * @memberof PasswordSetChallenge
     */
    id: string;
    /**
     *
     * @type {ChallengeType}
     * @memberof PasswordSetChallenge
     */
    type: ChallengeType;
    /**
     *
     * @type {FactorMethod}
     * @memberof PasswordSetChallenge
     */
    authentication_method: _FactorMethod1;
    /**
     *
     * @type {PasswordSetChallengeOptions}
     * @memberof PasswordSetChallenge
     */
    options: PasswordSetChallengeOptions;
}
/**
 *
 * @export
 * @interface PasswordVerifyChallenge
 */
interface PasswordVerifyChallenge {
    /**
     *
     * @type {string}
     * @memberof PasswordVerifyChallenge
     */
    id: string;
    /**
     *
     * @type {ChallengeType}
     * @memberof PasswordVerifyChallenge
     */
    type: ChallengeType;
    /**
     *
     * @type {FactorMethod}
     * @memberof PasswordVerifyChallenge
     */
    authentication_method: _FactorMethod1;
}
/**
 *
 * @export
 * @interface ProxyChallengeOptions
 */
interface ProxyChallengeOptions {
    /**
     *
     * @type {string}
     * @memberof ProxyChallengeOptions
     */
    challenge_id?: string;
}
/**
 *
 * @export
 * @interface ProxyChallenge
 */
interface ProxyChallenge {
    /**
     *
     * @type {string}
     * @memberof ProxyChallenge
     */
    id: string;
    /**
     *
     * @type {ChallengeType}
     * @memberof ProxyChallenge
     */
    type: ChallengeType;
    /**
     *
     * @type {FactorMethod}
     * @memberof ProxyChallenge
     */
    authentication_method: _FactorMethod1;
    /**
     *
     * @type {ProxyChallengeOptions}
     * @memberof ProxyChallenge
     */
    options?: ProxyChallengeOptions;
}
/**
 *
 * @export
 * @interface SAMLChallengeOptions
 */
interface SAMLChallengeOptions {
    /**
     *
     * @type {string}
     * @memberof SAMLChallengeOptions
     */
    start_authentication_url: string;
}
/**
 *
 * @export
 * @interface SAMLChallenge
 */
interface SAMLChallenge {
    /**
     *
     * @type {string}
     * @memberof SAMLChallenge
     */
    id: string;
    /**
     *
     * @type {ChallengeType}
     * @memberof SAMLChallenge
     */
    type: ChallengeType;
    /**
     *
     * @type {FactorMethod}
     * @memberof SAMLChallenge
     */
    authentication_method: _FactorMethod1;
    /**
     *
     * @type {SAMLChallengeOptions}
     * @memberof SAMLChallenge
     */
    options: SAMLChallengeOptions;
}
/**
 *
 * @export
 * @interface TOTPRegisterChallengeOptions
 */
interface TOTPRegisterChallengeOptions {
    /**
     *
     * @type {string}
     * @memberof TOTPRegisterChallengeOptions
     */
    key_uri: string;
    /**
     *
     * @type {string}
     * @memberof TOTPRegisterChallengeOptions
     */
    qr_code_data_b64: string;
    /**
     *
     * @type {Array<string>}
     * @memberof TOTPRegisterChallengeOptions
     */
    recovery_codes: Array<string>;
}
/**
 *
 * @export
 * @interface TOTPRegisterChallenge
 */
interface TOTPRegisterChallenge {
    /**
     *
     * @type {string}
     * @memberof TOTPRegisterChallenge
     */
    id: string;
    /**
     *
     * @type {ChallengeType}
     * @memberof TOTPRegisterChallenge
     */
    type: ChallengeType;
    /**
     *
     * @type {FactorMethod}
     * @memberof TOTPRegisterChallenge
     */
    authentication_method: _FactorMethod1;
    /**
     *
     * @type {TOTPRegisterChallengeOptions}
     * @memberof TOTPRegisterChallenge
     */
    options?: TOTPRegisterChallengeOptions;
}
/**
 *
 * @export
 * @interface TOTPVerifyChallenge
 */
interface TOTPVerifyChallenge {
    /**
     *
     * @type {string}
     * @memberof TOTPVerifyChallenge
     */
    id: string;
    /**
     *
     * @type {ChallengeType}
     * @memberof TOTPVerifyChallenge
     */
    type: ChallengeType;
    /**
     *
     * @type {FactorMethod}
     * @memberof TOTPVerifyChallenge
     */
    authentication_method: _FactorMethod1;
}
/**
 *
 * @export
 * @interface UICustomizationChallengeOptions
 */
interface UICustomizationChallengeOptions {
    /**
     * UI configuration for the hosted page users are redirected to after clicking a magic link or password reset link.
     * @type {{ [key: string]: any; }}
     * @memberof UICustomizationChallengeOptions
     */
    authn_redirect_page_ui_config?: {
        [key: string]: any;
    };
}
/**
 *
 * @export
 * @interface UICustomizationChallenge
 */
interface UICustomizationChallenge {
    /**
     *
     * @type {string}
     * @memberof UICustomizationChallenge
     */
    id: string;
    /**
     *
     * @type {ChallengeType}
     * @memberof UICustomizationChallenge
     */
    type: ChallengeType;
    /**
     *
     * @type {FactorMethod}
     * @memberof UICustomizationChallenge
     */
    authentication_method: _FactorMethod1;
    /**
     *
     * @type {UICustomizationChallengeOptions}
     * @memberof UICustomizationChallenge
     */
    options?: UICustomizationChallengeOptions;
}
/**
 *
 * @export
 * @interface WebAuthnCreateChallenge
 */
interface WebAuthnCreateChallenge {
    /**
     *
     * @type {string}
     * @memberof WebAuthnCreateChallenge
     */
    id: string;
    /**
     *
     * @type {ChallengeType}
     * @memberof WebAuthnCreateChallenge
     */
    type: ChallengeType;
    /**
     *
     * @type {FactorMethod}
     * @memberof WebAuthnCreateChallenge
     */
    authentication_method: _FactorMethod1;
    /**
     * The "Options for Credential Creation" as described by the WebAuthn spec at https://www.w3.org/TR/webauthn/#dictionary-makecredentialoptions
     * @type {object}
     * @memberof WebAuthnCreateChallenge
     */
    options?: object;
}
/**
 *
 * @export
 * @interface WebAuthnGetChallenge
 */
interface WebAuthnGetChallenge {
    /**
     *
     * @type {string}
     * @memberof WebAuthnGetChallenge
     */
    id: string;
    /**
     *
     * @type {ChallengeType}
     * @memberof WebAuthnGetChallenge
     */
    type: ChallengeType;
    /**
     *
     * @type {FactorMethod}
     * @memberof WebAuthnGetChallenge
     */
    authentication_method: _FactorMethod1;
    /**
     * The "Options for Assertion Generation" as described by the WebAuthn spec at https://www.w3.org/TR/webauthn/#assertion-options
     * @type {object}
     * @memberof WebAuthnGetChallenge
     */
    options?: object;
}
/**
 * @type ChallengeListInner
 *
 * @export
 */
type ChallengeListInner = ({
    type: 'authn_context_update';
} & AuthnContextUpdateChallenge) | ({
    type: 'nonce';
} & NonceChallenge) | ({
    type: 'oidc';
} & OIDCChallenge) | ({
    type: 'otp';
} & OTPChallenge) | ({
    type: 'password_reset';
} & PasswordResetChallenge) | ({
    type: 'password_set';
} & PasswordSetChallenge) | ({
    type: 'password_verify';
} & PasswordVerifyChallenge) | ({
    type: 'proxy';
} & ProxyChallenge) | ({
    type: 'saml';
} & SAMLChallenge) | ({
    type: 'totp_register';
} & TOTPRegisterChallenge) | ({
    type: 'totp_verify';
} & TOTPVerifyChallenge) | ({
    type: 'ui_customization';
} & UICustomizationChallenge) | ({
    type: 'webauthn_create';
} & WebAuthnCreateChallenge) | ({
    type: 'webauthn_get';
} & WebAuthnGetChallenge);
/**
 * SlashID API v1.1
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * Do not edit the class manually.
 */
/**
 * The type of the credential
 * @export
 */
declare const CredentialType: {
    readonly PublicKey: "public-key";
    readonly Password: "password";
    readonly Totp: "totp";
};
type CredentialType = (typeof CredentialType)[keyof typeof CredentialType];
/**
 * SlashID API v1.1
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * Do not edit the class manually.
 */
/**
 *
 * @export
 */
declare const EventName: {
    readonly AuthenticationSucceededV1: "AuthenticationSucceeded_v1";
    readonly AuthenticationFailedV1: "AuthenticationFailed_v1";
    readonly PersonCreatedV1: "PersonCreated_v1";
    readonly AnonymousPersonCreatedV1: "AnonymousPersonCreated_v1";
    readonly PersonDeletedV1: "PersonDeleted_v1";
    readonly VirtualPageLoadedV1: "VirtualPageLoaded_v1";
    readonly SlashIdsdkLoadedV1: "SlashIDSDKLoaded_v1";
    readonly PersonIdentifiedV1: "PersonIdentified_v1";
    readonly PersonLoggedOutV1: "PersonLoggedOut_v1";
    readonly TokenMintedV1: "TokenMinted_v1";
    readonly AnonymousTokenMintedV1: "AnonymousTokenMinted_v1";
    readonly PasswordChangedV1: "PasswordChanged_v1";
    readonly GdprConsentsChangedV1: "GdprConsentsChanged_v1";
    readonly GateServerStartedV1: "GateServerStarted_v1";
    readonly GateRequestHandledV1: "GateRequestHandled_v1";
    readonly GateRequestCredentialFoundV1: "GateRequestCredentialFound_v1";
    readonly PermissionCreatedInRegionV1: "PermissionCreated_InRegion_v1";
    readonly PermissionCreatedV1: "PermissionCreated_v1";
    readonly PermissionDeletedInRegionV1: "PermissionDeleted_InRegion_v1";
    readonly PermissionDeletedV1: "PermissionDeleted_v1";
    readonly RoleCreatedInRegionV1: "RoleCreated_InRegion_v1";
    readonly RoleCreatedV1: "RoleCreated_v1";
    readonly RoleDeletedInRegionV1: "RoleDeleted_InRegion_v1";
    readonly RoleDeletedV1: "RoleDeleted_v1";
    readonly RoleUpdatedInRegionV1: "RoleUpdated_InRegion_v1";
    readonly RoleUpdatedV1: "RoleUpdated_v1";
    readonly RolesSetToPersonInRegionV1: "RolesSetToPerson_InRegion_v1";
    readonly RolesSetToPersonV1: "RolesSetToPerson_v1";
    readonly PermissionsSetToPersonInRegionV1: "PermissionsSetToPerson_InRegion_v1";
    readonly PermissionsSetToPersonV1: "PermissionsSetToPerson_v1";
    readonly MitmAttackDetectedV1: "MitmAttackDetected_v1";
    readonly PermissionUpdatedInRegionV1: "PermissionUpdated_InRegion_v1";
    readonly PermissionUpdatedV1: "PermissionUpdated_v1";
};
type EventName = (typeof EventName)[keyof typeof EventName];
/**
 *
 * @export
 * @interface SDKEventAuthenticationFailedV1
 */
interface SDKEventAuthenticationFailedV1 {
    /**
     *
     * @type {EventName}
     * @memberof SDKEventAuthenticationFailedV1
     */
    event_name: EventName;
    /**
     * Person ID
     * @type {string}
     * @memberof SDKEventAuthenticationFailedV1
     */
    person_id?: string;
    /**
     *
     * @type {Array<FactorMethod>}
     * @memberof SDKEventAuthenticationFailedV1
     */
    authenticated_methods?: Array<_FactorMethod1>;
    /**
     *
     * @type {FactorMethod}
     * @memberof SDKEventAuthenticationFailedV1
     */
    failed_authn_method: _FactorMethod1;
    /**
     *
     * @type {string}
     * @memberof SDKEventAuthenticationFailedV1
     */
    failure_reason: string;
    /**
     *
     * @type {string}
     * @memberof SDKEventAuthenticationFailedV1
     */
    failure_detail?: string;
    /**
     *
     * @type {PersonHandle}
     * @memberof SDKEventAuthenticationFailedV1
     */
    handle?: PersonHandle;
    /**
     *
     * @type {string}
     * @memberof SDKEventAuthenticationFailedV1
     */
    challenge_id?: string;
}
/**
 *
 * @export
 * @interface SDKEventAuthenticationSucceededV1
 */
interface SDKEventAuthenticationSucceededV1 {
    /**
     *
     * @type {EventName}
     * @memberof SDKEventAuthenticationSucceededV1
     */
    event_name: EventName;
    /**
     * Person ID
     * @type {string}
     * @memberof SDKEventAuthenticationSucceededV1
     */
    person_id: string;
    /**
     *
     * @type {FactorMethod}
     * @memberof SDKEventAuthenticationSucceededV1
     */
    success_authn_method: _FactorMethod1;
    /**
     *
     * @type {Array<FactorMethod>}
     * @memberof SDKEventAuthenticationSucceededV1
     */
    authenticated_methods: Array<_FactorMethod1>;
    /**
     *
     * @type {PersonHandle}
     * @memberof SDKEventAuthenticationSucceededV1
     */
    handle?: PersonHandle;
}
/**
 *
 * @export
 * @interface SDKEventPersonIdentifiedV1
 */
interface SDKEventPersonIdentifiedV1 {
    /**
     *
     * @type {EventName}
     * @memberof SDKEventPersonIdentifiedV1
     */
    event_name: EventName;
    /**
     * Person ID
     * @type {string}
     * @memberof SDKEventPersonIdentifiedV1
     */
    person_id: string;
}
/**
 *
 * @export
 * @interface SDKEventPersonLoggedOutV1
 */
interface SDKEventPersonLoggedOutV1 {
    /**
     *
     * @type {EventName}
     * @memberof SDKEventPersonLoggedOutV1
     */
    event_name: EventName;
    /**
     * Person ID
     * @type {string}
     * @memberof SDKEventPersonLoggedOutV1
     */
    person_id: string;
}
/**
 *
 * @export
 * @interface SDKEventSlashIDSDKLoadedV1
 */
interface SDKEventSlashIDSDKLoadedV1 {
    /**
     *
     * @type {EventName}
     * @memberof SDKEventSlashIDSDKLoadedV1
     */
    event_name: EventName;
}
/**
 *
 * @export
 * @interface SDKEventVirtualPageLoadedV1
 */
interface SDKEventVirtualPageLoadedV1 {
    /**
     *
     * @type {EventName}
     * @memberof SDKEventVirtualPageLoadedV1
     */
    event_name: EventName;
    /**
     * Person ID
     * @type {string}
     * @memberof SDKEventVirtualPageLoadedV1
     */
    person_id?: string;
}
/**
 * @type EventPostRequestEventData
 *
 * @export
 */
type EventPostRequestEventData = ({
    event_name: 'AuthenticationFailed_v1';
} & SDKEventAuthenticationFailedV1) | ({
    event_name: 'AuthenticationSucceeded_v1';
} & SDKEventAuthenticationSucceededV1) | ({
    event_name: 'PersonIdentified_v1';
} & SDKEventPersonIdentifiedV1) | ({
    event_name: 'PersonLoggedOut_v1';
} & SDKEventPersonLoggedOutV1) | ({
    event_name: 'SlashIDSDKLoaded_v1';
} & SDKEventSlashIDSDKLoadedV1) | ({
    event_name: 'VirtualPageLoaded_v1';
} & SDKEventVirtualPageLoadedV1);
/**
 *
 * @export
 * @interface EventPostRequest
 */
interface EventPostRequest {
    /**
     *
     * @type {string}
     * @memberof EventPostRequest
     */
    organization_id: string;
    /**
     *
     * @type {string}
     * @memberof EventPostRequest
     */
    analytics_correlation_id: string;
    /**
     *
     * @type {string}
     * @memberof EventPostRequest
     */
    window_location: string;
    /**
     *
     * @type {string}
     * @memberof EventPostRequest
     */
    user_agent: string;
    /**
     *
     * @type {EventPostRequestEventData}
     * @memberof EventPostRequest
     */
    event_data: EventPostRequestEventData;
}
/**
 *
 * @export
 * @interface PasswordCredentialParams
 */
interface PasswordCredentialParams {
    /**
     * A hash of a password, in the one of the formats accepts by SlashID.
     * SlashID supports the following hashing functions:
     *   - pbkdf2
     *   - bcrypt
     *   - argon2i
     *   - argon2id
     * Hashes created using a function not listed here will be rejected.
     * In all of these cases, SlashID accepts hashes in the format described [here](https://github.com/P-H-C/phc-string-format/blob/master/phc-sf-spec.md).
     * The only departure from the specification described is that the hashing function version can include the characters [a-z0-9], to accommodate bcrypt versions (2, 2a, 2b, 2x, 2y).
     * SlashID also accepts password hashes in the format used by [bcrypt](https://www.usenix.org/legacy/events/usenix99/provos/provos.pdf).
     * If a password hash matches this format, it is assumed that the hashing function used was bcrypt.
     * If any other hashing function was used to hash the password, the hash must be in the SlashID hash format.
     * @type {string}
     * @memberof PasswordCredentialParams
     */
    password_hash: string;
}
/**
 *
 * @export
 * @interface ExportedPasswordCredential
 */
interface ExportedPasswordCredential {
    /**
     * The ID of the credential
     * @type {string}
     * @memberof ExportedPasswordCredential
     */
    id: string;
    /**
     * The time when the credential was last used to authenticate successfully
     * @type {Date}
     * @memberof ExportedPasswordCredential
     */
    last_used?: Date;
    /**
     *
     * @type {CredentialType}
     * @memberof ExportedPasswordCredential
     */
    type: CredentialType;
    /**
     *
     * @type {PasswordCredentialParams}
     * @memberof ExportedPasswordCredential
     */
    params: PasswordCredentialParams;
    /**
     *
     * @type {string}
     * @memberof ExportedPasswordCredential
     */
    label?: string;
}
/**
 *
 * @export
 * @interface PublicKeyAuthenticator
 */
interface PublicKeyAuthenticator {
    /**
     * Base64-encoded AAGUID of the authenticator device
     * @type {string}
     * @memberof PublicKeyAuthenticator
     */
    aaguid: string;
    /**
     *
     * @type {number}
     * @memberof PublicKeyAuthenticator
     */
    sign_count?: number;
    /**
     *
     * @type {boolean}
     * @memberof PublicKeyAuthenticator
     */
    clone_warning?: boolean;
}
/**
 *
 * @export
 * @interface PublicKeyCredentialParams
 */
interface PublicKeyCredentialParams {
    /**
     * The ID of the webauthn credential
     * @type {string}
     * @memberof PublicKeyCredentialParams
     */
    webauthn_credential_id: string;
    /**
     * Base64-encoded public key
     * @type {string}
     * @memberof PublicKeyCredentialParams
     */
    public_key: string;
    /**
     * The attestation type for the public key (defaults to "none")
     * @type {string}
     * @memberof PublicKeyCredentialParams
     */
    attestation_type: string;
    /**
     *
     * @type {PublicKeyAuthenticator}
     * @memberof PublicKeyCredentialParams
     */
    authenticator: PublicKeyAuthenticator;
}
/**
 *
 * @export
 * @interface ExportedPublicKeyCredential
 */
interface ExportedPublicKeyCredential {
    /**
     * The ID of the credential
     * @type {string}
     * @memberof ExportedPublicKeyCredential
     */
    id: string;
    /**
     * The time when the credential was last used to authenticate successfully
     * @type {Date}
     * @memberof ExportedPublicKeyCredential
     */
    last_used?: Date;
    /**
     *
     * @type {CredentialType}
     * @memberof ExportedPublicKeyCredential
     */
    type: CredentialType;
    /**
     *
     * @type {PublicKeyCredentialParams}
     * @memberof ExportedPublicKeyCredential
     */
    params: PublicKeyCredentialParams;
    /**
     *
     * @type {string}
     * @memberof ExportedPublicKeyCredential
     */
    label?: string;
}
/**
 *
 * @export
 * @interface ExportedTOTPCredentialParams
 */
interface ExportedTOTPCredentialParams {
    /**
     * The total number of recovery codes originally issued to the given person.
     * @type {number}
     * @memberof ExportedTOTPCredentialParams
     */
    recovery_codes_total: number;
    /**
     * The total number of recovery codes still unused by the given person.
     * @type {number}
     * @memberof ExportedTOTPCredentialParams
     */
    recovery_codes_unused: number;
}
/**
 *
 * @export
 * @interface ExportedTOTPCredential
 */
interface ExportedTOTPCredential {
    /**
     * The ID of the credential
     * @type {string}
     * @memberof ExportedTOTPCredential
     */
    id: string;
    /**
     * The time when the credential was last used to authenticate successfully
     * @type {Date}
     * @memberof ExportedTOTPCredential
     */
    last_used?: Date;
    /**
     *
     * @type {CredentialType}
     * @memberof ExportedTOTPCredential
     */
    type: CredentialType;
    /**
     *
     * @type {ExportedTOTPCredentialParams}
     * @memberof ExportedTOTPCredential
     */
    params: ExportedTOTPCredentialParams;
    /**
     *
     * @type {string}
     * @memberof ExportedTOTPCredential
     */
    label?: string;
}
/**
 * @type ExportedCredential
 *
 * @export
 */
type ExportedCredential = ({
    type: 'password';
} & ExportedPasswordCredential) | ({
    type: 'public-key';
} & ExportedPublicKeyCredential) | ({
    type: 'totp';
} & ExportedTOTPCredential);
/**
 * SlashID API v1.1
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * Do not edit the class manually.
 */
/**
 *
 * @export
 */
declare const GDPRConsentLevel: {
    readonly None: "none";
    readonly Necessary: "necessary";
    readonly Analytics: "analytics";
    readonly Marketing: "marketing";
    readonly Retargeting: "retargeting";
    readonly Tracking: "tracking";
};
type GDPRConsentLevel = (typeof GDPRConsentLevel)[keyof typeof GDPRConsentLevel];
/**
 *
 * @export
 * @interface GDPRConsent
 */
interface GDPRConsent {
    /**
     *
     * @type {GDPRConsentLevel}
     * @memberof GDPRConsent
     */
    consent_level: GDPRConsentLevel;
    /**
     * Time when this consent was first created for this person
     * @type {Date}
     * @memberof GDPRConsent
     */
    created_at: Date;
}
/**
 *
 * @export
 * @interface GDPRConsentResponse
 */
interface GDPRConsentResponse {
    /**
     *
     * @type {Array<GDPRConsent>}
     * @memberof GDPRConsentResponse
     */
    consents: Array<GDPRConsent>;
}
/**
 *
 * @export
 * @interface GetAttributes200Response
 */
interface GetAttributes200Response {
    /**
     *
     * @type {APIMeta}
     * @memberof GetAttributes200Response
     */
    meta?: APIMeta;
    /**
     *
     * @type {Array<APIResponseError>}
     * @memberof GetAttributes200Response
     */
    errors?: Array<_APIResponseError1>;
    /**
     * Attributes divided into named buckets. Bucket names are top level keys; attributes are values. Attributes consist of key-value pairs. Attribute names (keys) may be at most 70 bytes long. Attribute values must be JSON-serializable and are limited to 64KiB.
     * @type {{ [key: string]: { [key: string]: any; }; }}
     * @memberof GetAttributes200Response
     */
    result?: {
        [key: string]: {
            [key: string]: any;
        };
    };
}
/**
 *
 * @export
 * @interface GetAttributesBucketName200Response
 */
interface GetAttributesBucketName200Response {
    /**
     *
     * @type {APIMeta}
     * @memberof GetAttributesBucketName200Response
     */
    meta?: APIMeta;
    /**
     *
     * @type {Array<APIResponseError>}
     * @memberof GetAttributesBucketName200Response
     */
    errors?: Array<_APIResponseError1>;
    /**
     * Clear-text person attributes as key-value pairs. Attribute names (keys) may be at most 70 bytes long. Attribute values must be JSON-serializable and are limited to 64KiB.
     * @type {{ [key: string]: any; }}
     * @memberof GetAttributesBucketName200Response
     */
    result?: {
        [key: string]: any;
    };
}
/**
 *
 * @export
 * @interface GetChallengeChallengeId200Response
 */
interface GetChallengeChallengeId200Response {
    /**
     *
     * @type {APIMeta}
     * @memberof GetChallengeChallengeId200Response
     */
    meta?: APIMeta;
    /**
     *
     * @type {Array<APIResponseError>}
     * @memberof GetChallengeChallengeId200Response
     */
    errors?: Array<_APIResponseError1>;
    /**
     *
     * @type {string}
     * @memberof GetChallengeChallengeId200Response
     */
    result?: string;
}
/**
 *
 * @export
 * @interface GetChallengeChallengeIdV2200Response
 */
interface GetChallengeChallengeIdV2200Response {
    /**
     *
     * @type {APIMeta}
     * @memberof GetChallengeChallengeIdV2200Response
     */
    meta?: APIMeta;
    /**
     *
     * @type {Array<APIResponseError>}
     * @memberof GetChallengeChallengeIdV2200Response
     */
    errors?: Array<_APIResponseError1>;
    /**
     *
     * @type {string}
     * @memberof GetChallengeChallengeIdV2200Response
     */
    result?: string;
}
/**
 *
 * @export
 * @interface Organization
 */
interface Organization {
    /**
     *
     * @type {string}
     * @memberof Organization
     */
    id: string;
    /**
     *
     * @type {string}
     * @memberof Organization
     */
    parent_id?: string;
    /**
     *
     * @type {string}
     * @memberof Organization
     */
    org_name: string;
    /**
     *
     * @type {string}
     * @memberof Organization
     */
    tenant_name: string;
}
/**
 *
 * @export
 * @interface OrganizationDetails
 */
interface OrganizationDetails {
    /**
     *
     * @type {string}
     * @memberof OrganizationDetails
     */
    id: string;
    /**
     *
     * @type {string}
     * @memberof OrganizationDetails
     */
    parent_id?: string;
    /**
     *
     * @type {string}
     * @memberof OrganizationDetails
     */
    org_name: string;
    /**
     *
     * @type {string}
     * @memberof OrganizationDetails
     */
    tenant_name: string;
    /**
     *
     * @type {Array<Organization>}
     * @memberof OrganizationDetails
     */
    managed_organizations?: Array<Organization>;
}
/**
 * SlashID API v1.1
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * Do not edit the class manually.
 */
/**
 *
 * @export
 */
declare const PersonType: {
    readonly Regular: "regular";
    readonly Anonymous: "anonymous";
};
type PersonType = (typeof PersonType)[keyof typeof PersonType];
/**
 * Abridged person structure
 * @export
 * @interface PersonRet
 */
interface PersonRet {
    /**
     * A flag indicating whether the person is active or not
     * @type {boolean}
     * @memberof PersonRet
     */
    active: boolean;
    /**
     * The ID of the person
     * @type {string}
     * @memberof PersonRet
     */
    person_id: string;
    /**
     *
     * @type {PersonType}
     * @memberof PersonRet
     */
    person_type: PersonType;
    /**
     *
     * @type {Region}
     * @memberof PersonRet
     */
    region: Region;
    /**
     *
     * @type {Array<PersonHandle>}
     * @memberof PersonRet
     */
    handles?: Array<PersonHandle>;
    /**
     *
     * @type {Array<string>}
     * @memberof PersonRet
     */
    groups?: Array<string>;
    /**
     * Attributes divided into named buckets. Bucket names are top level keys; attributes are values. Attributes consist of key-value pairs. Attribute names (keys) may be at most 70 bytes long. Attribute values must be JSON-serializable and are limited to 64KiB.
     * @type {{ [key: string]: { [key: string]: any; }; }}
     * @memberof PersonRet
     */
    attributes?: {
        [key: string]: {
            [key: string]: any;
        };
    };
}
/**
 *
 * @export
 * @interface GetMeResp
 */
interface GetMeResp {
    /**
     *
     * @type {PersonRet}
     * @memberof GetMeResp
     */
    person: PersonRet;
    /**
     *
     * @type {Array<OrganizationDetails>}
     * @memberof GetMeResp
     */
    organizations: Array<OrganizationDetails>;
    /**
     *
     * @type {Array<PersonHandle>}
     * @memberof GetMeResp
     */
    handles: Array<PersonHandle>;
    /**
     *
     * @type {Array<ExportedCredential>}
     * @memberof GetMeResp
     */
    credentials: Array<ExportedCredential>;
}
/**
 *
 * @export
 * @interface GetMe200Response
 */
interface GetMe200Response {
    /**
     *
     * @type {APIMeta}
     * @memberof GetMe200Response
     */
    meta?: APIMeta;
    /**
     *
     * @type {Array<APIResponseError>}
     * @memberof GetMe200Response
     */
    errors?: Array<_APIResponseError1>;
    /**
     *
     * @type {GetMeResp}
     * @memberof GetMe200Response
     */
    result: GetMeResp;
}
/**
 *
 * @export
 * @interface OrganizationHierarchy
 */
interface OrganizationHierarchy {
    /**
     *
     * @type {string}
     * @memberof OrganizationHierarchy
     */
    id: string;
    /**
     *
     * @type {string}
     * @memberof OrganizationHierarchy
     */
    parent_id?: string;
    /**
     *
     * @type {string}
     * @memberof OrganizationHierarchy
     */
    name?: string;
    /**
     *
     * @type {string}
     * @memberof OrganizationHierarchy
     */
    tenant_name?: string;
    /**
     *
     * @type {Array<string>}
     * @memberof OrganizationHierarchy
     */
    children_ids?: Array<string>;
    /**
     * The list of organizations or suborganizations that share user identities with this organization
     * @type {Array<string>}
     * @memberof OrganizationHierarchy
     */
    person_pool_orgs_ids?: Array<string>;
    /**
     * The list of organizations or suborganizations that share user groups with this organization
     * @type {Array<string>}
     * @memberof OrganizationHierarchy
     */
    group_pool_orgs_ids?: Array<string>;
    /**
     *
     * @type {string}
     * @memberof OrganizationHierarchy
     */
    manager_org_id?: string;
    /**
     *
     * @type {boolean}
     * @memberof OrganizationHierarchy
     */
    person_in_manager_org: boolean;
    /**
     *
     * @type {boolean}
     * @memberof OrganizationHierarchy
     */
    inherits_rbac_pools: boolean;
}
/**
 *
 * @export
 * @interface GetMeOrgsResp
 */
interface GetMeOrgsResp {
    /**
     *
     * @type {Array<OrganizationHierarchy>}
     * @memberof GetMeOrgsResp
     */
    org_hierarchy: Array<OrganizationHierarchy>;
}
/**
 *
 * @export
 * @interface GetMeOrgs200Response
 */
interface GetMeOrgs200Response {
    /**
     *
     * @type {APIMeta}
     * @memberof GetMeOrgs200Response
     */
    meta?: APIMeta;
    /**
     *
     * @type {Array<APIResponseError>}
     * @memberof GetMeOrgs200Response
     */
    errors?: Array<_APIResponseError1>;
    /**
     *
     * @type {GetMeOrgsResp}
     * @memberof GetMeOrgs200Response
     */
    result: GetMeOrgsResp;
}
/**
 * SlashID API v1.1
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * Do not edit the class manually.
 */
/**
 *
 * @export
 */
declare const TokenV2ReponseType: {
    readonly Token: "token";
    readonly ChallengeList: "challenge_list";
};
type TokenV2ReponseType = (typeof TokenV2ReponseType)[keyof typeof TokenV2ReponseType];
/**
 *
 * @export
 * @interface TokenV2ResponseChallengeList
 */
interface TokenV2ResponseChallengeList {
    /**
     *
     * @type {TokenV2ReponseType}
     * @memberof TokenV2ResponseChallengeList
     */
    type: TokenV2ReponseType;
    /**
     *
     * @type {Array<ChallengeListInner>}
     * @memberof TokenV2ResponseChallengeList
     */
    challenges: Array<ChallengeListInner>;
}
/**
 *
 * @export
 * @interface TokenV2ResponseToken
 */
interface TokenV2ResponseToken {
    /**
     *
     * @type {TokenV2ReponseType}
     * @memberof TokenV2ResponseToken
     */
    type: TokenV2ReponseType;
    /**
     *
     * @type {string}
     * @memberof TokenV2ResponseToken
     */
    token: string;
}
/**
 * @type TokenV2Response
 *
 * @export
 */
type TokenV2Response = ({
    type: 'challenge_list';
} & TokenV2ResponseChallengeList) | ({
    type: 'token';
} & TokenV2ResponseToken);
/**
 *
 * @export
 * @interface GetTokenV2200Response
 */
interface GetTokenV2200Response {
    /**
     *
     * @type {APIMeta}
     * @memberof GetTokenV2200Response
     */
    meta?: APIMeta;
    /**
     *
     * @type {Array<APIResponseError>}
     * @memberof GetTokenV2200Response
     */
    errors?: Array<_APIResponseError1>;
    /**
     *
     * @type {TokenV2Response}
     * @memberof GetTokenV2200Response
     */
    result?: TokenV2Response;
}
/**
 *
 * @export
 * @interface IDRequest
 */
interface IDRequest {
    /**
     *
     * @type {PersonHandle}
     * @memberof IDRequest
     */
    handle?: PersonHandle;
    /**
     *
     * @type {Factor}
     * @memberof IDRequest
     */
    factor?: _Factor1;
}
/**
 *
 * @export
 * @interface IDRequestMetadata
 */
interface IDRequestMetadata {
    /**
     *
     * @type {string}
     * @memberof IDRequestMetadata
     */
    pkce_code_challenge?: string;
    /**
     *
     * @type {string}
     * @memberof IDRequestMetadata
     */
    csrf_token?: string;
}
/**
 *
 * @export
 * @interface IDRequestV2
 */
interface IDRequestV2 {
    /**
     *
     * @type {PersonHandle}
     * @memberof IDRequestV2
     */
    handle?: PersonHandle;
    /**
     *
     * @type {Factor}
     * @memberof IDRequestV2
     */
    factor?: _Factor1;
    /**
     *
     * @type {IDRequestMetadata}
     * @memberof IDRequestV2
     */
    metadata?: IDRequestMetadata;
}
/**
 *
 * @export
 * @interface OIDCTokensInfo
 */
interface OIDCTokensInfo {
    /**
     *
     * @type {string}
     * @memberof OIDCTokensInfo
     */
    authn_id: string;
    /**
     *
     * @type {Array<string>}
     * @memberof OIDCTokensInfo
     */
    token_types: Array<string>;
    /**
     *
     * @type {OAuthProvider}
     * @memberof OIDCTokensInfo
     */
    provider: OAuthProvider;
    /**
     *
     * @type {string}
     * @memberof OIDCTokensInfo
     */
    client_id: string;
    /**
     * Groups the user belongs to in the OIDC provider
     * @type {Array<string>}
     * @memberof OIDCTokensInfo
     */
    oidc_groups?: Array<string>;
}
/**
 *
 * @export
 * @interface PostAttestationV3Resp
 */
interface PostAttestationV3Resp {
    /**
     *
     * @type {string}
     * @memberof PostAttestationV3Resp
     */
    token?: string;
}
/**
 *
 * @export
 * @interface PostAttestationV3200Response
 */
interface PostAttestationV3200Response {
    /**
     *
     * @type {APIMeta}
     * @memberof PostAttestationV3200Response
     */
    meta?: APIMeta;
    /**
     *
     * @type {Array<APIResponseError>}
     * @memberof PostAttestationV3200Response
     */
    errors?: Array<_APIResponseError1>;
    /**
     *
     * @type {PostAttestationV3Resp}
     * @memberof PostAttestationV3200Response
     */
    result?: PostAttestationV3Resp;
}
/**
 *
 * @export
 * @interface PostDirectId201Response
 */
interface PostDirectId201Response {
    /**
     *
     * @type {APIMeta}
     * @memberof PostDirectId201Response
     */
    meta?: APIMeta;
    /**
     *
     * @type {Array<APIResponseError>}
     * @memberof PostDirectId201Response
     */
    errors?: Array<_APIResponseError1>;
    /**
     *
     * @type {string}
     * @memberof PostDirectId201Response
     */
    result?: string;
}
/**
 *
 * @export
 * @interface PostId200Response
 */
interface PostId200Response {
    /**
     *
     * @type {APIMeta}
     * @memberof PostId200Response
     */
    meta?: APIMeta;
    /**
     *
     * @type {Array<APIResponseError>}
     * @memberof PostId200Response
     */
    errors?: Array<_APIResponseError1>;
    /**
     *
     * @type {Array<ChallengeListInner>}
     * @memberof PostId200Response
     */
    result?: Array<ChallengeListInner>;
}
/**
 *
 * @export
 * @interface PostPersonsAnonymous201Response
 */
interface PostPersonsAnonymous201Response {
    /**
     *
     * @type {APIMeta}
     * @memberof PostPersonsAnonymous201Response
     */
    meta?: APIMeta;
    /**
     *
     * @type {Array<APIResponseError>}
     * @memberof PostPersonsAnonymous201Response
     */
    errors?: Array<_APIResponseError1>;
    /**
     *
     * @type {string}
     * @memberof PostPersonsAnonymous201Response
     */
    result: string;
}
/**
 *
 * @export
 * @interface PostPersonsPersonIdImpersonate201Response
 */
interface PostPersonsPersonIdImpersonate201Response {
    /**
     *
     * @type {APIMeta}
     * @memberof PostPersonsPersonIdImpersonate201Response
     */
    meta?: APIMeta;
    /**
     *
     * @type {Array<APIResponseError>}
     * @memberof PostPersonsPersonIdImpersonate201Response
     */
    errors?: Array<_APIResponseError1>;
    /**
     *
     * @type {string}
     * @memberof PostPersonsPersonIdImpersonate201Response
     */
    result: string;
}
/**
 *
 * @export
 * @interface PostPersonsPersonIdImpersonateV2Request
 */
interface PostPersonsPersonIdImpersonateV2Request {
    /**
     *
     * @type {string}
     * @memberof PostPersonsPersonIdImpersonateV2Request
     */
    target_url: string;
}
/**
 *
 * @export
 * @interface PostSsoResolveRequest
 */
interface PostSsoResolveRequest {
    /**
     *
     * @type {string}
     * @memberof PostSsoResolveRequest
     */
    challenge_id: string;
    /**
     *
     * @type {string}
     * @memberof PostSsoResolveRequest
     */
    code: string;
    /**
     *
     * @type {string}
     * @memberof PostSsoResolveRequest
     */
    pkce_code_verifier: string;
}
/**
 *
 * @export
 * @interface PostTokenRequestV2
 */
interface PostTokenRequestV2 {
    /**
     *
     * @type {IDRequestMetadata}
     * @memberof PostTokenRequestV2
     */
    metadata: IDRequestMetadata;
}
/**
 *
 * @export
 * @interface ValidateTokenResponse
 */
interface ValidateTokenResponse {
    /**
     * True if token is genuine and has not expired yet, false otherwise.
     * @type {boolean}
     * @memberof ValidateTokenResponse
     */
    valid: boolean;
    /**
     * If the token is invalid, this field contains the reason.
     * @type {string}
     * @memberof ValidateTokenResponse
     */
    invalidity_reason?: ValidateTokenResponseInvalidityReasonEnum;
    /**
     * JWT token validity. This value is not present if the token is not valid (valid field == false).
     * @type {number}
     * @memberof ValidateTokenResponse
     */
    expires_in_seconds?: number;
    /**
     * Token expiration time in UTC. This value is not present if token is not valid (valid field == false) or expired.
     * @type {Date}
     * @memberof ValidateTokenResponse
     */
    expires_at?: Date;
}
/**
 * @export
 */
declare const ValidateTokenResponseInvalidityReasonEnum: {
    readonly InvalidTokenContent: "invalid_token_content";
    readonly Expired: "expired";
    readonly InvalidIssuer: "invalid_issuer";
    readonly NotEnoughFactors: "not_enough_factors";
    readonly PersonNotActive: "person_not_active";
};
type ValidateTokenResponseInvalidityReasonEnum = (typeof ValidateTokenResponseInvalidityReasonEnum)[keyof typeof ValidateTokenResponseInvalidityReasonEnum];
/**
 * SlashID API v1.1
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * Do not edit the class manually.
 */
/**
 * Authentication factor that can be recovered
 * @export
 */
declare const RecoverableFactorMethod: {
    readonly Password: "password";
};
type RecoverableFactorMethod = (typeof RecoverableFactorMethod)[keyof typeof RecoverableFactorMethod];
/**
 *
 * @export
 * @interface RecoverableFactor
 */
interface RecoverableFactor {
    /**
     *
     * @type {RecoverableFactorMethod}
     * @memberof RecoverableFactor
     */
    method: RecoverableFactorMethod;
}
/**
 *
 * @export
 * @interface RecoverRequest
 */
interface RecoverRequest {
    /**
     *
     * @type {PersonHandle}
     * @memberof RecoverRequest
     */
    handle: PersonHandle;
    /**
     *
     * @type {RecoverableFactor}
     * @memberof RecoverRequest
     */
    factor: RecoverableFactor;
}
/**
 *
 * @export
 * @interface TokenContainer
 */
interface TokenContainer {
    /**
     *
     * @type {string}
     * @memberof TokenContainer
     */
    aud?: string;
    /**
     *
     * @type {string}
     * @memberof TokenContainer
     */
    id?: string;
    /**
     *
     * @type {number}
     * @memberof TokenContainer
     */
    iat?: number;
    /**
     *
     * @type {number}
     * @memberof TokenContainer
     */
    exp?: number;
    /**
     *
     * @type {number}
     * @memberof TokenContainer
     */
    nbf?: number;
    /**
     *
     * @type {string}
     * @memberof TokenContainer
     */
    iss?: string;
    /**
     *
     * @type {string}
     * @memberof TokenContainer
     */
    sub?: string;
    /**
     *
     * @type {string}
     * @memberof TokenContainer
     */
    user_token: string;
    /**
     *
     * @type {Array<OIDCTokensInfo>}
     * @memberof TokenContainer
     */
    oidc_tokens?: Array<OIDCTokensInfo>;
}
/**
 *
 * @export
 * @interface UserToken
 */
interface _UserToken1 {
    /**
     *
     * @type {string}
     * @memberof UserToken
     */
    aud?: string;
    /**
     *
     * @type {string}
     * @memberof UserToken
     */
    id?: string;
    /**
     *
     * @type {number}
     * @memberof UserToken
     */
    iat?: number;
    /**
     *
     * @type {number}
     * @memberof UserToken
     */
    exp?: number;
    /**
     *
     * @type {number}
     * @memberof UserToken
     */
    nbf?: number;
    /**
     *
     * @type {string}
     * @memberof UserToken
     */
    iss?: string;
    /**
     *
     * @type {string}
     * @memberof UserToken
     */
    sub?: string;
    /**
     *
     * @type {string}
     * @memberof UserToken
     */
    prev_token_id?: string;
    /**
     *
     * @type {string}
     * @memberof UserToken
     */
    oid?: string;
    /**
     * Person ID
     * @type {string}
     * @memberof UserToken
     */
    person_id?: string;
    /**
     *
     * @type {PersonType}
     * @memberof UserToken
     */
    person_type?: PersonType;
    /**
     *
     * @type {boolean}
     * @memberof UserToken
     */
    first_token?: boolean;
    /**
     *
     * @type {Array<Authentication>}
     * @memberof UserToken
     */
    authentications?: Array<Authentication>;
    /**
     *
     * @type {Array<FactorMethod>}
     * @memberof UserToken
     */
    authenticated_methods?: Array<_FactorMethod1>;
    /**
     *
     * @type {string}
     * @memberof UserToken
     */
    groups_claim_name?: string;
    /**
     * The ID of the anonymous person used before the sign-in (if any)
     * @type {string}
     * @memberof UserToken
     */
    prev_anonymous_person_id?: string;
}
interface DeleteAttributesBucketNameRequest {
    bucketName: string;
    slashIDSdkVersion?: string;
    attributes?: Array<string>;
}
interface GetAttributesRequest {
    slashIDSdkVersion?: string;
    buckets?: Array<string>;
}
interface GetAttributesBucketNameRequest {
    bucketName: string;
    slashIDSdkVersion?: string;
    attributes?: Array<string>;
}
interface PatchAttributesRequest {
    body: {
        [key: string]: {
            [key: string]: any;
        };
    };
    slashIDSdkVersion?: string;
}
interface PatchAttributesBucketNameRequest {
    bucketName: string;
    body: {
        [key: string]: any;
    };
    slashIDSdkVersion?: string;
}
interface PutAttributesRequest {
    body: {
        [key: string]: {
            [key: string]: any;
        };
    };
    slashIDSdkVersion?: string;
}
interface PutAttributesBucketNameRequest {
    bucketName: string;
    body: {
        [key: string]: any;
    };
    slashIDSdkVersion?: string;
}
/**
 *
 */
declare class AttributesApi extends runtime.BaseAPI {
    /**
     * Delete attributes from a single bucket
     */
    deleteAttributesBucketNameRaw(requestParameters: DeleteAttributesBucketNameRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<APIResponseBase>>;
    /**
     * Delete attributes from a single bucket
     */
    deleteAttributesBucketName(requestParameters: DeleteAttributesBucketNameRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<APIResponseBase>;
    /**
     * Retrieve attributes from multiple buckets
     */
    getAttributesRaw(requestParameters: GetAttributesRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<GetAttributes200Response>>;
    /**
     * Retrieve attributes from multiple buckets
     */
    getAttributes(requestParameters?: GetAttributesRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<GetAttributes200Response>;
    /**
     * Retrieve attributes from a single bucket
     */
    getAttributesBucketNameRaw(requestParameters: GetAttributesBucketNameRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<GetAttributesBucketName200Response>>;
    /**
     * Retrieve attributes from a single bucket
     */
    getAttributesBucketName(requestParameters: GetAttributesBucketNameRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<GetAttributesBucketName200Response>;
    /**
     * Create new attributes or modify existing attributes for a person in one or more attribute buckets.  Any existing attribute that isn\'t referenced by key in the request is left untouched.
     * Create or modify attributes in multiple buckets
     */
    patchAttributesRaw(requestParameters: PatchAttributesRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<APIResponseBase>>;
    /**
     * Create new attributes or modify existing attributes for a person in one or more attribute buckets.  Any existing attribute that isn\'t referenced by key in the request is left untouched.
     * Create or modify attributes in multiple buckets
     */
    patchAttributes(requestParameters: PatchAttributesRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<APIResponseBase>;
    /**
     * Create new attributes or modify existing attributes for a person in a single bucket.  Any existing attribute that isn\'t referenced by key in the request is left untouched.
     * Create or modify attributes in a single bucket
     */
    patchAttributesBucketNameRaw(requestParameters: PatchAttributesBucketNameRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<APIResponseBase>>;
    /**
     * Create new attributes or modify existing attributes for a person in a single bucket.  Any existing attribute that isn\'t referenced by key in the request is left untouched.
     * Create or modify attributes in a single bucket
     */
    patchAttributesBucketName(requestParameters: PatchAttributesBucketNameRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<APIResponseBase>;
    /**
     * Create new attributes or modify existing attributes for a person in one or more attribute buckets.  Replaces the set of existing attributes with those present in the request. In other words, it deletes any existing attributes that aren\'t referenced by key in the request.
     * Create or modify attributes in multiple buckets
     */
    putAttributesRaw(requestParameters: PutAttributesRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<APIResponseBase>>;
    /**
     * Create new attributes or modify existing attributes for a person in one or more attribute buckets.  Replaces the set of existing attributes with those present in the request. In other words, it deletes any existing attributes that aren\'t referenced by key in the request.
     * Create or modify attributes in multiple buckets
     */
    putAttributes(requestParameters: PutAttributesRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<APIResponseBase>;
    /**
     * Create new attributes or modify existing attributes for a person in a single bucket.  Replaces the set of existing attributes with those present in the request. In other words, it deletes any existing attributes that aren\'t referenced by key in the request.
     * Create or modify attributes in a single bucket
     */
    putAttributesBucketNameRaw(requestParameters: PutAttributesBucketNameRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<APIResponseBase>>;
    /**
     * Create new attributes or modify existing attributes for a person in a single bucket.  Replaces the set of existing attributes with those present in the request. In other words, it deletes any existing attributes that aren\'t referenced by key in the request.
     * Create or modify attributes in a single bucket
     */
    putAttributesBucketName(requestParameters: PutAttributesBucketNameRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<APIResponseBase>;
}
interface GetChallengeChallengeIdRequest {
    challengeId: string;
    slashIDSdkVersion?: string;
}
interface GetChallengeChallengeIdV2Request {
    challengeId: string;
    slashIDSdkVersion?: string;
}
interface GetChallengePackChallengePackIdRequest {
    challengePackId: string;
    slashIDSdkVersion?: string;
}
interface GetTokenRequest {
    slashIDOrgID: string;
    slashIDSdkVersion?: string;
}
interface GetTokenV2Request {
    slashIDOrgID: string;
    slashIDSdkVersion?: string;
}
interface PostAttestationRequest {
    attestation: Attestation;
    slashIDSdkVersion?: string;
}
interface PostAttestationV2Request {
    attestation: Attestation;
    slashIDSdkVersion?: string;
}
interface PostAttestationV3Request {
    attestation: Attestation;
    slashIDSdkVersion?: string;
}
interface PostDirectIdRequest {
    slashIDSdkVersion?: string;
}
interface PostIdRequest {
    slashIDOrgID: string;
    iDRequest: IDRequest;
    slashIDSdkVersion?: string;
}
interface PostIdV2Request {
    slashIDOrgID: string;
    iDRequestV2: IDRequestV2;
    slashIDSdkVersion?: string;
}
interface PostRecoverRequest {
    slashIDOrgID: string;
    recoverRequest: RecoverRequest;
    slashIDSdkVersion?: string;
}
interface PostSsoResolveOperationRequest {
    slashIDOrgID: string;
    postSsoResolveRequest?: PostSsoResolveRequest;
}
interface PostTokenV2Request {
    slashIDOrgID: string;
    postTokenRequestV2: PostTokenRequestV2;
    slashIDSdkVersion?: string;
}
/**
 *
 */
declare class DefaultApi extends runtime.BaseAPI {
    /**
     */
    getChallengeChallengeIdRaw(requestParameters: GetChallengeChallengeIdRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<GetChallengeChallengeId200Response>>;
    /**
     */
    getChallengeChallengeId(requestParameters: GetChallengeChallengeIdRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<GetChallengeChallengeId200Response>;
    /**
     */
    getChallengeChallengeIdV2Raw(requestParameters: GetChallengeChallengeIdV2Request, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<GetChallengeChallengeIdV2200Response>>;
    /**
     */
    getChallengeChallengeIdV2(requestParameters: GetChallengeChallengeIdV2Request, initOverrides?: RequestInit | InitOverrideFunction): Promise<GetChallengeChallengeIdV2200Response>;
    /**
     */
    getChallengePackChallengePackIdRaw(requestParameters: GetChallengePackChallengePackIdRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<PostId200Response>>;
    /**
     */
    getChallengePackChallengePackId(requestParameters: GetChallengePackChallengePackIdRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<PostId200Response>;
    /**
     * Retrieve details of the person and all the organizations they belong to, including:  - The organization of the request: the person must be a member of the organization you authenticate    with for you to be allowed to retrieve this list  - Any other organizations that share the person pool with the organization specified in the request and to which the person also belongs.    A hierarchy of organizations can be created using [this API endpoint](/docs/api/post-organizations-suborganizations).    When organizations are configured to share a person pool, if the same person registers with multiple organizations    in the pool using the same handle, all organizations will see the same person ID for that person.
     * Retrieve the person details and list of organizations
     */
    getMeRaw(initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<GetMe200Response>>;
    /**
     * Retrieve details of the person and all the organizations they belong to, including:  - The organization of the request: the person must be a member of the organization you authenticate    with for you to be allowed to retrieve this list  - Any other organizations that share the person pool with the organization specified in the request and to which the person also belongs.    A hierarchy of organizations can be created using [this API endpoint](/docs/api/post-organizations-suborganizations).    When organizations are configured to share a person pool, if the same person registers with multiple organizations    in the pool using the same handle, all organizations will see the same person ID for that person.
     * Retrieve the person details and list of organizations
     */
    getMe(initOverrides?: RequestInit | InitOverrideFunction): Promise<GetMe200Response>;
    /**
     * Retrieve all the organizations the person belongs to, including:  - The organization of the request: the person must be a member of the organization you authenticate    with for you to be allowed to retrieve this list  - Any other organizations that share the person pool with the organization specified in the request and to which the person also belongs.    A hierarchy of organizations can be created using [this API endpoint](/docs/api/post-organizations-suborganizations).    When organizations are configured to share a person pool, if the same person registers with multiple organizations    in the pool using the same handle, all organizations will see the same person ID for that person.
     * Retrieve the person list of organizations
     */
    getMeOrgsRaw(initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<GetMeOrgs200Response>>;
    /**
     * Retrieve all the organizations the person belongs to, including:  - The organization of the request: the person must be a member of the organization you authenticate    with for you to be allowed to retrieve this list  - Any other organizations that share the person pool with the organization specified in the request and to which the person also belongs.    A hierarchy of organizations can be created using [this API endpoint](/docs/api/post-organizations-suborganizations).    When organizations are configured to share a person pool, if the same person registers with multiple organizations    in the pool using the same handle, all organizations will see the same person ID for that person.
     * Retrieve the person list of organizations
     */
    getMeOrgs(initOverrides?: RequestInit | InitOverrideFunction): Promise<GetMeOrgs200Response>;
    /**
     * Given a token for a Person in an Organization, return a new token for the same user in the Organization specified in the SlashID-OrgID request header. For the call to succeed the following conditions must be met: - the token must be valid at the time of the request - the two Organizations must share the same person pool - the user must be a member of both Organizations This operation does not count as an authentication, so the new token will have the same expiration time as the original.
     * Get a new token for the specified Organization ID
     */
    getTokenRaw(requestParameters: GetTokenRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<GetChallengeChallengeIdV2200Response>>;
    /**
     * Given a token for a Person in an Organization, return a new token for the same user in the Organization specified in the SlashID-OrgID request header. For the call to succeed the following conditions must be met: - the token must be valid at the time of the request - the two Organizations must share the same person pool - the user must be a member of both Organizations This operation does not count as an authentication, so the new token will have the same expiration time as the original.
     * Get a new token for the specified Organization ID
     */
    getToken(requestParameters: GetTokenRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<GetChallengeChallengeIdV2200Response>;
    /**
     * Given a token for a Person in an Organization: return a new token for the same user in the Organization specified in the SlashID-OrgID request header OR return a list of challenges that need to be resolved in order to obtain the token.  For the call to succeed the following conditions must be met: - the token must be valid at the time of the request - the two Organizations must share the same person pool - the user must be a member of both Organizations This operation does not count as an authentication, so the new token will have the same expiration time as the original.
     * Get a new token for the specified Organization ID
     */
    getTokenV2Raw(requestParameters: GetTokenV2Request, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<GetTokenV2200Response>>;
    /**
     * Given a token for a Person in an Organization: return a new token for the same user in the Organization specified in the SlashID-OrgID request header OR return a list of challenges that need to be resolved in order to obtain the token.  For the call to succeed the following conditions must be met: - the token must be valid at the time of the request - the two Organizations must share the same person pool - the user must be a member of both Organizations This operation does not count as an authentication, so the new token will have the same expiration time as the original.
     * Get a new token for the specified Organization ID
     */
    getTokenV2(requestParameters: GetTokenV2Request, initOverrides?: RequestInit | InitOverrideFunction): Promise<GetTokenV2200Response>;
    /**
     */
    postAttestationRaw(requestParameters: PostAttestationRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<GetChallengeChallengeId200Response>>;
    /**
     */
    postAttestation(requestParameters: PostAttestationRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<GetChallengeChallengeId200Response>;
    /**
     */
    postAttestationV2Raw(requestParameters: PostAttestationV2Request, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<GetChallengeChallengeIdV2200Response>>;
    /**
     */
    postAttestationV2(requestParameters: PostAttestationV2Request, initOverrides?: RequestInit | InitOverrideFunction): Promise<GetChallengeChallengeIdV2200Response>;
    /**
     */
    postAttestationV3Raw(requestParameters: PostAttestationV3Request, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<PostAttestationV3200Response>>;
    /**
     */
    postAttestationV3(requestParameters: PostAttestationV3Request, initOverrides?: RequestInit | InitOverrideFunction): Promise<PostAttestationV3200Response>;
    /**
     */
    postDirectIdRaw(requestParameters: PostDirectIdRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<PostDirectId201Response>>;
    /**
     */
    postDirectId(requestParameters?: PostDirectIdRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<PostDirectId201Response>;
    /**
     */
    postIdRaw(requestParameters: PostIdRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<PostId200Response>>;
    /**
     */
    postId(requestParameters: PostIdRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<PostId200Response>;
    /**
     */
    postIdV2Raw(requestParameters: PostIdV2Request, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<PostId200Response>>;
    /**
     */
    postIdV2(requestParameters: PostIdV2Request, initOverrides?: RequestInit | InitOverrideFunction): Promise<PostId200Response>;
    /**
     */
    postRecoverRaw(requestParameters: PostRecoverRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<PostId200Response>>;
    /**
     */
    postRecover(requestParameters: PostRecoverRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<PostId200Response>;
    /**
     * Resolve endpoint for SSO flows using PKCE.
     * SSO resolve challenge endpoint
     */
    postSsoResolveRaw(requestParameters: PostSsoResolveOperationRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<void>>;
    /**
     * Resolve endpoint for SSO flows using PKCE.
     * SSO resolve challenge endpoint
     */
    postSsoResolve(requestParameters: PostSsoResolveOperationRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<void>;
    /**
     * Given a token for a Person in an Organization: return a new token for the same user in the Organization specified in the SlashID-OrgID request header OR return a list of challenges that need to be resolved in order to obtain the token.  For the call to succeed the following conditions must be met: - the token must be valid at the time of the request - the two Organizations must share the same person pool - the user must be a member of both Organizations This operation does not count as an authentication, so the new token will have the same expiration time as the original.
     * Get a new token for the specified Organization ID
     */
    postTokenV2Raw(requestParameters: PostTokenV2Request, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<GetTokenV2200Response>>;
    /**
     * Given a token for a Person in an Organization: return a new token for the same user in the Organization specified in the SlashID-OrgID request header OR return a list of challenges that need to be resolved in order to obtain the token.  For the call to succeed the following conditions must be met: - the token must be valid at the time of the request - the two Organizations must share the same person pool - the user must be a member of both Organizations This operation does not count as an authentication, so the new token will have the same expiration time as the original.
     * Get a new token for the specified Organization ID
     */
    postTokenV2(requestParameters: PostTokenV2Request, initOverrides?: RequestInit | InitOverrideFunction): Promise<GetTokenV2200Response>;
}
interface PostActionsSdkRequest {
    eventPostRequest: EventPostRequest;
}
interface PostEventsRequest {
    eventPostRequest: EventPostRequest;
}
/**
 *
 */
declare class EventsApi extends runtime.BaseAPI {
    /**
     * Post information that can used to build and publish an event originating from the SlashID SDK
     * Publish an event from the SDK
     */
    postActionsSdkRaw(requestParameters: PostActionsSdkRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<void>>;
    /**
     * Post information that can used to build and publish an event originating from the SlashID SDK
     * Publish an event from the SDK
     */
    postActionsSdk(requestParameters: PostActionsSdkRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<void>;
    /**
     * Post information that can used to build and publish an event. Deprecated, use `/actions`.
     * Publish an event
     */
    postEventsRaw(requestParameters: PostEventsRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<void>>;
    /**
     * Post information that can used to build and publish an event. Deprecated, use `/actions`.
     * Publish an event
     */
    postEvents(requestParameters: PostEventsRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<void>;
}
interface DeleteConsentGdprRequest {
    slashIDSdkVersion?: string;
    consentLevels?: Array<GDPRConsentLevel>;
    deleteAll?: boolean;
}
interface PostPersonsAnonymousRequest {
    slashIDOrgID: string;
    anonymousPersonCreateReq: AnonymousPersonCreateReq;
    slashIDSdkVersion?: string;
}
interface PostPersonsPersonIdImpersonateRequest {
    personId: string;
    slashIDOrgID: string;
}
interface PostPersonsPersonIdImpersonateV2OperationRequest {
    personId: string;
    slashIDOrgID: string;
    postPersonsPersonIdImpersonateV2Request?: PostPersonsPersonIdImpersonateV2Request;
}
/**
 *
 */
declare class PersonsApi extends runtime.BaseAPI {
    /**
     * Create a new anonymous person linked to your organization. Unlike regular persons, anonymous persons\' identities are unknown and they do not have any authentication methods. However, it is still possible to persist information associated with this user, including attributes and GDPR consent. Anonymous persons can be created when a user first enters your website or application. If the person eventually signs up, the person type is upgraded to regular. Anonymous persons are inherently temporary and will be deleted after 30 days. Anonymous persons do not count towards billing and account limits, but their creation is rate-limited based on the organization\'s pricing tier.
     * Create new anonymous person
     */
    postPersonsAnonymousRaw(requestParameters: PostPersonsAnonymousRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<PostPersonsAnonymous201Response>>;
    /**
     * Create a new anonymous person linked to your organization. Unlike regular persons, anonymous persons\' identities are unknown and they do not have any authentication methods. However, it is still possible to persist information associated with this user, including attributes and GDPR consent. Anonymous persons can be created when a user first enters your website or application. If the person eventually signs up, the person type is upgraded to regular. Anonymous persons are inherently temporary and will be deleted after 30 days. Anonymous persons do not count towards billing and account limits, but their creation is rate-limited based on the organization\'s pricing tier.
     * Create new anonymous person
     */
    postPersonsAnonymous(requestParameters: PostPersonsAnonymousRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<PostPersonsAnonymous201Response>;
    /**
     * This endpoint creates a one-time token to impersonate a specific person. The returned token string must embedded in a URL in the `challenges` query parameter to let you land on a target page already authenticated as the desired person.
     * Impersonate another person
     */
    postPersonsPersonIdImpersonateRaw(requestParameters: PostPersonsPersonIdImpersonateRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<PostPersonsPersonIdImpersonate201Response>>;
    /**
     * This endpoint creates a one-time token to impersonate a specific person. The returned token string must embedded in a URL in the `challenges` query parameter to let you land on a target page already authenticated as the desired person.
     * Impersonate another person
     */
    postPersonsPersonIdImpersonate(requestParameters: PostPersonsPersonIdImpersonateRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<PostPersonsPersonIdImpersonate201Response>;
    /**
     * This endpoint creates a one-time token to impersonate a specific person. The returned token string must embedded in a URL in the `challenges` query parameter to let you land on a target page already authenticated as the desired person.
     * Impersonate another person
     */
    postPersonsPersonIdImpersonateV2Raw(requestParameters: PostPersonsPersonIdImpersonateV2OperationRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<ApiResponse<PostPersonsPersonIdImpersonate201Response>>;
    /**
     * This endpoint creates a one-time token to impersonate a specific person. The returned token string must embedded in a URL in the `challenges` query parameter to let you land on a target page already authenticated as the desired person.
     * Impersonate another person
     */
    postPersonsPersonIdImpersonateV2(requestParameters: PostPersonsPersonIdImpersonateV2OperationRequest, initOverrides?: RequestInit | InitOverrideFunction): Promise<PostPersonsPersonIdImpersonate201Response>;
}
type FactorMethodValues = `${Exclude<FactorMethod, "api" | "anonymous" | "direct_id" | "impersonate">}`;
declare class FactorMethodOptionsTypeMap implements Record<FactorMethodValues, any> {
    "webauthn": WebAuthnMethodOptions;
    "oidc": OIDCMethodOptions;
    "saml": SAMLMethodOptions;
    "password": never;
    "otp_via_sms": OTPMethodOptions | undefined;
    "otp_via_email": OTPMethodOptions | undefined;
    "totp": _TOTPMethodOptions1 | undefined;
    "email_link": never;
    "sms_link": never;
}
type FactorTypeHelper<T> = {
    [K in keyof T]: {
        method: K;
        options?: Omit<T[K], "method">;
    };
};
export type FactorMethod = keyof FactorMethodOptionsTypeMap;
export type Factor = FactorTypeHelper<FactorMethodOptionsTypeMap>[keyof FactorTypeHelper<FactorMethodOptionsTypeMap>];
type UserTokenText = string;
type TokenContainerText = string;
type OrganizationID = string;
type JsonObject = {
    [Key in string]: JsonValue;
} & {
    [Key in string]?: JsonValue | undefined;
};
type JsonArray = JsonValue[] | readonly JsonValue[];
type JsonPrimitive = string | number | boolean | null;
type JsonValue = JsonPrimitive | JsonObject | JsonArray;
/**
 * SlashID production environment name. Uses the following default values:
 *
 * const baseURL = "https://api.slashid.com"
 * const sdkURL = "https://cdn.slashid.com/sdk.html"
 */
type ProductionEnvironment = "production";
/**
 * SlashID sandbox environment name. Uses the following default values:
 *
 * const baseURL = "https://api.sandbox.slashid.com"
 * const sdkURL = "https://cdn.sandbox.slashid.com/sdk.html"
 */
type SandboxEnvironment = "sandbox";
/**
 * SlashID custom environment name. Values must be provided for baseURL and sdkURL.
 */
type CustomEnvironment = {
    baseURL: string;
    sdkURL: string;
};
type SlashIDEnvironment = ProductionEnvironment | SandboxEnvironment | CustomEnvironment;
type UICustomization = {
    [key: string]: any;
};
export type ReachablePersonHandle = PersonHandle & {
    type: "email_address" | "phone_number";
};
export type ReachablePersonHandleType = ReachablePersonHandle["type"];
declare function isReachablePersonHandleType(handleType: PersonHandleType): handleType is ReachablePersonHandleType;
type RegexValidationRule = {
    type: "regex";
    name: RegexPasswordValidationRule["name"];
    regexp: RegExp;
    matchType: RegexPasswordValidationRule["match_type"];
};
type ValidationRule = RegexValidationRule;
declare const DefaultBucketName: {
    readonly end_user_read_write: "end_user_read_write";
    readonly end_user_read_only: "end_user_read_only";
    readonly end_user_no_access: "end_user_no_access";
    readonly "person_pool-end_user_read_write": "person_pool-end_user_read_write";
    readonly "person_pool-end_user_read_only": "person_pool-end_user_read_only";
    readonly "person_pool-end_user_no_access": "person_pool-end_user_no_access";
};
type BucketName = keyof typeof DefaultBucketName | string;
type BucketOptions = {
    user: BaseUser;
    bucketName: BucketName;
};
/**
 *  An object that allows you to access and modify the attributes stored within the named bucket.
 *  The easiest way to create a bucket is by using the {@link Types.BaseUser.getBucket} method and passing in the bucket name.
 */
declare class Bucket {
    constructor({ user, bucketName }: BucketOptions);
    /**
     * Retrieve attributes for a person from the bucket
     *
     * @param attributeNames You can optionally filter which attributes to retrieve by supplying a list of attribute names. If you don't the method returns all attributes.
     *
     * @returns A map from `string` to basic types containing user data previously associated with {@link set}.
     * @throws `Error` if the operation fails.
     */
    get<AttributesType extends JsonObject>(attributeNames?: string[]): Promise<AttributesType>;
    /**
     * Set attributes for a person in the bucket
     *
     * @param attributes A serializable object to associate with the user credential.
     * @throws `Error` if the operation fails.
     */
    set<AttributesType extends JsonObject>(attributes: AttributesType): Promise<void>;
    /**
     * Delete person attributes from the bucket
     *
     * @param attributeNames You must specify which data attributes to delete by supplying a list of filter strings.
     * @throws `Error` if the operation fails.
     */
    delete(attributeNames: string[]): Promise<any>;
}
interface CreateAnonymousUserOptions {
    environment: SlashIDOptions["environment"];
    oid: string;
}
export const createAnonymousUserToken: ({ environment, oid }: CreateAnonymousUserOptions) => Promise<string>;
export type UserToken = UserToken & Partial<JsonObject>;
type GDPRConsentLevels = {
    consentLevels: GDPRConsentLevel[];
};
/**
 * Objects of this type represent an authenticated user. If you have a token you can instantiate your own User.
 * This class is server side rendering (SSR) friendly as it only uses the fetch API with no other dependencies on browser APIs.
 *
 * A User object gives you access to methods to:
 *
 *  - access or associate arbitrary private data to the user: please see the {@link getBucket} method;
 *    your backend will also be able to retrieve the data associated with your user by invoking the related SlashID User Management API {@link https://developer.slashid.dev/docs/api/get-persons-person-id-attributes-bucket-name/};
 *  - contextual user attributes as detailed in the _Accessors_ section below;
 *
 * @remarks User objects are safe for serialization, you can pass them to other contexts with the `postMessage` family of functions.
 *
 */
declare class BaseUser {
    protected _apiClient: DefaultApi;
    protected _token: string | undefined;
    static createAnonymousUser(options: SlashIDOptions): Promise<BaseUser>;
    /**
     * Reconstruct an authenticated user from its token value.
     *
     * @param token A user {@link token} value.
     * @param optionsOrSid SlashID instance or SlashID connection options. It is preferred to pass in the SlashID instance
     *
     * @throws `TypeError` If the given `optionsOrSid`, if defined, fail validation, or
     * the given token cannot be decoded.
     */
    constructor(token: UserTokenText | TokenContainerText, options?: SlashIDOptions);
    /**
     * Use a new token to update the internal state of the user. Same set of options is reused.
     */
    protected updateToken(token: UserTokenText): void;
    protected get decoded(): UserToken;
    /**
     * The claims of the user token.
     * @returns {UserToken}
     */
    get tokenClaims(): UserToken;
    protected get decodedTokenContainer(): TokenContainer | undefined;
    /**
     * If the user instance is created with a {@link Types.TokenContainer} this will return the claims of the token container.
     * Otherwise it will return undefined.
     * @returns {api.TokenContainer | undefined}
     */
    get tokenContainerClaims(): TokenContainer | undefined;
    protected updateClient(token?: UserTokenText): void;
    /**
     * Initializes every client with new Configuration based on currently stored
     * _clientOptions and _token.
     */
    protected initializeClients(): void;
    /**
     * This user's ID. Use this property in your backend services when interacting with the [SlashID User Management API](https://developer.slashid.dev/docs/category/api/persons).
     */
    get ID(): string;
    /**
     * The entire, signed authentication token of this user.
     */
    get token(): string;
    /**
     * The entire token container
     * @returns either the token container string or an empty string
     */
    get tokenContainer(): string;
    /**
     * The organization ID this user belongs to.
     */
    get oid(): string;
    /**
     * Indicates whether the user has been just registered, otherwise it's a returning user.
     */
    get firstLogin(): boolean;
    /**
     * Indicates which authentication methods the user has been verified with. It can contain multiple items in case of multi factor authentication.
     */
    get authentication(): FactorMethod[];
    /**
     * Indicates which authentication methods the user has been verified with, including the handles used for each method.
     */
    get authentications(): Authentication[];
    /**
     * Indicates if the user is an anonymous user
     */
    get anonymous(): boolean;
    /**
     * Indicates if the user is authenticated
     *
     * For anonymous users this will return `false`
     */
    isAuthenticated(): Promise<boolean>;
    /**
     * Create a DirectID based on your token
     * @returns directID token
     */
    createDirectID(): Promise<string | undefined>;
    /**
     * Log out of the current session. Clears the SlashID token.
     * Will attempt revoking the token server-side.
     */
    logout(): Promise<void>;
    /**
     * Resolves to a token validity info object which tells if the token is genuine and if it has expired yet.
     * @returns {Promise} Token validity info
     */
    validateToken(): Promise<ValidateTokenResponse>;
    /**
     * Get an array of group names that the user belongs to.
     */
    getGroups(): string[];
    /**
     * Exposes the attributes client so the Bucket instance can access it
     */
    getAttributesClient(): AttributesApi;
    /**
     *  Creates a {@link Types.Bucket} object used to access attributes.
     *
     * @param bucketName name of the bucket we want to access - uses "end_user_read_write" as default.
     * You can pass in any string that corresponds to a name of a bucket set up for your organization.
     * You can use any of the preset bucket names with corresponding permissions and scopes - {@link Types.DefaultBucketName}.
     * @returns
     */
    getBucket(bucketName?: BucketName): Bucket;
    /**
     * @deprecated Use {@link getBucket} instead.
     */
    get<AttributesType extends JsonObject>(attributeNames?: string[]): Promise<AttributesType>;
    /**
     * @deprecated Use {@link getBucket} instead.
     */
    set<AttributesType extends JsonObject>(attributes: AttributesType): Promise<void>;
    /**
     * @deprecated Use {@link getBucket} instead.
     */
    delete(attributeNames: string[]): Promise<any>;
    /**
     * Fetch the GDPR consent levels for the current user.
     * @returns {Promise} GDPR consent info
     */
    getGDPRConsent(): Promise<GDPRConsentResponse>;
    /**
     * Set the GDPR consent levels for the current user.
     * This will overwrite any existing consent levels and set the consent levels to only the ones included with the request.
     *
     * @param {api.GDPRConsentRequest} request with consentLevels to set
     * @returns {Promise} GDPR consent info
     */
    setGDPRConsent({ consentLevels }: GDPRConsentLevels): Promise<GDPRConsentResponse>;
    /**
     * Add the GDPR consent levels to the current user.
     * Consent levels not included in the request will not be changed.
     *
     * @param {api.GDPRConsentRequest} request with consent levels to add
     * @returns {Promise} GDPR consent info
     */
    addGDPRConsent({ consentLevels }: GDPRConsentLevels): Promise<GDPRConsentResponse>;
    /**
     * Remove the GDPR consent levels from the current user.
     * Consent levels not included in the request will not be changed.
     *
     * @param {api.ConsentGdprDeleteRequest} request with consentLevels to remove
     */
    removeGDPRConsent({ consentLevels }: DeleteConsentGdprRequest): Promise<void>;
    /**
     * Remove all stored GDPR consent levels from the current user.
     * Consent levels not included in the request will not be changed, unless deleteAll flag is set to true.
     */
    removeGDPRConsentAll(): Promise<void>;
    /**
     * Get the organizations the user belongs to.
     * @returns {Promise} A list of organizations the user belongs to
     */
    getOrganizations(): Promise<OrganizationDetails[]>;
    /**
     * Fetch all the handles associated with this user from the SlashID API.
     * @returns {Promise} A list of handles available for the user
     */
    getHandles(): Promise<PersonHandle[]>;
    /**
     * Given an organization ID, get a new token for the same user in the Organization specified by the Organization ID.
     *
     * For the call to succeed the following conditions must be met:
     * - the token must be valid at the time of the request
     * - the two Organizations must share the same person pool
     * - the user must be a member of both Organizations
     *
     * This operation does not count as an authentication, so the new token will have the same expiration time as the original.
     * @param oid
     * @returns {Promise} A new token for the specified Organization ID
     */
    getTokenForOrganization(oid: string): Promise<UserTokenText | TokenContainerText>;
    /**
     * User objects stringify to their token value for convenience:
     *
     * @example
     * ```js
     * user.toString() === "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoiSm9obiBTbWl0aCIsImlhdCI6MTUxNjIzOTAyMn0.dzKuKf6u9G7Crk9tsFnS2cey1zglWTFQv_hjWjmtXms"
     * ```
     */
    toString(): string;
    /**
     * User objects encode to JSON as a string containing their token value.
     *
     * @example
     * ```js
     * JSON.stringify(user) === "\"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoiSm9obiBTbWl0aCIsImlhdCI6MTUxNjIzOTAyMn0.dzKuKf6u9G7Crk9tsFnS2cey1zglWTFQv_hjWjmtXms\""
     * ```
     */
    toJSON(): string;
}
type BaseEvent = {
    readonly name: string;
};
type EventMeta = {
    authFlowId?: string | undefined;
    recoveryFlowId?: string | undefined;
    access: "private" | "public";
};
type EventHandler<T extends BaseEvent> = (event: T) => void;
type _Middleware1<T extends BaseEvent> = (event: T, cancel: () => void) => T | void;
interface EventEmitter<EventT extends BaseEvent> {
    on(eventName: EventT["name"], handler: EventHandler<EventT>): void;
    off(eventName: EventT["name"], handler: EventHandler<EventT>): void;
    emit(event: EventT): void;
    use(middleware: _Middleware1<EventT>): void;
}
/**
 * This event is emitted once the OTP code is sent via SMS.
 *
 * @deprecated please use OtpCodeSentEvent instead.
 */
type OtpSmsSentEvent = void;
/**
 * This event is emitted once the OTP code is sent.
 */
type OtpCodeSentEvent = void;
/**
 * This event is emitted once the SDK is ready to register new TOTP credential.
 */
type TotpKeyGenerated = {
    uri: string;
    qrCode: string;
    recoveryCodes: string[];
};
/**
 * This event is emitted once the SDK is ready to verify a TOTP code.
 */
type TotpCodeRequested = void;
declare const OAuthFailureReason: {
    readonly PopupBlocked: "Popup blocked";
    readonly BadOAuthURL: "Bad OAuth sign in URL";
};
declare const PopupFailureReason: {
    readonly PopupBlocked: "Popup blocked";
    readonly BadAuthURL: "Bad authentication URL";
};
/**
 * This event is emitted once the SDK is ready to accept a new password. It means the handle has been verified.
 */
type PasswordSetReadyEvent = void;
/**
 * This event is emitted once the SDK is ready to verify an existing password.
 */
type PasswordVerifyReadyEvent = void;
/**
 * This event is emitted once the SDK is ready to accept a new password as part of the password recovery flow.
 */
type PasswordResetReadyEvent = void;
/**
 * This event needs to be emitted when the end user enters their password.
 */
type PasswordSubmittedEvent = string;
/**
 * This events can be emitted while the flow is processing the challenges to cancel it.
 */
type FlowCancelled = void;
/**
 * This event is emitted once the OAuth flow in the popup UX mode was started
 */
type OAuthFlowStartedEvent = Omit<OIDCMethodOptions, "method">;
/**
 * This event is emitted when the OAuthFlow fails with the specified reason
 */
type OAuthFlowFailedEvent = Omit<OIDCMethodOptions, "method"> & {
    reason: (typeof OAuthFailureReason)[keyof typeof OAuthFailureReason];
};
/**
 * This event is emitted if the submitted OTP code is incorrect.
 */
type OtpIncorrectCodeSubmittedEvent = {
    factor: Factor;
    challengeId: string;
};
/**
 * This event should be emitted when the end user enters the OTP code they received.
 * Event payload is a string containing the OTP code.
 */
type OtpCodeSubmittedEvent = string;
/**
 * This event is emitted when the submitted password does not meet the validation rules.
 */
type InvalidPasswordSubmittedEvent = FlowErrorMetadata & {
    failedRules: ValidationRule[];
};
/**
 * This event is emitted when the submitted password does not match the password stored for the given handle.
 */
type IncorrectPasswordSubmittedEvent = FlowErrorMetadata;
type UserAuthenticatedFromURLEvent = {
    token: string;
};
type PersonIdentifiedEvent = {
    user: BaseUser;
};
type PersonLoggedOutEvent = {
    token: UserTokenText;
};
/**
 * This event is emitted when the .id method resolves successfully.
 */
type IdFlowSucceededEvent = {
    token: UserTokenText;
    handle?: PersonHandle;
    authenticationFactor?: Factor;
};
type IdFlowStartedEvent = {
    authenticationFactor?: Factor;
};
type RecoveryFlowStartedEvent = {
    handle: PersonHandle;
    authenticationFactor: Factor;
};
type RecoveryFlowSucceededEvent = {
    handle: PersonHandle;
    authenticationFactor: Factor;
};
type FlowErrorMetadata = {
    authenticationFactor?: Factor;
    handle?: PersonHandle;
    previousToken?: string;
    challengeId?: string;
    failureDetail?: string;
};
type IdFlowFailedEvent = FlowErrorMetadata & {
    errorText: ClientGeneratedErrorSlug;
};
type RecoveryFlowFailedEvent = FlowErrorMetadata & {
    errorText: ClientGeneratedErrorSlug;
};
/**
 * An unexpected client side error occurred within the SDK, potentially interrupting authentication.
 */
type ClientSideErrorEvent = FlowErrorMetadata & {
    errorText: "client_side_error";
};
type WebAuthnChallengeProcessed = {
    credentialId: string;
};
type RedirectUriDiscoveredEvent = {
    redirectUri: string;
};
type UICustomizationReceivedEvent = {
    customizationProperties: UICustomization;
};
type AuthnContextUpdateChallengeReceivedEvent = {
    targetOrgId: string;
    factor?: _Factor1;
};
type PublicReadEvents = {
    otpCodeSent: OtpCodeSentEvent;
    otpSmsSent: OtpSmsSentEvent;
    totpKeyGenerated: TotpKeyGenerated;
    totpCodeRequested: TotpCodeRequested;
    otpIncorrectCodeSubmitted: OtpIncorrectCodeSubmittedEvent;
    passwordSetReady: PasswordSetReadyEvent;
    passwordVerifyReady: PasswordVerifyReadyEvent;
    passwordResetReady: PasswordResetReadyEvent;
    invalidPasswordSubmitted: InvalidPasswordSubmittedEvent;
    incorrectPasswordSubmitted: IncorrectPasswordSubmittedEvent;
    oauthFlowStarted: OAuthFlowStartedEvent;
    oauthFlowFailed: OAuthFlowFailedEvent;
    userAuthenticatedFromURL: UserAuthenticatedFromURLEvent;
    idFlowSucceeded: IdFlowSucceededEvent;
    idFlowStarted: IdFlowStartedEvent;
    idFlowFailed: IdFlowFailedEvent;
    recoveryFlowStarted: RecoveryFlowStartedEvent;
    recoveryFlowSucceeded: RecoveryFlowSucceededEvent;
    recoveryFlowFailed: RecoveryFlowFailedEvent;
    webAuthnChallengeProcessed: WebAuthnChallengeProcessed;
    redirectUriDiscovered: RedirectUriDiscoveredEvent;
    uiCustomizationReceived: UICustomizationReceivedEvent;
    authnContextUpdateChallengeReceivedEvent: AuthnContextUpdateChallengeReceivedEvent;
};
type PublicWriteEvents = {
    otpCodeSubmitted: OtpCodeSubmittedEvent;
    passwordSubmitted: PasswordSubmittedEvent;
    flowCancelled: FlowCancelled;
};
/**
 * We don't differentiate between read and write here
 * because there is no clear API boundary for private
 * events.
 *
 * This event can be fired by any internal slashid source, and
 * may be listened to by any internal slashid source. There is
 * no concept of "them" and "us" here.
 *
 * The source is never a third party.
 */
type PrivateEvents = {
    clientSideError: ClientSideErrorEvent;
};
export type PublicReadEventsKeys = Array<keyof PublicReadEvents>;
export type PublicWriteEventsKeys = Array<keyof PublicWriteEvents>;
type Events = PublicReadEvents & PublicWriteEvents;
/**
 * This event is emitted when the Popup UX mode fails with the specified reason
 */
type PopupFailedEvent = {
    reason: (typeof PopupFailureReason)[keyof typeof PopupFailureReason];
};
type InternalEvents = {
    popupFailed: PopupFailedEvent;
};
type Handler<T = unknown> = (event: T) => void;
type NamesToEventsMap = Events & InternalEvents & PrivateEvents;
type EventsWithNamesMap = {
    [K in keyof NamesToEventsMap]: {
        name: K;
        payload: NamesToEventsMap[K];
        meta?: EventMeta;
    };
};
type NamedEvents = EventsWithNamesMap[keyof EventsWithNamesMap];
interface SerialisedResponseError {
    status: Response["status"];
    statusText: Response["statusText"];
    url: Response["url"];
    type: Response["type"];
    ok: Response["ok"];
    redirected: Response["redirected"];
    headers: Record<string, string>;
    body: Awaited<ReturnType<Response["json"]>>;
}
declare const CLIENT_GENERATED_ERROR_SLUGS: readonly ["incorrect_otp_code_via_email", "incorrect_otp_code_via_sms", "incorrect_otp_code", "invalid_password", "incorrect_password", "recovery_failed", "oidc_popup_blocked", "client_side_error", "unspecified", "no_password_set", "flow_cancelled", "handle_pattern_not_allowed", "sign_up_awaiting_approval", "sign_in_awaiting_approval", "self_registration_not_allowed", "recover_non_reachable_handle_type", "timeout", "rate_limit_exceeded", "passkey_bad_scope", "passkey_prompt_failed", "api_response_error", "invalid_slashid_configuration", "invalid_slashid_url_params", "invalid_authentication_method", "invalid_action", "invalid_email_address_format", "invalid_phone_number_format", "unreachable_phone_number", "person_exists"];
type ClientGeneratedErrorSlug = (typeof CLIENT_GENERATED_ERROR_SLUGS)[number];
type SlashIDErrorContext = Record<string, any> & {
    response?: SerialisedResponseError;
};
type SlashIDInternalErrorInput = {
    name: ErrorName;
    message: string;
    context?: SlashIDErrorContext;
    cause?: Error;
};
declare class _SlashIDError1 extends Error {
    name: ErrorName;
    context: SlashIDErrorContext;
    constructor({ name, message, context, cause, }: SlashIDInternalErrorInput);
}
declare const ERROR_NAMES: {
    readonly noPasswordSet: "noPasswordSet";
    readonly unknown: "UnexpectedError";
    readonly flowCancelled: "FlowCancelledError";
    readonly handlePatternNotAllowed: "HandlePatternNotAllowedError";
    readonly signUpAwaitingApproval: "SignUpAwaitingApprovalError";
    readonly signInAwaitingApproval: "SignInAwaitingApprovalError";
    readonly selfRegistrationNotAllowed: "SelfRegistrationNotAllowed";
    readonly recoverNonReachableHandleType: "recoverNonReachableHandleType";
    readonly timeoutError: "TimeoutError";
    readonly rateLimitError: "RateLimitError";
    readonly badPasskeyScopeError: "BadPasskeyScopeError";
    readonly passkeyPromptError: "PasskeyPromptError";
    readonly apiResponseError: "APIResponseError";
    readonly invalidSlashIDConfigurationError: "InvalidSlashIDConfigurationError";
    readonly invalidSlashIDURLParamsError: "InvalidSlashIDURLParamsError";
    readonly invalidAuthenticationMethodError: "InvalidAuthenticationMethodError";
    readonly invalidActionError: "InvalidActionError";
    readonly invalidEmailAddressFormatError: "InvalidEmailAddressFormatError";
    readonly invalidPhoneNumberFormatError: "InvalidPhoneNumberFormatError";
    readonly unreachablePhoneNumberError: "UnreachablePhoneNumberError";
    readonly personExistsError: "PersonExistsError";
};
type ErrorName = (typeof ERROR_NAMES)[keyof typeof ERROR_NAMES];
export type FlowCancelledError = _SlashIDError1 & {
    name: typeof ERROR_NAMES.flowCancelled;
    context: {
        challenge: ProxyChallenge;
    };
};
export type HandlePatternNotAllowedError = _SlashIDError1 & {
    name: typeof ERROR_NAMES.handlePatternNotAllowed;
};
export type SignUpAwaitingApprovalError = _SlashIDError1 & {
    name: typeof ERROR_NAMES.signUpAwaitingApproval;
};
export type SignInAwaitingApprovalError = _SlashIDError1 & {
    name: typeof ERROR_NAMES.signInAwaitingApproval;
};
export type SelfRegistrationNotAllowedError = _SlashIDError1 & {
    name: typeof ERROR_NAMES.selfRegistrationNotAllowed;
};
export type NoPasswordSetError = _SlashIDError1 & {
    name: typeof ERROR_NAMES.noPasswordSet;
};
export type NonReachableHandleTypeError = _SlashIDError1 & {
    name: typeof ERROR_NAMES.recoverNonReachableHandleType;
};
export type TimeoutError = _SlashIDError1 & {
    name: typeof ERROR_NAMES.timeoutError;
};
export type RateLimitError = _SlashIDError1 & {
    name: typeof ERROR_NAMES.rateLimitError;
};
export type BadPasskeyScopeError = _SlashIDError1 & {
    name: typeof ERROR_NAMES.badPasskeyScopeError;
};
export type PasskeyPromptError = _SlashIDError1 & {
    name: typeof ERROR_NAMES.passkeyPromptError;
};
export type APIResponseError = _SlashIDError1 & {
    name: typeof ERROR_NAMES.apiResponseError;
    context: {
        response: SerialisedResponseError;
        correlationId: string;
    };
};
export type InvalidSlashIDConfigurationError = _SlashIDError1 & {
    name: typeof ERROR_NAMES.invalidSlashIDConfigurationError;
};
export type InvalidURLParamsError = _SlashIDError1 & {
    name: typeof ERROR_NAMES.invalidSlashIDURLParamsError;
};
export type InvalidAuthenticationMethodError = _SlashIDError1 & {
    name: typeof ERROR_NAMES.invalidAuthenticationMethodError;
};
export type InvalidActionError = _SlashIDError1 & {
    name: typeof ERROR_NAMES.invalidActionError;
};
export type PersonExistsError = _SlashIDError1 & {
    name: typeof ERROR_NAMES.personExistsError;
};
export type InvalidEmailAddressFormatError = _SlashIDError1 & {
    name: typeof ERROR_NAMES.invalidEmailAddressFormatError;
};
export type InvalidPhoneNumberFormatError = _SlashIDError1 & {
    name: typeof ERROR_NAMES.invalidPhoneNumberFormatError;
};
type UnreachablePhoneNumberError = _SlashIDError1 & {
    name: typeof ERROR_NAMES.unreachablePhoneNumberError;
};
export type UnexpectedError = _SlashIDError1 & {
    name: typeof ERROR_NAMES.unknown;
};
export type SlashIDError = FlowCancelledError | SelfRegistrationNotAllowedError | NoPasswordSetError | NonReachableHandleTypeError | HandlePatternNotAllowedError | SignUpAwaitingApprovalError | SignInAwaitingApprovalError | TimeoutError | RateLimitError | BadPasskeyScopeError | InvalidSlashIDConfigurationError | InvalidURLParamsError | InvalidAuthenticationMethodError | PasskeyPromptError | InvalidActionError | PersonExistsError | InvalidEmailAddressFormatError | InvalidPhoneNumberFormatError | UnreachablePhoneNumberError | APIResponseError | UnexpectedError;
type SlashIDErrorInput = SlashIDInternalErrorInput & {
    name: SlashIDError["name"];
};
/**
 * This class simply holds connection options for your SlashID organization, to be passed to the
 * {@link SlashID} constructor.
 *
 * By default, the SDK will connect to the production environment and use the default SDK location:
 * ```js
 * const baseURL = "https://api.slashid.com"
 * const sdkURL = "https://cdn.slashid.com/sdk.html"
 *```
 *
 * You can configure the SlashID SDK to connect to the sandbox environment instead:
 * @example
 *
 * ```js
 * const sid = SlashID({
 *     environment: "sandbox"
 * })
 * ```
 *
 * Alternatively, you can specify a custom environment:
 * @example
 *
 * ```js
 * const sid = SlashID({
 *    environment: {
 *     baseURL: "https://api.custom.com",
 *     sdkURL: "https://sdk.custom/path.html"
 *   }
 * })
 * ```
 *
 * @remarks Specifying options for {@link SlashID} is optional and **only required in some cases**:
 *  - if your Organization has custom _WebAuthn_ scopes: use your SlashID-provided `sdkURL` value;
 *  - you are experimenting and want to connect to an environment other than production;
 *  - you want to enable analytics, in which case you must provide your Organization ID as the `oid` value
 */
export interface SlashIDOptions {
    /**
     * The base SlashID API endpoint.
     * @deprecated Use the `environment` option instead.
     */
    baseURL?: string;
    /**
     * The location where your organization's custom SDK is served.
     * @deprecated Use the `environment` option instead.
     */
    sdkURL?: string;
    /**
     * The environment to connect to - either "production" or "sandbox".
     * @default "production"
     *
     * To use a custom environment, pass an object with the following shape:
     * @example
     * environment: {
     *  baseURL: "https://{YOUR_CUSTOM_API_DOMAIN}}",
     *  sdkURL: "https://{YOUR_CUSTOM_SDK_DOMAIN}}/sdk.html"
     * }
     *
     */
    environment?: SlashIDEnvironment;
    /**
     * Your Organization ID provided by SlashID
     */
    oid?: string;
    /**
     * Whether to enable analytics or not.
     * @default true
     */
    analyticsEnabled?: boolean;
    /**
     * Allow Identity Provider Initiated SSO.
     * The SDK expects the `iss` query parameter to be set with the following format: `social:PROVIDER_NAME:CLIENT_ID`.
     * @default false
     */
    identityProviderInitiatedSSOEnabled?: boolean;
}
/**
 * Configuration options for the SlashID SDK.
 * Same as SlashIDOptions, but with all required options set.
 * Does not inherit the same set of fields as SlashIDOptions because some of them are going to be removed in the next major version.
 */
type SlashIDConfig = {
    oid?: string;
    baseURL: string;
    sdkURL: string;
    analyticsEnabled: boolean;
    identityProviderInitiatedSSOEnabled: boolean;
};
declare class OTPMethodOptions {
    readonly getOTP?: () => Promise<string | undefined>;
    constructor(obj?: any);
}
declare class _TOTPMethodOptions1 {
    readonly getOTP?: () => Promise<string | undefined>;
    constructor(obj?: any);
}
declare class CrossDomainStorage {
    remoteOrigin: string | undefined;
    constructor(iframe: HTMLIFrameElement | null, remoteOrigin: string | undefined);
    localGetItem(key: string): Promise<string | null>;
    remoteGetItem(key: string): Promise<string | null>;
    localSetItem(key: string, value: string): Promise<void>;
    remoteSetItem(key: string, value: string): Promise<void>;
}
declare abstract class StorageBase {
    protected readonly store: CrossDomainStorage;
    constructor(store: CrossDomainStorage);
}
declare class IdentifiersStorage extends StorageBase {
    getAll(): Promise<PersonHandle[]>;
    add(identifier: PersonHandle): Promise<void>;
}
declare class CredentialsStorageBase extends StorageBase {
    protected static identifiersEqual(id1: string, id2: string): boolean;
    protected static merge(ids1: string[], ids2: string[]): string[];
}
/**
 * @ignore
 *
 * Storage for local credentials. Contrary to the previous V1 storage, this class stores credentials IDs
 * by their scope, allowing clients to effectively register local credentials with more or less specific
 * scopes at their will. For the old default "global" credentials it falls back to an internal instance
 * of the V1 storage, so to keep older SDKs running seamlessly.
 */
export class CredentialsStorageV2 extends CredentialsStorageBase {
    constructor(store: CrossDomainStorage);
    get(scope: string): Promise<string[]>;
    add(scope: string, credId: string): Promise<void>;
}
type LogInWithOAuthParams = {
    clientId: string;
    redirectUri: string;
};
export class User extends BaseUser {
    /**
     * Reconstruct an authenticated user from its token value. An instance can be created in multiple ways:
     * - by calling {@link SlashID.id} to perform authentication
     * - by calling {@link SlashID.getUser} to reconstruct a user from a token while reusing the existing SDK instance
     * - by creating it directly using the constructor (not advised)
     *
     * Instances can only be constructed in a browser environment due to dependency on {@link SlashID}.
     *
     * @param token A user {@link token} value.
     * @param optionsOrSid SlashID instance or SlashID connection options. It is preferred to pass in the SlashID instance
     *
     * @throws `TypeError` If the given `optionsOrSid`, if defined, fail validation, or
     * the given token cannot be decoded.
     */
    constructor(token: UserTokenText | TokenContainerText, optionsOrSid?: SlashID);
    /**
     * @deprecated use SlashId instead of SlashIDOptions as it ensures the expected behaviour of the internal event emitter
     */
    constructor(token: UserTokenText | TokenContainerText, optionsOrSid?: SlashIDOptions);
    /**
     * Request the user to authenticate with the given method. This method is essentially equivalent to
     * {@link SlashID.id}, but since the user is already authenticated you can omit the `handle` or
     * `authenticationFactor` parameters, depending on the desired outcome. Please refer to the examples
     * for the use cases this method covers.
     *
     * @param handle A user handle, either a new one to be associated to the user, or an existing
     * one to deliver the authetication request to.
     *
     * @param authenticationFactor The authentication factor, please to refer to {@link SlashID.id}
     * documentation for details.
     *
     * @throws `slashid.errors.InvalidAuthenticationMethodError` if the chosen method is
     * incompatible with the given handle or is not available on the current device.
     * `Error` if the operation fails otherwise.
     *
     * @example
     *
     * One thing you can do with `mfa()` is attach other handles to the user.
     * For example, the user has already authenticated via e-mail magic link with
     * {@link SlashID.id}, but you want to also attach their phone number. In that case all
     * the method requires is the handle, not
     *
     * ```js
     * await user.mfa({
     *   type: "phone_number",
     *   value: "+13337777777"
     * })
     * ```
     *
     * SlashID will send a challenge SMS to the phone number to verify it. If `mfa()` returns
     * without throwing any error the procedure is complete and the user object will have been
     * updated with a refreshed {@link token}. For future authentications the user will be able
     * to use the newly-attached phone number as an alternative to the e-mail address. Consider
     * though that this call only verified ownership of the phone number and added it to the user
     * handles, as such the {@link authentication} array stays unchanged.
     *
     * If you want to step-up the user authentication, or simply re-authenticate the user,
     * you can do so by also providing an authentication factor. For example let's assume
     * you want to send a magic link to one of the user's e-mail address:
     *
     * ```js
     * await user.mfa({
     *   type: "email_address",
     *   value: "..." // one previously-attached address, or a new one to be attached
     * }, {
     *   method: "email_link"
     * })
     * ```
     *
     * If the e-mail address provided above was not attached to the user, SlashID will verify it
     * and also perform the authentication. Once again, when `mfa()` returns the user will have
     * a refreshed {@link token}, but this time its {@link authentication} array will also include
     * `"email_link"` in addition to the method chosen for the first authentication with
     * {@link SlashID.id}.
     *
     * The only edge case to note is that for performing MFA with WebAuthn authentication
     * there's no need to specify an handle, as the ceremony happens on the current device:
     *
     * ```js
     * await user.mfa(undefined, {
     *   method: "webauthn"
     * })
     * ```
     */
    mfa(handleOrFactor: any, authenticationFactor?: Factor): Promise<void>;
    /**
     * Given an organization ID, get a new token for the same user in the Organization specified by the Organization ID.
     *
     * For the call to succeed the following conditions must be met:
     * - the token must be valid at the time of the request
     * - the two Organizations must share the same person pool
     * - the user must be a member of both Organizations
     *
     * This operation does not count as an authentication, so the new token will have the same expiration time as the original.
     * @param oid
     * @returns {Promise} A new token for the specified Organization ID
     * @override
     */
    getTokenForOrganization(oid: string): Promise<UserTokenText | TokenContainerText>;
}
export type AnalyticsTransport = {
    sendEvent(payload: EventPostRequest): Promise<void>;
};
export type AnalyticsOptions = {
    user?: BaseUser;
    options?: SlashIDOptions;
    transport?: AnalyticsTransport;
};
/**
 * Server-side rendering friendly analytics class.
 * Can be used to identify users and track virtual page views.
 */
declare class BaseAnalytics {
    protected eventsAPI: EventsApi;
    protected user?: BaseUser;
    protected readonly config: SlashIDConfig;
    protected correlationId: string;
    protected transport: AnalyticsTransport;
    constructor({ options, user, transport }: AnalyticsOptions);
    protected createCorrelationID(): string;
    protected createEventMetadata({ location, userAgent }?: {
        location: string;
        userAgent: string;
    }): {
        organization_id: string;
        analytics_correlation_id: string;
        window_location: string;
        user_agent: string;
    };
    protected sendEvent(payload: EventPostRequest): void;
    protected trackPersonIdentified({ user }: PersonIdentifiedEvent): void;
    protected trackPersonLoggedOut(e: PersonLoggedOutEvent): void;
    /**
     * Identifies a user for the purpose of user activity tracking. Where possible
     * user identification is done automatically.
     *
     * @param user The user being identified.
     */
    identify(user: BaseUser): void;
    /**
     * Logs the user out from the point-of-view of the {@link Types.BaseAnalytics} class only,
     * this method does not have a side-effect which affects the logged in state of the user.
     *
     * After removing a stored token this method should be called to record the log out event.
     */
    logout(): void;
    /**
     * Tracks a virtual page view
     *
     * A virtual page view allows you to track a page view, even when a page is not physically
     * loaded in the browser. For example, when navigating using a client-side router in a
     * single page application, or navigating within a sub-section of a page (like a tabbed pane,
     * or navigation drawer) without changing the page itself.
     *
     * The exact meaning of a virtual page view will vary by implementation, it depends on your
     * routing paradigm and what you're trying to track. You will need to implement this event
     * in a way which makes sense for your product.
     *
     * @param options.url The URL of the page to track as the subject of the virtual page view.
     */
    trackVirtualPageView(options: {
        url?: string;
        userAgent?: string;
    }): void;
}
type BrowserAnalyticsOptions = {
    sdk: SlashID;
    user?: BaseUser;
};
/**
 * The interface for SlashID user analytics.
 *
 * We've built user analytics right into SlashID. We automatically track user
 * activity surrounding sign-up & log-in so we can give you metrics like monthly
 * active users (MAU), returning users, and new users.
 *
 * Further, we record how people are choosing to authenticate with SlashID and
 * expose this data to you so you can understand user preferences regarding
 * authentication methods, and crucially: any friction caused by requiring that
 * a particular authentication method or combination of authentication methods (MFA)
 * be used.
 */
declare class BrowserAnalytics extends BaseAnalytics {
    constructor({ sdk, user }: BrowserAnalyticsOptions);
    protected createCorrelationID(): string;
    protected createEventMetadata({ location, userAgent }?: {
        location: string;
        userAgent: string;
    }): {
        organization_id: string;
        analytics_correlation_id: string;
        window_location: string;
        user_agent: string;
    };
    /**
     * Tracks a virtual page view
     *
     * A virtual page view allows you to track a page view, even when a page is not physically
     * loaded in the browser. For example, when navigating using a client-side router in a
     * single page application, or navigating within a sub-section of a page (like a tabbed pane,
     * or navigation drawer) without changing the page itself.
     *
     * The exact meaning of a virtual page view will vary by implementation, it depends on your
     * routing paradigm and what you're trying to track. You will need to implement this event
     * in a way which makes sense for your product.
     *
     * @param options.url The URL of the page to track as the subject of the virtual page view.
     */
    trackVirtualPageView(options: {
        url?: string;
        userAgent?: string;
    }): void;
}
type Challenge = ProxyChallenge | NonceChallenge | WebAuthnGetChallenge | WebAuthnCreateChallenge | OIDCChallenge | UICustomizationChallenge;
type ChallengeSSR = NonceChallenge | ProxyChallenge;
type FlowMeta = {
    authFlowId?: string | undefined;
    recoveryFlowId?: string | undefined;
};
declare class ChallengeProcessor {
    constructor(slashID: SlashID, emitter: EventEmitter<NamedEvents>, flowMeta?: FlowMeta | undefined);
    processChallenges({ challenges, authnFactor, previousToken, }: {
        challenges: Challenge[];
        authnFactor?: Factor;
        previousToken?: UserTokenText;
    }): Promise<UserTokenText>;
    processTOTPVerifyChallenge(challenge: TOTPVerifyChallenge): Promise<TOTPVerifyAttestation>;
    processWebAuthnGetChallenge(challenge: WebAuthnGetChallenge): Promise<WebAuthnGetAttestation>;
    processWebAuthnCreateChallenge(challenge: WebAuthnCreateChallenge): Promise<WebAuthnCreateAttestation>;
}
export class AnonymousUser extends BaseUser {
    /**
     * Reconstruct an anonymous user from its token value. Call the `id` method to authenticate the user.
     * If this results with registering a new user, the underlying user ID will be the same as the originating anonymous user.
     *
     * Instances can only be constructed in a browser environment due to dependency on {@link SlashID}.
     *
     * @param token A user {@link token} value.
     * @param slashid SlashID instance
     *
     * @throws `TypeError` the given token cannot be decoded.
     */
    constructor(token: UserTokenText | TokenContainerText, slashid: SlashID);
    /**
     *  Authenticates the [AnonymousUser], on success the user is now a permanently registered user.
     *
     *  @returns `Promise<BrowserUser>`
     */
    id(handle: PersonHandle, authenticationFactor: Factor): Promise<User>;
}
declare const PRIVATE_PUBLISH: unique symbol;
declare const PRIVATE_SUBSCRIBE: unique symbol;
declare const PRIVATE_UNSUBSCRIBE: unique symbol;
export const __INTERNAL_ONLY: (sid: SlashID) => {
    publish: <Key extends "clientSideError">(type: Key, event: PrivateEvents[Key]) => void;
    subscribe: <Key_1 extends "clientSideError">(type: Key_1, handler: Handler<PrivateEvents[Key_1]>) => void;
    unsubscribe: <Key_2 extends "clientSideError">(type: Key_2, handler: Handler<PrivateEvents[Key_2]>) => void;
};
/**
 * This class is the main entry point for users of the SlashID SDK. It exposes a single function
 * for uniform access to all supported identification methods as {@link id}.
 * The returned {@link Types.BaseUser} object has methods to either register further
 * user handles (e.g. a second e-mail address, or a phone number), or ask the user to
 * authenticate using any number of available authentication methods. Please see {@link Types.BaseUser}
 * for further details and examples.
 *
 * For a quick start please consult the {@link constructor} and {@link id} documentation and examples.
 */
export class SlashID {
    readonly baseURL: string;
    readonly sdkURL: string;
    readonly oid?: string;
    authnClient: DefaultApi;
    personsClient: PersonsApi;
    iframe: HTMLIFrameElement | null;
    identifiersStorage: IdentifiersStorage;
    credentialStorage: CredentialsStorageV2;
    /**
     * @example
     *
     * For production you can simply create your _SlashID_ instance with:
     *
     * ```js
     * import * as slashid from "slashid"
     * const sid = new slashid.SlashID()
     * ```
     *
     * If you want to experiment and connect to the sandbox environment instead:
     *
     * ```js
     * const sid = new slashid.SlashID({
     *   environment: "sandbox"
     * })
     * ```
     *
     * @param options Your SlashID connection options.
     * @throws `TypeError` If the given `options`, if defined, fail validation
     */
    constructor(options?: SlashIDOptions);
    /**
     * Get an instance of the Analytics class. Use the instance to track virtual page views.
     * @throws `Error` If analytics is not enabled or oid is not set.
     * @returns Analytics instance
     */
    getAnalytics(): BrowserAnalytics;
    static canGetPublicKeyCredentialsInIFrame(): Promise<boolean>;
    /**
     * Starts the login flow with a redirect to the hosted login page.
     */
    startHostedLoginFlow(params: LogInWithOAuthParams): Promise<void>;
    /**
     * Resolves the previously started login flow with a redirect to the hosted login page.
     * Call this method on the page where the hosted login page redirects to.
     */
    resolveHostedLoginFlow(): Promise<User | undefined>;
    /**
     * Publish an event to the SDK. Currently available events are listed in {@link Types.PublicWriteEvents}.
     * @param type
     * @param event
     */
    publish<Key extends keyof PublicWriteEvents>(type: Key, event: PublicWriteEvents[Key]): void;
    /**
     * Variant of [publish] for private events
     */
    [PRIVATE_PUBLISH]<Key extends keyof PrivateEvents>(type: Key, event: PrivateEvents[Key]): void;
    /**
     * Subscribe to the events published by the SDK. Currently available events are listed in {@link Types.PublicReadEvents}.
     * @param type
     * @param handler
     */
    subscribe<Key extends keyof PublicReadEvents>(type: Key, handler: Handler<PublicReadEvents[Key]>): void;
    /**
     * Variant of [subscribe] for private events
     */
    [PRIVATE_SUBSCRIBE]<Key extends keyof PrivateEvents>(type: Key, handler: Handler<PrivateEvents[Key]>): void;
    /**
     * Unsubscribe from the SDK events. Currently available events are listed in {@link Types.PublicReadEvents}.
     * @param type
     * @param handler
     */
    unsubscribe<Key extends keyof PublicReadEvents>(type: Key, handler: Handler<PublicReadEvents[Key]>): void;
    /**
     * Variant of [subscribe] for private events
     */
    [PRIVATE_UNSUBSCRIBE]<Key extends keyof PrivateEvents>(type: Key, handler: Handler<PrivateEvents[Key]>): void;
    /**
     * Get a Promise that resolves to an array of challenge objects.
     */
    getChallengesFromURL(): Promise<ChallengeListInner[] | null>;
    /**
     * Process authentication challenges from the URL query parameters.
     * You can use this in conjunction with the Direct-ID API to allow your users to land on your
     * target page already authenticated.
     *
     * If Identity Provider Initiated SSO is enabled and the organization ID is set,
     * this method will also start the SSO flow given the correct parameters.
     *
     * @returns The authenticated user from the `challenges` URL parameter, if present, `null` otherwise.
     */
    getUserFromURL(): Promise<BaseUser | null>;
    /**
     * List the available authentication methods for the chosen handle type. Currently available
     * authentication methods are listed in {@link Types.FactorMethod}. Before choosing a method to pass
     * to {@link id} you should consult the result of this method. In particular the availability of
     * the {@link Types.FactorMethod['Webauthn']} method depends on the current device configuration and
     * might not always be available.
     *
     * It's important to note that you can rely on some authentication methods to always be available:
     *
     *  - for {@link PersonHandleType['EmailAddress']}: {@link Types.FactorMethod['OtpViaEmail']} and
     *    {@link Types.FactorMethod['EmailLink']} are always available;
     *  - for {@link PersonHandleType['PhoneNumber']}: {@link Types.FactorMethod['OtpViaSms']} and
     *    {@link Types.FactorMethod['SmsLink']} are always available;
     *
     * On the contrary, the availability of {@link Types.FactorMethod['Webauthn']} depends exclusively on the
     * current device configuration.
     *
     * @remarks The availability of authetication methods can vary over time, you probably should not
     * cache or store the result and instead invoke the method any time you need to authenticate a user.
     *
     * @example
     *
     * SlashID supports a number of handle types, each in turn supporting a set of
     * authentication methods. Supposing you identify your users with e-mail addresses,
     * you should check the authentication methods available on the current device before
     * kicking off the authentication flow:
     *
     * ```js
     * const availableMethods = sid.getAvailableAuthenticationMethods("email_address")
     * // => availableMethods === ["webauthn", "email_link"]
     * ```
     *
     * At this point you can choose which method to use in {@link id}. You could decide based on
     * one or a combination of:
     *
     *  - Your static preference: e.g. require WebAuthn, prefer WebAuthn ({@link Types.FactorMethod['Webauthn']})
     *    if available, otherwise fallback to magic link via e-mail ({@link Types.FactorMethod['EmailLink']})
     *    ```
     *    const chosenMethod = availableMethods.includes("webauthn") ? "webauthn" : "email_link"
     *    ```
     *  - User's choice: you could present your users with a selection of the available methods;
     *
     * In general the SlashID SDK does not impose any restriction on how you decide to choose which
     * authentication method to use.
     *
     * @param handleType Available handle types are ``"email_address"``, ``"phone_number"`` and ``"username"``.
     * @returns  An array of the available authentication methods on this device.
     */
    getAvailableAuthenticationMethods(handleType: PersonHandleType): Promise<FactorMethod[]>;
    /**
     * Preferred way of creating  a {@link Types.BaseUser} instance based on an existing token.
     *
     * @param token A user {@link Types.UserTokenText} value.
     * @returns User instance
     */
    getUser(token: UserTokenText): User;
    /**
     * Identify a user. This method implements the SlashID authentication flow.
     * In particular the flow is:
     *
     *  - **passwordless**: all you need to specify to authenticate a user is their handle,
     *    be it an e-mail address or phone number, and how they wish to authenticate; please see
     *    the parameters documentation for more details;
     *
     *  - **unified**: it does not require you to differentiate between first registration and
     *    subsequent logins attempts. The SlashID service takes care of the distinction and will
     *    perform the necessary verification ceremonies on your behalf under the hood.
     *
     *  - **synchronous**: on successful return the user has verified their identity; even when
     *    the authentication spans multiple devices and is comprised of multiple steps (e.g
     *    clicking a magic link on the provided e-mail address and creating a new biometric
     *    credential on the current device), this method will not return until all steps have
     *    completed or errors have been encountered.
     *
     *
     * Before utilizing any authentication method you should check whether it is available with {@link getAvailableAuthenticationMethods}.
     *
     * The currently available options for the `authenticationFactor.method` field are:
     *
     *  - **``"webauthn"``**: Authenticate the user via WebAuthn on this device. If available this
     *    usually entails built-in biometric authentication or the use of an external FIDO key, with a
     *    preference for the former. Please also see the [WebAuthn scope](#webauthn_scope) and
     *    [WebAuthn attachment](#webauthn_attachment) sections below for details.
     *
     *  - **``"email_link"``**: Deliver a magic link via e-mail.
     *
     *  - **``"otp_via_email"``**: Deliver an OTP security code via e-mail. This authentication method requires you to {@link publish} an
     *    `otpCodeSubmitted` event to the SDK. The event payload must be a string containing the OTP
     *    value, which your user will receive via e-mail.
     *
     *  - **``"sms_link"``**: Deliver a magic link via SMS.
     *
     *  - **``"otp_via_sms"``**: Deliver an OTP security code via SMS. This authentication method requires you to {@link publish} an
     *    `otpCodeSubmitted` event to the SDK. The event payload must be a string containing the OTP
     *    value, which your user will receive via SMS.
     *
     *  - **``oidc``**: Authenticate the user using OIDC through a preconfigured Identity Provider.
     *
     *  - **``totp``**: Authenticate the user with a TOTP code. This authentication method requires you to {@link publish} an
     *    `otpCodeSubmitted` event to the SDK. The event payload must be a string containing the OTP
     *    code, which your user will retrieve from their authenticator app or device.
     *
     * <a name="webauthn_scope"></a>
     * <b>WebAuthn scope</b>
     *
     * In case you have chosen the WebAuthn method, you have the option to specify a `scope`
     * in the `options` field. This field allows you to control the breadth of your users' WebAuthn credentials.
     * The field is optional, but if specified it can either be your domain or any "registrable domain suffix" of it.
     * E.g. if your domain is `shop.domain.com` you have two options to choose from:
     *
     *  - `shop.domain.com`: scope your users to the current domain. Credentials created here will not be shared with sibling domains such as `services.domain.com`;
     *  - `domain.com`: scope your users to the least specific domain. Credentials created here will be allowed to access all subdomains such as `services.domain.com`;
     *
     * Please consult the HTML spec for the formal definition of [registrable domain suffix](https://html.spec.whatwg.org/multipage/origin.html#is-a-registrable-domain-suffix-of-or-is-equal-to)
     * if you need detailed information. When not specified the `scope` option defaults to the current origin, `shop.domain.com`
     * in the example above.
     *
     * <a name="webauthn_attachment"></a>
     * <b>WebAuthn attachment</b>
     *
     * Users can perform WebAuthn either with built-in authenticators (FaceID, TouchID, fingerprint readers, etc.)
     * or external security keys, and in case you have a preference you can control which authenticator type to use
     * by specifying an `attachment` option field in the `options` field.
     * The field is optional and has 3 allowed values from the {@link WebAuthnAuthenticatorAttachment} enum:
     *
     *  - `"platform"`: mandate use of built-in authenticators;
     *  - `"cross-platform"`: mandate use of external security keys;
     *  - `"any"`: the default value if unspecified, allows both types;
     *
     * If left unspecified (or explicitly set to `"any"`) the user will be prompted with a system dialog to choose
     * which type of authenticator they prefer. By providing one of the other options instead (e.g. `"platform"`)
     * you explicitly limit the authenticator types the user can choose from. On most devices this results in the
     * most seamless WebAuthn user experience possible, as the system dialog will not be shown and the user will be
     * prompted to authenticate directly.
     *
     * @param oid Your organization ID.
     * @param handle How the user wishes to identify, e.g. their e-mail address.
     * @param authenticationFactor How to verify the user's identity matches the handle.
     *
     * @throws `slashid.errors_INTERNAL_ONLY.InvalidAuthenticationMethodError` if the chosen method is
     * incompatible with the given handle or is not available on the current device.
     *
     * @fires {@link Types.IdFlowSucceededEvent} when the flow resolves successfully
     *
     * @returns The authenticated user.
     *
     * @example
     *
     * Authenticating a user is as simple as:
     *
     * ```js
     * const user = await slashID.id({
     *   type: "phone_number",
     *   value: "+13337777777",
     * }, {
     *   method: "webauthn"
     * })
     * ```
     *
     * At this point the user has been authenticated; either registered or logged in.
     *
     * You can use it in a header in your HTTP requests:
     *
     * ```js
     * const response = await fetch(url, {
     *   ...
     *   headers: {
     *     'Authorization': `Bearer ${user.token}`,
     *      ...
     *   }
     * });
     * ```
     *
     * You can collect and associate user attributes:
     *
     * ```js
     * const userDetails = { name: "...", streetAddress: "..." }
     * await user.set(userDetails)
     * ```
     *
     * You can perform multi-factor authentication before proceeding with your application logic:
     *
     * ```js
     * await user.mfa({
     *   type: "email_address",
     *   value: "my.email@example.com"
     * }, {
     *   method: "email_link"
     * })
     * ```
     */
    id(oid: OrganizationID, handle: PersonHandle, authenticationFactor: Factor): Promise<User>;
    /**
     * @internal
     */
    _id(oid: OrganizationID, handle?: PersonHandle, authenticationFactor?: Factor, prevToken?: UserTokenText): Promise<User>;
    /**
     * List the handles previously used to authenticate successfully.
     *
     * @remarks Use of this method is in no way required to authenticate with SlashID. The SDK
     * provides it to allow you to more easily implement loging suggestion drop-down lists
     * and similar UX niceties, by e.g. tying it to a `<datalist>`:
     *
     * ```js
     * const handles = await sid.getAvailableIdentifiers()
     * const options = handles.map((handle) => {
     *   const option = document.createElement("option")
     *   option.value = handle.value
     *   return option
     * })
     * const datalist = document.getElementById("available_identifiers")
     * datalist.replaceChildren(...options)
     *
     * ...
     *
     * <input ... list="available_identifiers" />
     * ```
     *
     * Depending on browser settings, it may not be possible to discover these
     * identifiers.
     *
     * @returns An array of identifiers of previously-authenticated users.
     */
    getAvailableIdentifiers(): Promise<PersonHandle[]>;
    /**
     * Use a verified handle and a factor to start the account recovery flow.
     * The user will receive instructions on how to proceed using a delivery mechanism based on the given handle.
     * After this method resolves, the user will be able to authenticate using the same handle and factor.
     */
    recover({ handle, factor, }: {
        handle: ReachablePersonHandle;
        factor: RecoverableFactor;
    }): Promise<void>;
    getSDKUrl(): URL;
    isLocalScope(rpID: string): boolean;
    createAnonymousUser(): Promise<AnonymousUser>;
    createChallengeProcessor(flowMeta?: FlowMeta): ChallengeProcessor;
}
type ChallengeProcessorOptions = {
    /** HTTP client that implements the Fetch API */
    fetchApi?: Configuration["fetchApi"];
    /** The environment to use for the SlashID API. */
    environment?: SlashIDEnvironment;
    /**
     * The origin of the request.
     * Used to identify the origin of the request when sending requests to the SlashID API.
     * If allowed domains are configured in the SlashID API, the origin must be one of the allowed domains.
     * Otherwise, use the default value as is.
     */
    origin?: string;
};
/**
 * A server-side challenge processor. Compatible with node versions >= 18.
 * Node runtimes < 18 require a Fetch API implementation to be provided.
 *
 * Parse query string containing challenges and resolve them server side.
 */
declare class _ChallengeProcessor1 {
    constructor({ origin, environment, fetchApi }?: ChallengeProcessorOptions);
    /**
     * Input must be a query string containig either 'challenges' or 'sidcp' URL query parameters.
     * Get a Promise that resolves to an array of challenge objects.
     * Theses objects are either nonce or proxy challenges.
     */
    parseChallenges(queryString: string): Promise<ChallengeSSR[] | null>;
    /**
     * Process an array of challenges. The challenges must be either nonce or proxy challenges.
     * Returns a Promise that resolves to a user token if the challenge resolution is successful.
     */
    processChallenges({ challenges, previousToken, }: {
        challenges: ChallengeSSR[];
        previousToken?: UserTokenText;
    }): Promise<UserTokenText>;
}
export const SSR: {
    User: typeof BaseUser;
    Analytics: typeof BaseAnalytics;
    createAnonymousUserToken: ({ environment, oid }: import("src/main/user.utils").CreateAnonymousUserOptions) => Promise<string>;
    ChallengeProcessor: typeof _ChallengeProcessor1;
};
export const errors: {
    isFlowCancelledError(error: any): error is FlowCancelledError;
    isHandlePatternNotAllowedError(error: any): error is HandlePatternNotAllowedError;
    isSignUpAwaitingApprovalError(error: any): error is SignUpAwaitingApprovalError;
    isSignInAwaitingApprovalError(error: any): error is SignInAwaitingApprovalError;
    isSelfRegistrationNotAllowedError(error: import("src/domain/errors.internal").SlashIDError): error is SelfRegistrationNotAllowedError;
    isNoPasswordSetError(error: import("src/domain/errors.internal").SlashIDError): error is NoPasswordSetError;
    isNonReachableHandleTypeError(error: Error): error is NonReachableHandleTypeError;
    isTimeoutError(error: any): error is TimeoutError;
    isRateLimitError(error: any): error is RateLimitError;
    isBadPasskeyScopeError(error: any): error is BadPasskeyScopeError;
    isPasskeyPromptError(error: any): error is PasskeyPromptError;
    isAPIResponseError(error: any): error is APIResponseError;
    isInvalidSlashIDConfigurationError(error: any): error is InvalidSlashIDConfigurationError;
    isInvalidURLParamsError(error: any): error is InvalidURLParamsError;
    isInvalidAuthenticationMethodError(error: any): error is InvalidAuthenticationMethodError;
    isInvalidActionError(error: any): error is InvalidActionError;
    isPersonExistsError(error: any): error is PersonExistsError;
    isInvalidEmailAddressFormatError(error: any): error is InvalidEmailAddressFormatError;
    isInvalidPhoneNumberFormatError(error: any): error is InvalidPhoneNumberFormatError;
    isUnreachablePhoneNumberError(error: any): error is UnreachablePhoneNumberError;
    isUnexpectedError(error: any): error is UnexpectedError;
    createSlashIDError({ message, name, cause, context }: SlashIDErrorInput): SlashIDError;
    isSlashIDError(error: any): error is SlashIDError;
    ERROR_NAMES: {
        readonly noPasswordSet: "noPasswordSet";
        readonly unknown: "UnexpectedError";
        readonly flowCancelled: "FlowCancelledError";
        readonly handlePatternNotAllowed: "HandlePatternNotAllowedError";
        readonly signUpAwaitingApproval: "SignUpAwaitingApprovalError";
        readonly signInAwaitingApproval: "SignInAwaitingApprovalError";
        readonly selfRegistrationNotAllowed: "SelfRegistrationNotAllowed";
        readonly recoverNonReachableHandleType: "recoverNonReachableHandleType";
        readonly timeoutError: "TimeoutError";
        readonly rateLimitError: "RateLimitError";
        readonly badPasskeyScopeError: "BadPasskeyScopeError";
        readonly passkeyPromptError: "PasskeyPromptError";
        readonly apiResponseError: "APIResponseError";
        readonly invalidSlashIDConfigurationError: "InvalidSlashIDConfigurationError";
        readonly invalidSlashIDURLParamsError: "InvalidSlashIDURLParamsError";
        readonly invalidAuthenticationMethodError: "InvalidAuthenticationMethodError";
        readonly invalidActionError: "InvalidActionError";
        readonly invalidEmailAddressFormatError: "InvalidEmailAddressFormatError";
        readonly invalidPhoneNumberFormatError: "InvalidPhoneNumberFormatError";
        readonly unreachablePhoneNumberError: "UnreachablePhoneNumberError";
        readonly personExistsError: "PersonExistsError";
    };
    isClientGeneratedErrorSlug: (text: string) => text is "incorrect_otp_code_via_email" | "incorrect_otp_code_via_sms" | "incorrect_otp_code" | "invalid_password" | "incorrect_password" | "recovery_failed" | "oidc_popup_blocked" | "client_side_error" | "unspecified" | "no_password_set" | "flow_cancelled" | "handle_pattern_not_allowed" | "sign_up_awaiting_approval" | "sign_in_awaiting_approval" | "self_registration_not_allowed" | "recover_non_reachable_handle_type" | "timeout" | "rate_limit_exceeded" | "passkey_bad_scope" | "passkey_prompt_failed" | "api_response_error" | "invalid_slashid_configuration" | "invalid_slashid_url_params" | "invalid_authentication_method" | "invalid_action" | "invalid_email_address_format" | "invalid_phone_number_format" | "unreachable_phone_number" | "person_exists";
    CLIENT_GENERATED_ERROR_SLUGS: readonly ["incorrect_otp_code_via_email", "incorrect_otp_code_via_sms", "incorrect_otp_code", "invalid_password", "incorrect_password", "recovery_failed", "oidc_popup_blocked", "client_side_error", "unspecified", "no_password_set", "flow_cancelled", "handle_pattern_not_allowed", "sign_up_awaiting_approval", "sign_in_awaiting_approval", "self_registration_not_allowed", "recover_non_reachable_handle_type", "timeout", "rate_limit_exceeded", "passkey_bad_scope", "passkey_prompt_failed", "api_response_error", "invalid_slashid_configuration", "invalid_slashid_url_params", "invalid_authentication_method", "invalid_action", "invalid_email_address_format", "invalid_phone_number_format", "unreachable_phone_number", "person_exists"];
    ERROR_NAMES_TO_SLUGS_MAP: Record<ErrorName, "incorrect_otp_code_via_email" | "incorrect_otp_code_via_sms" | "incorrect_otp_code" | "invalid_password" | "incorrect_password" | "recovery_failed" | "oidc_popup_blocked" | "client_side_error" | "unspecified" | "no_password_set" | "flow_cancelled" | "handle_pattern_not_allowed" | "sign_up_awaiting_approval" | "sign_in_awaiting_approval" | "self_registration_not_allowed" | "recover_non_reachable_handle_type" | "timeout" | "rate_limit_exceeded" | "passkey_bad_scope" | "passkey_prompt_failed" | "api_response_error" | "invalid_slashid_configuration" | "invalid_slashid_url_params" | "invalid_authentication_method" | "invalid_action" | "invalid_email_address_format" | "invalid_phone_number_format" | "unreachable_phone_number" | "person_exists">;
};
export const Errors: {
    isFlowCancelledError(error: any): error is FlowCancelledError;
    isHandlePatternNotAllowedError(error: any): error is HandlePatternNotAllowedError;
    isSignUpAwaitingApprovalError(error: any): error is SignUpAwaitingApprovalError;
    isSignInAwaitingApprovalError(error: any): error is SignInAwaitingApprovalError;
    isSelfRegistrationNotAllowedError(error: import("src/domain/errors.internal").SlashIDError): error is SelfRegistrationNotAllowedError;
    isNoPasswordSetError(error: import("src/domain/errors.internal").SlashIDError): error is NoPasswordSetError;
    isNonReachableHandleTypeError(error: Error): error is NonReachableHandleTypeError;
    isTimeoutError(error: any): error is TimeoutError;
    isRateLimitError(error: any): error is RateLimitError;
    isBadPasskeyScopeError(error: any): error is BadPasskeyScopeError;
    isPasskeyPromptError(error: any): error is PasskeyPromptError;
    isAPIResponseError(error: any): error is APIResponseError;
    isInvalidSlashIDConfigurationError(error: any): error is InvalidSlashIDConfigurationError;
    isInvalidURLParamsError(error: any): error is InvalidURLParamsError;
    isInvalidAuthenticationMethodError(error: any): error is InvalidAuthenticationMethodError;
    isInvalidActionError(error: any): error is InvalidActionError;
    isPersonExistsError(error: any): error is PersonExistsError;
    isInvalidEmailAddressFormatError(error: any): error is InvalidEmailAddressFormatError;
    isInvalidPhoneNumberFormatError(error: any): error is InvalidPhoneNumberFormatError;
    isUnreachablePhoneNumberError(error: any): error is UnreachablePhoneNumberError;
    isUnexpectedError(error: any): error is UnexpectedError;
    createSlashIDError({ message, name, cause, context }: SlashIDErrorInput): SlashIDError;
    isSlashIDError(error: any): error is SlashIDError;
    ERROR_NAMES: {
        readonly noPasswordSet: "noPasswordSet";
        readonly unknown: "UnexpectedError";
        readonly flowCancelled: "FlowCancelledError";
        readonly handlePatternNotAllowed: "HandlePatternNotAllowedError";
        readonly signUpAwaitingApproval: "SignUpAwaitingApprovalError";
        readonly signInAwaitingApproval: "SignInAwaitingApprovalError";
        readonly selfRegistrationNotAllowed: "SelfRegistrationNotAllowed";
        readonly recoverNonReachableHandleType: "recoverNonReachableHandleType";
        readonly timeoutError: "TimeoutError";
        readonly rateLimitError: "RateLimitError";
        readonly badPasskeyScopeError: "BadPasskeyScopeError";
        readonly passkeyPromptError: "PasskeyPromptError";
        readonly apiResponseError: "APIResponseError";
        readonly invalidSlashIDConfigurationError: "InvalidSlashIDConfigurationError";
        readonly invalidSlashIDURLParamsError: "InvalidSlashIDURLParamsError";
        readonly invalidAuthenticationMethodError: "InvalidAuthenticationMethodError";
        readonly invalidActionError: "InvalidActionError";
        readonly invalidEmailAddressFormatError: "InvalidEmailAddressFormatError";
        readonly invalidPhoneNumberFormatError: "InvalidPhoneNumberFormatError";
        readonly unreachablePhoneNumberError: "UnreachablePhoneNumberError";
        readonly personExistsError: "PersonExistsError";
    };
    isClientGeneratedErrorSlug: (text: string) => text is "incorrect_otp_code_via_email" | "incorrect_otp_code_via_sms" | "incorrect_otp_code" | "invalid_password" | "incorrect_password" | "recovery_failed" | "oidc_popup_blocked" | "client_side_error" | "unspecified" | "no_password_set" | "flow_cancelled" | "handle_pattern_not_allowed" | "sign_up_awaiting_approval" | "sign_in_awaiting_approval" | "self_registration_not_allowed" | "recover_non_reachable_handle_type" | "timeout" | "rate_limit_exceeded" | "passkey_bad_scope" | "passkey_prompt_failed" | "api_response_error" | "invalid_slashid_configuration" | "invalid_slashid_url_params" | "invalid_authentication_method" | "invalid_action" | "invalid_email_address_format" | "invalid_phone_number_format" | "unreachable_phone_number" | "person_exists";
    CLIENT_GENERATED_ERROR_SLUGS: readonly ["incorrect_otp_code_via_email", "incorrect_otp_code_via_sms", "incorrect_otp_code", "invalid_password", "incorrect_password", "recovery_failed", "oidc_popup_blocked", "client_side_error", "unspecified", "no_password_set", "flow_cancelled", "handle_pattern_not_allowed", "sign_up_awaiting_approval", "sign_in_awaiting_approval", "self_registration_not_allowed", "recover_non_reachable_handle_type", "timeout", "rate_limit_exceeded", "passkey_bad_scope", "passkey_prompt_failed", "api_response_error", "invalid_slashid_configuration", "invalid_slashid_url_params", "invalid_authentication_method", "invalid_action", "invalid_email_address_format", "invalid_phone_number_format", "unreachable_phone_number", "person_exists"];
    ERROR_NAMES_TO_SLUGS_MAP: Record<ErrorName, "incorrect_otp_code_via_email" | "incorrect_otp_code_via_sms" | "incorrect_otp_code" | "invalid_password" | "incorrect_password" | "recovery_failed" | "oidc_popup_blocked" | "client_side_error" | "unspecified" | "no_password_set" | "flow_cancelled" | "handle_pattern_not_allowed" | "sign_up_awaiting_approval" | "sign_in_awaiting_approval" | "self_registration_not_allowed" | "recover_non_reachable_handle_type" | "timeout" | "rate_limit_exceeded" | "passkey_bad_scope" | "passkey_prompt_failed" | "api_response_error" | "invalid_slashid_configuration" | "invalid_slashid_url_params" | "invalid_authentication_method" | "invalid_action" | "invalid_email_address_format" | "invalid_phone_number_format" | "unreachable_phone_number" | "person_exists">;
};
export const Utils: {
    runtimeSupportsBestPasskeyUX: () => Promise<boolean>;
    isReachablePersonHandleType: typeof isReachablePersonHandleType;
    PUBLIC_READ_EVENTS: PublicReadEventsKeys;
    PUBLIC_WRITE_EVENTS: PublicWriteEventsKeys;
};

//# sourceMappingURL=slashid.d.ts.map