@loginid/websdk3 1.0.0 → 1.1.0

package/dist/index.d.ts

@@ -0,0 +1,881 @@
+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 AuthenticatorAssertionResponse = {
+    /**
+     * 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 AuthCompleteRequestBody = {
+    assertionResult: AuthenticatorAssertionResponse;
+    /**
+     * An opaque object containing session data.
+     */
+    session: string;
+};
+
+type PubKeyCredentialDescriptor = {
+    /**
+     * Base64 encoded byte array of the public key identifier.
+     */
+    id: string;
+    transports?: Array<'usb' | 'nfc' | 'ble' | 'internal' | 'hybrid'>;
+    type: 'public-key';
+};
+
+type PublicKeyCredentialRequestOptions = {
+    /**
+     * 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<PubKeyCredentialDescriptor>;
+    /**
+     * 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';
+};
+
+type AuthInit = {
+    assertionOptions: PublicKeyCredentialRequestOptions;
+    /**
+     * An opaque object containing session data.
+     */
+    session: string;
+};
+
+/**
+ * Application making the request. It contains additional info about the caller
+ * to distinguish between tenants.
+ */
+type Application = {
+    /**
+     * 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 DeviceInfo = {
+    /**
+     * 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 User = {
+    /**
+     * Display Name
+     */
+    displayName?: string;
+    /**
+     * Username
+     */
+    username: string;
+    /**
+     * Username type
+     */
+    usernameType: 'email' | 'phone';
+};
+
+type AuthInitRequestBody = {
+    app: Application;
+    deviceInfo: DeviceInfo;
+    user?: User;
+};
+
+type JWT = {
+    /**
+     * JWT access token
+     */
+    jwtAccess: string;
+};
+
+declare class AuthService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Complete WebAuthn registration
+     * @returns JWT OK response.
+     * @throws ApiError
+     */
+    authAuthComplete({ requestBody, }: {
+        requestBody: AuthCompleteRequestBody;
+    }): CancelablePromise<JWT>;
+    /**
+     * Start WebAuthn registration flow
+     * @returns AuthInit OK response.
+     * @throws ApiError
+     */
+    authAuthInit({ requestBody, userAgent, }: {
+        requestBody: AuthInitRequestBody;
+        /**
+         * Raw user-agent header as set by a browser
+         */
+        userAgent?: string;
+    }): CancelablePromise<AuthInit>;
+}
+
+type Passkey = {
+    /**
+     * Timestamp in RFC3339 format.
+     */
+    createdAt: string;
+    /**
+     * Device type
+     */
+    device: string;
+    /**
+     * PassKey ID
+     */
+    id: string;
+    /**
+     * Name of the passkey
+     */
+    name: string;
+};
+
+type PasskeyCollection = Array<Passkey>;
+
+type PasskeyRenameRequestBody = {
+    /**
+     * Internal passkey identifier
+     */
+    name: string;
+};
+
+declare class PasskeysService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * List passkeys
+     * @returns PasskeyCollection OK response.
+     * @throws ApiError
+     */
+    passkeysPasskeysList({ authorization }: {
+        authorization: string;
+    }): CancelablePromise<PasskeyCollection>;
+    /**
+     * Delete passkey
+     * @returns void
+     * @throws ApiError
+     */
+    passkeysPasskeyDelete({ id, authorization, }: {
+        /**
+         * Internal passkey identifier
+         */
+        id: string;
+        authorization: string;
+    }): CancelablePromise<void>;
+    /**
+     * Rename passkey
+     * @returns void
+     * @throws ApiError
+     */
+    passkeysPasskeyRename({ id, requestBody, authorization }: {
+        /**
+         * Internal passkey identifier
+         */
+        id: string;
+        requestBody: PasskeyRenameRequestBody;
+        authorization: string;
+    }): CancelablePromise<void>;
+}
+
+type CreationResult = {
+    /**
+     * 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' | 'hybrid'>;
+};
+
+type RegCompleteRequestBody = {
+    creationResult: CreationResult;
+    /**
+     * An opaque object containing session data.
+     */
+    session: string;
+};
+
+type AuthenticatorSelectionCriteria = {
+    /**
+     * 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 PublicKeyCredentialParameters = {
+    /**
+     * 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 PublicKeyCredentialRpEntity = {
+    /**
+     * 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 PublicKeyCredentialUserEntity = {
+    displayName: string;
+    id: string;
+    name: string;
+};
+
+type PublicKeyCredentialCreationOptions = {
+    /**
+     * A preference for attestation conveyance.
+     */
+    attestation?: 'none' | 'indirect' | 'direct' | 'enterprise';
+    authenticatorSelection?: AuthenticatorSelectionCriteria;
+    /**
+     * 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<PubKeyCredentialDescriptor>;
+    /**
+     * 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<PublicKeyCredentialParameters>;
+    rp: PublicKeyCredentialRpEntity;
+    /**
+     * 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: PublicKeyCredentialUserEntity;
+};
+
+type RegInit = {
+    registrationRequestOptions: PublicKeyCredentialCreationOptions;
+    /**
+     * An opaque object containing session data.
+     */
+    session: string;
+};
+
+type RegInitRequestBody = {
+    app: Application;
+    deviceInfo: DeviceInfo;
+    /**
+     * 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: User;
+};
+
+declare class RegService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Complete WebAuthn registration flow
+     * @returns JWT OK response.
+     * @throws ApiError
+     */
+    regRegComplete({ requestBody, }: {
+        requestBody: RegCompleteRequestBody;
+    }): CancelablePromise<JWT>;
+    /**
+     * Start WebAuthn registration flow
+     * @returns RegInit OK response.
+     * @throws ApiError
+     */
+    regRegInit({ requestBody, userAgent, }: {
+        requestBody: RegInitRequestBody;
+        /**
+         * Raw user-agent header as set by a browser
+         */
+        userAgent?: string;
+    }): CancelablePromise<RegInit>;
+}
+
+type TokenVerifyRequestBody = {
+    /**
+     * JWT access token
+     */
+    jwtAccess: string;
+};
+
+declare class TokenService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Validate JWT Access Token
+     * @returns void
+     * @throws ApiError
+     */
+    tokenTokenVerify({ requestBody, }: {
+        requestBody: TokenVerifyRequestBody;
+    }): CancelablePromise<void>;
+}
+
+type TxComplete = {
+    authCred?: Passkey;
+    /**
+     * Internal passkey identifier
+     */
+    credentialId: string;
+    /**
+     * JWT access token
+     */
+    jwtAccess: string;
+    /**
+     * Random string generated by LoginID.
+     */
+    lNonce: string;
+    /**
+     * Random string.
+     */
+    nonce: string;
+    /**
+     * Computed hash value of the transaction.
+     */
+    txHash: string;
+    /**
+     * Internal transaction identifier
+     */
+    txId: string;
+};
+
+type TxCompleteRequestBody = {
+    /**
+     * 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.
+     */
+    clientData: string;
+    /**
+     * Identified of the passkey credential.
+     */
+    keyHandle: string;
+    /**
+     * An opaque object containing session data.
+     */
+    session: string;
+    /**
+     * Base64 encoded the raw signature returned from the authenticator.
+     */
+    signature: string;
+};
+
+type TxInit = {
+    assertionOptions: PublicKeyCredentialRequestOptions;
+    /**
+     * An opaque object containing session data.
+     */
+    session: string;
+    /**
+     * Internal transaction identifier
+     */
+    txId: string;
+};
+
+type TxInitRequestBody = {
+    /**
+     * Random string
+     */
+    nonce: string;
+    /**
+     * Payload of transaction
+     */
+    txPayload: string;
+    /**
+     * Type of transaction
+     */
+    txType: string;
+    /**
+     * Username of user
+     */
+    username: string;
+};
+
+declare class TxService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Complete transaction confirmation
+     * @returns TxComplete OK response.
+     * @throws ApiError
+     */
+    txTxComplete({ requestBody, }: {
+        requestBody: TxCompleteRequestBody;
+    }): CancelablePromise<TxComplete>;
+    /**
+     * Start transaction confirmation flow
+     * @returns TxInit OK response.
+     * @throws ApiError
+     */
+    txTxInit({ requestBody, }: {
+        requestBody: TxInitRequestBody;
+    }): CancelablePromise<TxInit>;
+}
+
+type Version = {
+    /**
+     * Version hash
+     */
+    hash?: string;
+    /**
+     * Software version
+     */
+    version: string;
+};
+
+declare class VersionService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Show software version
+     * @returns Version OK response.
+     * @throws ApiError
+     */
+    versionVersionShow(): CancelablePromise<Version>;
+}
+
+type HttpRequestConstructor = new (config: OpenAPIConfig) => BaseHttpRequest;
+declare class LoginIDService {
+    readonly auth: AuthService;
+    readonly passkeys: PasskeysService;
+    readonly reg: RegService;
+    readonly token: TokenService;
+    readonly tx: TxService;
+    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 = User['usernameType'];
+type DeviceInfoRequestBody = DeviceInfo;
+type MFA = RegInitRequestBody['mfa'];
+type Transports = CreationResult['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 ConfirmTransactionOptions extends Partial<Pick<TxInitRequestBody, 'txType'>> {
+}
+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 {RegInit} regInitResponseBody The response body from registration initialization.
+     * @returns {Promise<RegRegCompleteRequestBody>} Completion request body for registration.
+     */
+    createNavigatorCredential(regInitResponseBody: RegInit): Promise<RegCompleteRequestBody>;
+    /**
+     * 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 {AuthInit} authInitResponseBody The response body from authentication initialization.
+     * @param {AuthenticateWithPasskeysOptions} options Additional options for authentication.
+     * @returns {Promise<AuthAuthCompleteRequestBody>} Completion request body for authentication.
+     */
+    getNavigatorCredential(authInitResponseBody: AuthInit, options?: AuthenticateWithPasskeysOptions): Promise<AuthCompleteRequestBody>;
+    /**
+     * 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>;
+    /**
+     * Confirms a transaction using a passkey.
+     *
+     * This method initiates a transaction confirmation process by generating a transaction-specific challenge
+     * and then expects the client to provide an assertion response using a passkey.
+     * This method is useful for confirming actions such as payments
+     * or changes to sensitive account information, ensuring that the transaction is being authorized
+     * by the rightful owner of the passkey.
+     *
+     * @param {string} username The username of the user confirming the transaction.
+     * @param {string} txPayload The transaction-specific payload, which could include details
+     * such as the transaction amount, recipient, and other metadata necessary for the transaction.
+     * @param {ConfirmTransactionOptions} [options={}] Optional parameters for transaction confirmation.
+     * @returns {Promise<any>} A promise that resolves with the result of the transaction confirmation operation.
+     * The result includes details about the transaction's details and includes a new JWT access token.
+     */
+    confirmTransaction(username: string, txPayload: string, nonce: string, options?: ConfirmTransactionOptions): Promise<TxComplete>;
+    /**
+     * 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<PasskeyCollection>;
+    /**
+     * 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: PublicKeyCredentialCreationOptions) => 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: PublicKeyCredentialRequestOptions, 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 ConfirmTransactionOptions, 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 };