@loginid/websdk3 1.0.0 → 1.0.1

package/dist/index.d.ts

@@ -0,0 +1,777 @@
+type ApiRequestOptions = {
+    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+    readonly url: string;
+    readonly path?: Record<string, any>;
+    readonly cookies?: Record<string, any>;
+    readonly headers?: Record<string, any>;
+    readonly query?: Record<string, any>;
+    readonly formData?: Record<string, any>;
+    readonly body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number, string>;
+};
+
+interface OnCancel {
+    readonly isResolved: boolean;
+    readonly isRejected: boolean;
+    readonly isCancelled: boolean;
+    (cancelHandler: () => void): void;
+}
+declare class CancelablePromise<T> implements Promise<T> {
+    #private;
+    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: OnCancel) => void);
+    get [Symbol.toStringTag](): string;
+    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onFinally?: (() => void) | null): Promise<T>;
+    cancel(): void;
+    get isCancelled(): boolean;
+}
+
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+type Headers = Record<string, string>;
+type OpenAPIConfig = {
+    BASE: string;
+    VERSION: string;
+    WITH_CREDENTIALS: boolean;
+    CREDENTIALS: 'include' | 'omit' | 'same-origin';
+    TOKEN?: string | Resolver<string> | undefined;
+    USERNAME?: string | Resolver<string> | undefined;
+    PASSWORD?: string | Resolver<string> | undefined;
+    HEADERS?: Headers | Resolver<Headers> | undefined;
+    ENCODE_PATH?: ((path: string) => string) | undefined;
+};
+
+declare abstract class BaseHttpRequest {
+    readonly config: OpenAPIConfig;
+    constructor(config: OpenAPIConfig);
+    abstract request<T>(options: ApiRequestOptions): CancelablePromise<T>;
+}
+
+type authenticatorAssertionResponseRequestBody = {
+    /**
+     * This attribute contains the authenticator data returned by the authenticator.
+     */
+    authenticatorData: string;
+    /**
+     * Base64 encoded byte array which is a JSON-compatible serialization of client data
+     * passed to the authenticator by the client in order to generate this assertion.
+     * The exact JSON serialization MUST be preserved, as the hash of the serialized
+     * client data has been computed over it.
+     */
+    clientDataJSON: string;
+    /**
+     * A base64 encoded byte sequence identifying a public key credential
+     * source and its authentication assertions.
+     */
+    credentialId: string;
+    /**
+     * Base64 encoded the raw signature returned from the authenticator.
+     */
+    signature: string;
+    /**
+     * User handle returned from the authenticator, or null if the authenticator did not return a user handle.
+     */
+    userHandle?: string;
+};
+
+type AuthAuthCompleteRequestBody = {
+    assertionResult: authenticatorAssertionResponseRequestBody;
+    /**
+     * An opaque object containing session data.
+     */
+    session: string;
+};
+
+/**
+ * AuthCompleteResponseBody result type (default view)
+ */
+type AuthAuthCompleteResponseBody = {
+    /**
+     * JWT access token
+     */
+    jwtAccess: string;
+};
+
+/**
+ * Application making the request. It contains additional info about the caller
+ * to distinguish between tenants.
+ */
+type applicationRequestBody = {
+    /**
+     * Unique application id
+     */
+    id: string;
+    /**
+     * App authorization token signed with application key.
+     */
+    token?: string;
+};
+
+/**
+ * Information about the device. All of these attributes are optional and should
+ * be provided on best effort basis. If provide, they will be taken into
+ * consideration in order to improve user experience.
+ */
+type deviceInfoRequestBody = {
+    /**
+     * Client name
+     */
+    clientName?: string;
+    /**
+     * Client type.
+     */
+    clientType?: 'browser' | 'other';
+    /**
+     * Client version
+     */
+    clientVersion?: string;
+    /**
+     * An unique device identifier
+     */
+    deviceId?: string;
+    /**
+     * OS architecture
+     */
+    osArch?: string;
+    /**
+     * OS name
+     */
+    osName?: string;
+    /**
+     * OS version
+     */
+    osVersion?: string;
+    /**
+     * Screen height in pixels
+     */
+    screenHeight?: number;
+    /**
+     * Screen width in pixels
+     */
+    screenWidth?: number;
+};
+
+type userRequestBody = {
+    /**
+     * Display Name
+     */
+    displayName?: string;
+    /**
+     * Username
+     */
+    username: string;
+    /**
+     * Username type
+     */
+    usernameType: 'email' | 'phone';
+};
+
+type AuthAuthInitRequestBody = {
+    app: applicationRequestBody;
+    deviceInfo: deviceInfoRequestBody;
+    user: userRequestBody;
+};
+
+type pubKeyCredentialDescriptorResponseBody = {
+    /**
+     * Base64 encoded byte array of the public key identifier.
+     */
+    id: string;
+    transports?: Array<'usb' | 'nfc' | 'ble' | 'internal'>;
+    type: 'public-key';
+};
+
+type publicKeyCredentialRequestOptionsResponseBody = {
+    /**
+     * A list of PublicKeyCredentialDescriptor objects representing public key
+     * credentials acceptable to the caller, in descending order of the caller’s
+     * preference (the first item in the list is the most preferred credential,
+     * and so on down the list).
+     */
+    allowCredentials?: Array<pubKeyCredentialDescriptorResponseBody>;
+    /**
+     * This base64 encoded byte array represents a challenge that the selected
+     * authenticator signs, along with other data, when producing an authentication
+     * assertion.
+     */
+    challenge: string;
+    /**
+     * Additional parameters requesting additional processing by the client and
+     * authenticator. For example, if transaction confirmation is sought from the
+     * user, then the prompt string might be included as an extension.
+     */
+    extensions?: Record<string, string>;
+    /**
+     * The relying party identifier claimed by the caller. If omitted, its value will
+     * be the CredentialsContainer object’s relevant settings object's origin's
+     * effective domain.
+     */
+    rpId?: string;
+    /**
+     * Specifies a time, in milliseconds, that the caller is willing
+     * to wait for the call to complete. The value is treated as a
+     * hint, and MAY be overridden by the client.
+     */
+    timeout?: number;
+    /**
+     * The Relying Party's requirements regarding user verification for the get()
+     * operation. The value SHOULD be a member of UserVerificationRequirement but
+     * client platforms MUST ignore unknown values, treating an unknown value as if
+     * the member does not exist. Eligible authenticators are filtered to only those
+     * capable of satisfying this requirement.
+     */
+    userVerification?: 'required' | 'preferred' | 'discouraged';
+};
+
+/**
+ * AuthInitResponseBody result type (default view)
+ */
+type AuthAuthInitResponseBody = {
+    assertionOptions: publicKeyCredentialRequestOptionsResponseBody;
+    /**
+     * An opaque object containing session data.
+     */
+    session: string;
+};
+
+declare class AuthService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Complete WebAuthn registration
+     * @returns AuthAuthCompleteResponseBody OK response.
+     * @throws ApiError
+     */
+    authAuthComplete({ authCompleteRequestBody, }: {
+        authCompleteRequestBody: AuthAuthCompleteRequestBody;
+    }): CancelablePromise<AuthAuthCompleteResponseBody>;
+    /**
+     * Start WebAuthn registration flow
+     * @returns AuthAuthInitResponseBody OK response.
+     * @throws ApiError
+     */
+    authAuthInit({ authInitRequestBody, userAgent, }: {
+        authInitRequestBody: AuthAuthInitRequestBody;
+        /**
+         * Raw user-agent header as set by a browser
+         */
+        userAgent?: string;
+    }): CancelablePromise<AuthAuthInitResponseBody>;
+}
+
+type PasskeysPasskeyRenameRequestBody = {
+    /**
+     * Internal passkey identifier
+     */
+    name: string;
+};
+
+/**
+ * PasskeyResponse result type (default view)
+ */
+type PasskeyResponse = {
+    /**
+     * Timestamp in RFC3339 format.
+     */
+    createdAt: string;
+    /**
+     * Device type
+     */
+    device: string;
+    /**
+     * PassKey ID
+     */
+    id: string;
+    /**
+     * Name of the passkey
+     */
+    name: string;
+};
+
+/**
+ * PasskeysListResponseBody is the result type for an array of PasskeyResponse (default view)
+ */
+type PasskeysPasskeyResponseCollection = Array<PasskeyResponse>;
+
+declare class PasskeysService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * List passkeys
+     * **Required security scopes for jwt**:
+     * * `passkey:read`
+     * @returns PasskeysPasskeyResponseCollection OK response.
+     * @throws ApiError
+     */
+    passkeysPasskeysList({ authorization, }: {
+        /**
+         * Authorization token
+         */
+        authorization?: string;
+    }): CancelablePromise<PasskeysPasskeyResponseCollection>;
+    /**
+     * Rename passkey
+     * **Required security scopes for jwt**:
+     * * `passkey:write`
+     * @returns void
+     * @throws ApiError
+     */
+    passkeysPasskeyRename({ id, passkeyRenameRequestBody, authorization, }: {
+        /**
+         * Internal passkey identifier
+         */
+        id: string;
+        passkeyRenameRequestBody: PasskeysPasskeyRenameRequestBody;
+        /**
+         * Authorization token
+         */
+        authorization?: string;
+    }): CancelablePromise<void>;
+    /**
+     * Delete passkey
+     * **Required security scopes for jwt**:
+     * * `passkey:write`
+     * @returns void
+     * @throws ApiError
+     */
+    passkeysPasskeyDelete({ id, authorization, }: {
+        /**
+         * Internal passkey identifier
+         */
+        id: string;
+        /**
+         * Authorization token
+         */
+        authorization?: string;
+    }): CancelablePromise<void>;
+}
+
+type creationResultRequestBody = {
+    /**
+     * Base64 encoded byte array containing an attestation object, which is opaque to,
+     * and cryptographically protected against tampering by, the client.
+     */
+    attestationObject: string;
+    /**
+     * This attribute contains the authenticator data contained within attestationObject.
+     */
+    authenticatorData?: string;
+    /**
+     * Base64 encoded byte array which is a JSON-compatible serialization of client data
+     * passed to the authenticator by the client in order to generate this credential.
+     * The exact JSON serialization MUST be preserved, as the hash of the serialized
+     * client data has been computed over it.
+     */
+    clientDataJSON: string;
+    /**
+     * A base64 encoded byte sequence identifying a public key credential
+     * source and its authentication assertions.
+     */
+    credentialId: string;
+    /**
+     * Base64 encoded DER SubjectPublicKeyInfo of the new credential, or null if this is
+     * not available.
+     */
+    publicKey?: string;
+    publicKeyAlgorithm?: number;
+    /**
+     * These values are the transports that the authenticator is believed to support,
+     * or an empty sequence if the information is unavailable.
+     */
+    transports?: Array<'usb' | 'nfc' | 'ble' | 'internal'>;
+};
+
+type RegRegCompleteRequestBody = {
+    creationResult: creationResultRequestBody;
+    /**
+     * An opaque object containing session data.
+     */
+    session: string;
+};
+
+/**
+ * RegCompleteResponseBody result type (default view)
+ */
+type RegRegCompleteResponseBody = {
+    /**
+     * JWT access token
+     */
+    jwtAccess: string;
+};
+
+type RegRegInitRequestBody = {
+    app: applicationRequestBody;
+    deviceInfo: deviceInfoRequestBody;
+    /**
+     * Set of authentication factors:
+     * - Single factor: Username (i.e. email or phone) + FIDO2 credential;
+     * - Two factor: Username + password + FIDO2 credential;
+     * - Passwordless: FIDO2 discoverable credentials;
+     * - Passwordless + MFA: FIDO2 discoverable credentials + PIN;
+     */
+    mfa?: Array<'fido2' | 'email' | 'phone' | 'password' | 'pin'>;
+    user: userRequestBody;
+};
+
+type authenticatorSelectionCriteriaResponseBody = {
+    /**
+     * Authenticator attachment modality
+     */
+    authenticatorAttachment?: 'platform' | 'cross-platform';
+    /**
+     * Resident key requirement
+     */
+    requireResidentKey?: boolean;
+    /**
+     * Resident key requirement
+     */
+    residentKey?: 'discouraged' | 'preferred' | 'required';
+    /**
+     * Resident key requirement
+     */
+    userVerification?: 'required' | 'preferred' | 'discouraged';
+};
+
+/**
+ * Additional parameters when creating a new credential.
+ */
+type publicKeyCredentialParametersResponseBody = {
+    /**
+     * A cryptographic signature algorithm with which the newly generated credential
+     * will be used, and thus also the type of asymmetric key pair to be generated,
+     * e.g., RSA or Elliptic Curve.
+     */
+    alg?: -7 | -35 | -36 | -257 | -8;
+    type?: 'public-key';
+};
+
+/**
+ * Data about the Relying Party responsible for the request.
+ */
+type publicKeyCredentialRpEntityResponseBody = {
+    /**
+     * A unique identifier for the Relying Party entity, which sets the RP ID.
+     */
+    id?: string;
+    /**
+     * Relaying party name
+     */
+    name: string;
+};
+
+/**
+ * Data about the user account for which the Relying Party is requesting attestation
+ */
+type publicKeyCredentialUserEntityResponseBody = {
+    displayName: string;
+    id: string;
+    name: string;
+};
+
+type publicKeyCredentialCreationOptionsResponseBody = {
+    /**
+     * A preference for attestation conveyance.
+     */
+    attestation?: 'none' | 'indirect' | 'direct' | 'enterprise';
+    authenticatorSelection?: authenticatorSelectionCriteriaResponseBody;
+    /**
+     * This base64 encoded byte array represents a challenge that
+     * the selected authenticator signs, along with other data, when
+     * producing an authentication assertion.
+     */
+    challenge: string;
+    /**
+     * List of credentials to limit the creation of multiple credentials for the same
+     * account on a single authenticator. The client is requested to return an error
+     * if the new credential would be created on an authenticator that also contains
+     * one of the credentials enumerated in this parameter.
+     */
+    excludeCredentials?: Array<pubKeyCredentialDescriptorResponseBody>;
+    /**
+     * Additional parameters requesting processing by the client and authenticator.
+     */
+    extensions?: Record<string, string>;
+    /**
+     * This member contains information about the desired properties of the credential
+     * to be created. The sequence is ordered from most preferred to least preferred.
+     * The client makes a best-effort to create the most preferred credential that it
+     * can.
+     */
+    pubKeyCredParams: Array<publicKeyCredentialParametersResponseBody>;
+    rp: publicKeyCredentialRpEntityResponseBody;
+    /**
+     * This OPTIONAL member specifies a time, in milliseconds,
+     * that the caller is willing to wait for the call to complete. The
+     * value is treated as a hint, and MAY be overridden by the client.
+     */
+    timeout?: number;
+    user: publicKeyCredentialUserEntityResponseBody;
+};
+
+/**
+ * RegInitResponseBody result type (default view)
+ */
+type RegRegInitResponseBody = {
+    registrationRequestOptions: publicKeyCredentialCreationOptionsResponseBody;
+    /**
+     * An opaque object containing session data.
+     */
+    session: string;
+};
+
+declare class RegService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Complete WebAuthn registration flow
+     * @returns RegRegCompleteResponseBody OK response.
+     * @throws ApiError
+     */
+    regRegComplete({ regCompleteRequestBody, }: {
+        regCompleteRequestBody: RegRegCompleteRequestBody;
+    }): CancelablePromise<RegRegCompleteResponseBody>;
+    /**
+     * Start WebAuthn registration flow
+     * @returns RegRegInitResponseBody OK response.
+     * @throws ApiError
+     */
+    regRegInit({ regInitRequestBody, userAgent, }: {
+        regInitRequestBody: RegRegInitRequestBody;
+        /**
+         * Raw user-agent header as set by a browser
+         */
+        userAgent?: string;
+    }): CancelablePromise<RegRegInitResponseBody>;
+}
+
+/**
+ * VersionShowResponseBody result type (default view)
+ */
+type VersionVersionShowResponseBody = {
+    /**
+     * Version hash
+     */
+    hash?: string;
+    /**
+     * Software version
+     */
+    version: string;
+};
+
+declare class VersionService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Show software version
+     * @returns VersionVersionShowResponseBody OK response.
+     * @throws ApiError
+     */
+    versionVersionShow(): CancelablePromise<VersionVersionShowResponseBody>;
+}
+
+type HttpRequestConstructor = new (config: OpenAPIConfig) => BaseHttpRequest;
+declare class LoginIDService {
+    readonly auth: AuthService;
+    readonly passkeys: PasskeysService;
+    readonly reg: RegService;
+    readonly version: VersionService;
+    readonly request: BaseHttpRequest;
+    constructor(config?: Partial<OpenAPIConfig>, HttpRequest?: HttpRequestConstructor);
+}
+
+type ApiResult = {
+    readonly url: string;
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+};
+
+declare class ApiError extends Error {
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+    readonly request: ApiRequestOptions;
+    constructor(request: ApiRequestOptions, response: ApiResult, message: string);
+}
+
+type UsernameType = userRequestBody['usernameType'];
+type DeviceInfoRequestBody = deviceInfoRequestBody;
+type MFA = RegRegInitRequestBody['mfa'];
+type Transports = creationResultRequestBody['transports'];
+interface LoginIDConfig {
+    baseUrl: string;
+    appId: string;
+}
+interface PasskeyOptions {
+    token?: string;
+    displayName?: string;
+    usernameType?: UsernameType;
+}
+interface AuthenticateWithPasskeysOptions extends PasskeyOptions {
+    autoFill?: boolean;
+    abortSignal?: AbortSignal;
+}
+interface RegisterWithPasskeyOptions extends PasskeyOptions {
+    mfa?: MFA;
+}
+interface PasskeyResult {
+    jwtAccess: string;
+}
+
+/**
+ * Provides a base class for integrating with the LoginID API services.
+ * This class initializes the common configuration and service needed for derived classes to interact with LoginID services.
+ */
+declare class LoginIDBase {
+    /**
+     * Holds the configuration settings for the LoginID integration, including API base URL.
+     */
+    protected readonly config: LoginIDConfig;
+    /**
+     * Instance of LoginIDService, providing access to the LoginID API methods.
+     */
+    protected readonly service: LoginIDService;
+    /**
+     * Constructs a new instance of the LoginIDBase class, initializing the service with the provided configuration.
+     * @param {LoginIDConfig} config Configuration object for LoginID API, including the base URL.
+     */
+    constructor(config: LoginIDConfig);
+}
+
+/**
+ * Extends LoginIDBase to support creation, registration, and authentication of passkeys.
+ */
+declare class Passkeys extends LoginIDBase {
+    private jwtAccess;
+    /**
+     * Initializes a new Passkeys instance with the provided configuration.
+     * @param {LoginIDConfig} config Configuration object for LoginID.
+     */
+    constructor(config: LoginIDConfig);
+    /**
+     * Creates a navigator credential using WebAuthn.
+     * @param {RegRegInitResponseBody} regInitResponseBody The response body from registration initialization.
+     * @returns {Promise<RegRegCompleteRequestBody>} Completion request body for registration.
+     */
+    createNavigatorCredential(regInitResponseBody: RegRegInitResponseBody): Promise<RegRegCompleteRequestBody>;
+    /**
+     * Registers a user with a passkey.
+     * @param {string} username Username to register.
+     * @param {RegisterWithPasskeysOptions} options Additional registration options.
+     * @returns {Promise<any>} Result of the registration operation.
+     */
+    registerWithPasskey(username: string, options?: RegisterWithPasskeyOptions): Promise<PasskeyResult>;
+    /**
+     * Retrieves a navigator credential for authentication.
+     * @param {AuthAuthInitResponseBody} authInitResponseBody The response body from authentication initialization.
+     * @param {AuthenticateWithPasskeysOptions} options Additional options for authentication.
+     * @returns {Promise<AuthAuthCompleteRequestBody>} Completion request body for authentication.
+     */
+    getNavigatorCredential(authInitResponseBody: AuthAuthInitResponseBody, options?: AuthenticateWithPasskeysOptions): Promise<AuthAuthCompleteRequestBody>;
+    /**
+     * Authenticates a user with a passkey.
+     * @param {string} username Username to authenticate.
+     * @param {AuthenticateWithPasskeysOptions} options Additional authentication options.
+     * @returns {Promise<any>} Result of the authentication operation.
+     */
+    authenticateWithPasskey(username: string, options?: AuthenticateWithPasskeysOptions): Promise<PasskeyResult>;
+    /**
+     * Retrieves the JWT access token.
+     * @returns {string} The JWT access token.
+     */
+    getJWTAccess(): string;
+}
+
+/**
+ * Extends LoginIDBase to manage Passkeys, including listing, renaming, and deleting passkeys.
+ */
+declare class PasskeyManager extends LoginIDBase {
+    /**
+     * Initializes a new instance of PasskeyManager with the provided configuration.
+     * @param {LoginIDConfig} config Configuration object for LoginID.
+     */
+    constructor(config: LoginIDConfig);
+    /**
+     * Lists all passkeys associated with the account identified by the authToken.
+     * @param {string} authToken Authorization token to authenticate the request.
+     * @returns {Promise<PasskeysPasskeyResponseCollection>} A collection of passkeys.
+     */
+    listPasskeys(authToken: string): Promise<PasskeysPasskeyResponseCollection>;
+    /**
+     * Renames a specified passkey.
+     * @param {string} authToken Authorization token to authenticate the request.
+     * @param {string} id The ID of the passkey to rename.
+     * @param {string} name The new name for the passkey.
+     * @returns {Promise<null>} A promise that resolves to null upon successful completion.
+     */
+    renamePasskey(authToken: string, id: string, name: string): Promise<null>;
+    /**
+     * Deletes a specified passkey.
+     * @param {string} authToken Authorization token to authenticate the request.
+     * @param {string} id The ID of the passkey to delete.
+     * @returns {Promise<null>} A promise that resolves to null upon successful deletion.
+     */
+    deletePasskey(authToken: string, id: string): Promise<null>;
+}
+
+interface LoginIDWebSDK extends Passkeys, PasskeyManager {
+}
+declare class LoginIDWebSDK extends LoginIDBase {
+    constructor(config: LoginIDConfig);
+}
+
+type PasskeyErrorCode = 'ERROR_PASSKEY_ABORTED' | 'ERROR_DISCOVERABLE_CREDENTIALS_UNSUPPORTED' | 'ERROR_USER_VERIFICATION_UNSUPPORTED' | 'ERROR_PASSKEY_EXISTS' | 'ERROR_GENERAL_ERROR_SEE_CAUSE_FIELD' | 'ERROR_ALGORITHMS_UNSUPPORTED' | 'ERROR_DOMAIN_MISMATCH' | 'ERROR_AUTHENTICATOR_UNKNOWN_ERROR';
+
+/**
+ * Error class for passkey-related errors.
+ */
+declare class PasskeyError extends Error {
+    readonly code: PasskeyErrorCode;
+    /**
+     * Initializes a new instance of PasskeyError with the provided message, code, and original error.
+     *
+     * @type {Error}
+     * @memberof PasskeyError
+     */
+    constructor(message: string, code: PasskeyErrorCode, originalError: Error);
+}
+
+/**
+ * Asynchronously creates a passkey credential using the provided registration response.
+ *
+ * @param {IRegisterPasskeyInitResponse} init - The registration initiation response.
+ * @returns {Promise<PublicKeyCredential>} A promise that resolves to the passkey credential.
+ * @throws {LoginIdError} If any errors occur during credential creation or if the credential type is invalid.
+ */
+declare const createPasskeyCredential: (init: publicKeyCredentialCreationOptionsResponseBody) => Promise<PublicKeyCredential>;
+/**
+ * Asynchronously retrieves a passkey credential for authentication using the provided request options.
+ *
+ * @param {publicKeyCredentialRequestOptionsResponseBody} init - The authentication initiation response.
+ * @param {AuthenticateWithPasskeysOptions} options - Additional options for the authentication request.
+ * @returns {Promise<PublicKeyCredential>} A promise that resolves to the passkey credential.
+ */
+declare const getPasskeyCredential: (init: publicKeyCredentialRequestOptionsResponseBody, options?: AuthenticateWithPasskeysOptions) => Promise<PublicKeyCredential>;
+
+/**
+ * Checks if platform authenticator available
+ * */
+declare function isPlatformAuthenticatorAvailable(): Promise<boolean>;
+/**
+ * Checks if conditional UI is available
+ * */
+declare function isConditionalUIAvailable(): Promise<boolean>;
+interface DoesDeviceSupportPasskeysResponse {
+    solution: string;
+    deviceSupported: boolean;
+}
+/**
+ * Attempts to provide a solution for missing platform authenticator
+ */
+declare function doesDeviceSupportPasskeys(): Promise<DoesDeviceSupportPasskeysResponse>;
+
+export { ApiError, type AuthenticateWithPasskeysOptions, type DeviceInfoRequestBody, type DoesDeviceSupportPasskeysResponse, type LoginIDConfig, LoginIDWebSDK, type MFA, PasskeyError, type PasskeyOptions, type PasskeyResult, type RegisterWithPasskeyOptions, type Transports, type UsernameType, createPasskeyCredential, LoginIDWebSDK as default, doesDeviceSupportPasskeys, getPasskeyCredential, isConditionalUIAvailable, isPlatformAuthenticatorAvailable };