@0xkey-io/core 0.1.0

package/dist/__clients__/core.d.ts

@@ -0,0 +1,1201 @@
+import { ZeroXKeySDKClientBase } from "../__generated__/sdk-client-base";
+import { type TDeleteSubOrganizationResponse, type Session, type TStampLoginResponse, type v1SignRawPayloadResult, type v1User, type ProxyTGetWalletKitConfigResponse, type v1PrivateKey, type WalletAuthResult, type BaseAuthResult, type PasskeyAuthResult, type v1BootProof, type TGetSendTransactionStatusResponse, AuthAction } from "@0xkey-io/sdk-types";
+import { Chain, type ExportBundle, type ZeroXKeySDKClientConfig, type WalletAccount, type Wallet, type WalletManagerBase, type WalletProvider, type CreatePasskeyParams, type CreatePasskeyResult, type LogoutParams, type LoginWithPasskeyParams, type SignUpWithPasskeyParams, type SwitchWalletAccountChainParams, type LoginWithWalletParams, type SignUpWithWalletParams, type LoginOrSignupWithWalletParams, type InitOtpParams, type InitOtpResult, type VerifyOtpParams, type VerifyOtpResult, type LoginWithOtpParams, type SignUpWithOtpParams, type CompleteOtpParams, type CompleteOauthParams, type LoginWithOauthParams, type SignUpWithOauthParams, type FetchWalletsParams, type FetchWalletAccountsParams, type FetchPrivateKeysParams, type SignMessageParams, type SignTransactionParams, type SignAndSendTransactionParams, type EthSendErc20TransferParams, type EthSendTransactionParams, type SolSendTransactionParams, type FetchUserParams, type FetchOrCreateP256ApiKeyUserParams, type FetchOrCreatePoliciesParams, type FetchOrCreatePoliciesResult, type UpdateUserEmailParams, type RemoveUserEmailParams, type UpdateUserPhoneNumberParams, type RemoveUserPhoneNumberParams, type UpdateUserNameParams, type AddOauthProviderParams, type RemoveOauthProvidersParams, type AddPasskeyParams, type RemovePasskeyParams, type CreateWalletParams, type CreateWalletAccountsParams, type ExportWalletParams, type ExportPrivateKeyParams, type ExportWalletAccountParams, type ImportWalletParams, type ImportPrivateKeyParams, type DeleteSubOrganizationParams, type StoreSessionParams, type ClearSessionParams, type RefreshSessionParams, type GetSessionParams, type SetActiveSessionParams, type CreateApiKeyPairParams, type FetchBootProofForAppProofParams, type CreateHttpClientParams, type BuildWalletLoginRequestResult, type BuildWalletLoginRequestParams, type VerifyAppProofsParams, type PollTransactionStatusParams } from "../__types__";
+import { CrossPlatformApiKeyStamper } from "../__stampers__/api/base";
+import { CrossPlatformPasskeyStamper } from "../__stampers__/passkey/base";
+/**
+ * @internal
+ * Gathers all public methods exposed in our core client and turns it into a type that
+ * can be used to extend clients created for other packages built off core
+ *
+ * Should be used to keep any packages that extend this core package in sync with each
+ * other, meaning any new additions to core should also be reflected in those packages
+ */
+type PublicMethods<T> = {
+    [K in keyof T as T[K] extends Function ? K : never]: T[K];
+};
+export type ZeroXKeyClientMethods = Omit<PublicMethods<ZeroXKeyClient>, "init" | "config" | "httpClient" | "constructor">;
+export declare class ZeroXKeyClient {
+    config: ZeroXKeySDKClientConfig;
+    httpClient: ZeroXKeySDKClientBase;
+    private apiKeyStamper?;
+    private passkeyStamper?;
+    private walletManager?;
+    private storageManager;
+    constructor(config: ZeroXKeySDKClientConfig, apiKeyStamper?: CrossPlatformApiKeyStamper, passkeyStamper?: CrossPlatformPasskeyStamper, walletManager?: WalletManagerBase);
+    init(): Promise<void>;
+    /**
+     * Creates a new ZeroXKeySDKClientBase instance with the provided configuration.
+     * This method is used internally to create the HTTP client for making API requests,
+     * but can also be used to create an additional client with different configurations if needed.
+     * By default, it uses the configuration provided during the ZeroXKeyClient initialization.
+     *
+     * @param params - Optional configuration parameters to override the default client configuration.
+     * @param params.apiBaseUrl - The base URL of the ZeroXKey API (defaults to `https://api.0xkey.com` if not provided).
+     * @param params.organizationId - The organization ID to associate requests with.
+     * @param params.authProxyUrl - The base URL of the Auth Proxy (defaults to `https://authproxy.0xkey.com` if not provided).
+     * @param params.authProxyConfigId - The configuration ID to use when making Auth Proxy requests.
+     * @param params.defaultStamperType - The default stamper type to use for signing requests
+     *   (overrides automatic detection of ApiKey, Passkey, or Wallet stampers).
+     *
+     * @returns A new instance of {@link ZeroXKeySDKClientBase} configured with the provided parameters.
+     */
+    createHttpClient: (params?: CreateHttpClientParams) => ZeroXKeySDKClientBase;
+    /**
+     * Creates a new passkey authenticator for the user.
+     *
+     * - This function generates a new passkey attestation and challenge, suitable for registration with the user's device.
+     * - Handles both web and React Native environments, automatically selecting the appropriate passkey creation flow.
+     * - The resulting attestation and challenge can be used to register the passkey with ZeroXKey.
+     *
+     * @param params.name - display name for the passkey (defaults to a generated name based on the current timestamp).
+     * @param params.challenge - challenge string to use for passkey registration. If not provided, a new challenge will be generated.
+     * @returns A promise that resolves to {@link CreatePasskeyResult}
+     * @throws {ZeroXKeyError} If there is an error during passkey creation, or if the platform is unsupported.
+     */
+    createPasskey: (params: CreatePasskeyParams) => Promise<CreatePasskeyResult>;
+    /**
+     * Logs out the current client session.
+     *
+     * - This function clears the specified session and removes any associated key pairs from storage.
+     * - If a sessionKey is provided, it logs out from that session; otherwise, it logs out from the active session.
+     * - Cleans up any api keys associated with the session.
+     *
+     * @param params.sessionKey - session key to specify which session to log out from (defaults to the active session).
+     * @returns A promise that resolves when the logout process is complete.
+     * @throws {ZeroXKeyError} If there is no active session or if there is an error during the logout process.
+     */
+    logout: (params?: LogoutParams) => Promise<void>;
+    /**
+     * Logs in a user using a passkey, optionally specifying the public key, session key, and session expiration.
+     *
+     * - This function initiates the login process with a passkey and handles session creation and storage.
+     * - If a public key is not provided, a new key pair will be generated for authentication.
+     * - If a session key is not provided, the default session key will be used.
+     * - The session expiration can be customized via the expirationSeconds parameter.
+     * - Handles cleanup of unused key pairs if login fails.
+     *
+     * @param params.publicKey - public key to use for authentication. If not provided, a new key pair will be generated.
+     * @param params.sessionKey - session key to use for session creation (defaults to the default session key).
+     * @param params.expirationSeconds - session expiration time in seconds (defaults to the configured default).
+     * @param params.organizationId - organization ID to target (defaults to the session's organization ID or the parent organization ID).
+     * @returns A promise that resolves to a {@link PasskeyAuthResult}, which includes:
+     *          - `sessionToken`: the signed JWT session token.
+     *          - `credentialId`: an empty string.
+     * @throws {ZeroXKeyError} If there is an error during the passkey login process or if the user cancels the passkey prompt.
+     */
+    loginWithPasskey: (params?: LoginWithPasskeyParams) => Promise<PasskeyAuthResult>;
+    /**
+     * Signs up a user using a passkey, creating a new sub-organization and session.
+     *
+     * - This function creates a new passkey authenticator and uses it to register a new sub-organization for the user.
+     * - Handles both passkey creation and sub-organization creation in a single flow.
+     * - Optionally accepts additional sub-organization parameters, a custom session key, a custom passkey display name, and a custom session expiration.
+     * - Automatically generates a new API key pair for authentication and session management.
+     * - Stores the resulting session token and manages cleanup of unused key pairs.
+     *
+     * @param params.passkeyDisplayName - display name for the passkey (defaults to a generated name based on the current timestamp).
+     * @param params.challenge - challenge string to use for passkey registration. If not provided, a new challenge will be generated.
+     * @param params.expirationSeconds - session expiration time in seconds (defaults to the configured default).
+     * @param params.createSubOrgParams - parameters for creating a sub-organization (e.g., authenticators, user metadata).
+     * @param params.sessionKey - session key to use for storing the session (defaults to the default session key).
+     * @param params.organizationId - organization ID to target (defaults to the session's organization ID or the parent organization ID).
+     * @returns A promise that resolves to a {@link PasskeyAuthResult}, which includes:
+     *          - `sessionToken`: the signed JWT session token.
+     *          - `credentialId`: the credential ID associated with the passkey created.
+     * @throws {ZeroXKeyError} If there is an error during passkey creation, sub-organization creation, or session storage.
+     */
+    signUpWithPasskey: (params?: SignUpWithPasskeyParams) => Promise<PasskeyAuthResult>;
+    /**
+     * Retrieves wallet providers from the initialized wallet manager.
+     *
+     * - Optionally filters providers by the specified blockchain chain.
+     * - Throws an error if the wallet manager is not initialized.
+     *
+     * @param chain - optional blockchain chain to filter the returned providers.
+     * @returns A promise that resolves to an array of wallet providers.
+     * @throws {ZeroXKeyError} If the wallet manager is uninitialized or provider retrieval fails.
+     */
+    fetchWalletProviders: (chain?: Chain) => Promise<WalletProvider[]>;
+    /**
+     * Connects the specified wallet account.
+     *
+     * - Requires the wallet manager and its connector to be initialized.
+     *
+     * @param walletProvider - wallet provider to connect.
+     * @returns A promise that resolves with the connected wallet's address.
+     * @throws {ZeroXKeyError} If the wallet manager is uninitialized or the connection fails.
+     */
+    connectWalletAccount: (walletProvider: WalletProvider) => Promise<string>;
+    /**
+     * Disconnects the specified wallet account.
+     *
+     * - Requires the wallet manager and its connector to be initialized.
+     *
+     * @param walletProvider - wallet provider to disconnect.
+     * @returns A promise that resolves once the wallet account is disconnected.
+     * @throws {ZeroXKeyError} If the wallet manager is uninitialized or the disconnection fails.
+     */
+    disconnectWalletAccount: (walletProvider: WalletProvider) => Promise<void>;
+    /**
+     * Switches the wallet provider associated with a given wallet account
+     * to a different chain.
+     *
+     * - Requires the wallet manager and its connector to be initialized
+     * - Only works for connected wallet accounts
+     * - Looks up the provider for the given account address
+     * - Does nothing if the provider is already on the desired chain.
+     *
+     * @param params.walletAccount - The wallet account whose provider should be switched.
+     * @param params.chainOrId - The target chain, specified as a chain ID string or a SwitchableChain object.
+     * @param params.walletProviders - Optional list of wallet providers to search; falls back to `fetchWalletProviders()` if omitted.
+     * @returns A promise that resolves once the chain switch is complete.
+     *
+     * @throws {ZeroXKeyError} If the wallet manager is uninitialized, the provider is not connected, or the switch fails.
+     */
+    switchWalletAccountChain: (params: SwitchWalletAccountChainParams) => Promise<void>;
+    /**
+     * Builds and signs a wallet login request without submitting it to ZeroXKey.
+     *
+     * - This function prepares a signed request for wallet authentication, which can later be used
+     *   to log in or sign up a user with ZeroXKey.
+     * - It initializes the wallet stamper, ensures a valid session public key (generating one if needed),
+     *   and signs the login intent with the connected wallet.
+     * - For Ethereum wallets, derives the public key from the stamped request header.
+     * - For Solana wallets, retrieves the public key directly from the connected wallet.
+     * - The signed request is not sent to ZeroXKey immediately; it is meant to be used in a subsequent flow
+     *   (e.g., `loginOrSignupWithWallet`) where sub-organization existence is verified or created first.
+     *
+     * @param params.walletProvider - the wallet provider used for authentication and signing.
+     * @param params.publicKey - optional pre-generated session public key (auto-generated if not provided).
+     * @param params.expirationSeconds - optional session expiration time in seconds (defaults to the configured default).
+     * @returns A promise resolving to an object containing:
+     *          - `signedRequest`: the signed wallet login request.
+     *          - `publicKey`: the public key associated with the signed request.
+     * @throws {ZeroXKeyError} If the wallet stamper is not initialized, the signing process fails,
+     *                        or the public key cannot be derived or generated.
+     */
+    buildWalletLoginRequest: (params: BuildWalletLoginRequestParams) => Promise<BuildWalletLoginRequestResult>;
+    /**
+     * Logs in a user using the specified wallet provider.
+     *
+     * - This function logs in a user by authenticating with the provided wallet provider via a wallet-based signature.
+     * - If a public key is not provided, a new one will be generated for authentication.
+     * - Optionally accepts a custom session key and session expiration time.
+     * - Stores the resulting session token under the specified session key, or the default session key if not provided.
+     * - Throws an error if a public key cannot be found or generated, or if the login process fails.
+     *
+     * @param params.walletProvider - wallet provider to use for authentication.
+     * @param params.publicKey - optional public key to associate with the session (generated if not provided).
+     * @param params.sessionKey - optional key to store the session under (defaults to the default session key).
+     * @param params.expirationSeconds - optional session expiration time in seconds (defaults to the configured default).
+     * @param params.organizationId - organization ID to target (defaults to the session's organization ID or the parent organization ID).
+     * @returns A promise that resolves to a {@link WalletAuthResult}, which includes:
+     *          - `sessionToken`: the signed JWT session token.
+     *          - `address`: the authenticated wallet address.
+     * @throws {ZeroXKeyError} If the wallet stamper is uninitialized, a public key cannot be found or generated, or login fails.
+     */
+    loginWithWallet: (params: LoginWithWalletParams) => Promise<WalletAuthResult>;
+    /**
+     * Signs up a user using a wallet, creating a new sub-organization and session.
+     *
+     * - This function creates a new wallet authenticator and uses it to register a new sub-organization for the user.
+     * - Handles both wallet authentication and sub-organization creation in a single flow.
+     * - Optionally accepts additional sub-organization parameters, a custom session key, and a custom session expiration.
+     * - Automatically generates additional API key pairs for authentication and session management.
+     * - Stores the resulting session token under the specified session key, or the default session key if not provided, and manages cleanup of unused key pairs.
+     *
+     * @param params.walletProvider - wallet provider to use for authentication.
+     * @param params.createSubOrgParams - parameters for creating a sub-organization (e.g., authenticators, user metadata).
+     * @param params.sessionKey - session key to use for storing the session (defaults to the default session key).
+     * @param params.expirationSeconds - session expiration time in seconds (defaults to the configured default).
+     * @param params.organizationId - organization ID to target (defaults to the session's organization ID or the parent organization ID).
+     * @returns A promise that resolves to a {@link WalletAuthResult}, which includes:
+     *          - `sessionToken`: the signed JWT session token.
+     *          - `address`: the authenticated wallet address.
+     * @throws {ZeroXKeyError} If there is an error during wallet authentication, sub-organization creation, session storage, or cleanup.
+     */
+    signUpWithWallet: (params: SignUpWithWalletParams) => Promise<WalletAuthResult>;
+    /**
+     * Logs in an existing user or signs up a new user using a wallet, creating a new sub-organization if needed.
+     *
+     * - This function attempts to log in the user by stamping a login request with the provided wallet.
+     * - If the wallet’s public key is not associated with an existing sub-organization, a new one is created.
+     * - Handles both wallet authentication and sub-organization creation in a single flow.
+     * - For Ethereum wallets, derives the public key from the signed request header; for Solana wallets, retrieves it directly from the wallet.
+     * - Optionally accepts additional sub-organization parameters, a custom session key, and a custom session expiration.
+     * - Stores the resulting session token under the specified session key, or the default session key if not provided.
+     *
+     * @param params.walletProvider - wallet provider to use for authentication.
+     * @param params.publicKey - optional public key to associate with the session (generated if not provided).
+     * @param params.createSubOrgParams - optional parameters for creating a sub-organization (e.g., authenticators, user metadata).
+     * @param params.sessionKey - session key to use for storing the session (defaults to the default session key).
+     * @param params.expirationSeconds - session expiration time in seconds (defaults to the configured default).
+     * @param params.organizationId - organization ID to target (defaults to the session's organization ID or the parent organization ID).
+     * @returns A promise that resolves to an object containing:
+     *          - `sessionToken`: the signed JWT session token.
+     *          - `address`: the authenticated wallet address.
+     *          - `action`: whether the flow resulted in a login or signup ({@link AuthAction}).
+     * @throws {ZeroXKeyError} If there is an error during wallet authentication, sub-organization creation, or session storage.
+     */
+    loginOrSignupWithWallet: (params: LoginOrSignupWithWalletParams) => Promise<WalletAuthResult & {
+        action: AuthAction;
+    }>;
+    /**
+     * Initializes the OTP process by sending an OTP code to the provided contact.
+     *
+     * - This function initiates the OTP flow by sending a one-time password (OTP) code to the user's contact information (email address or phone number) via the auth proxy.
+     * - Supports both email and SMS OTP types.
+     * - Returns an OTP ID that is required for subsequent OTP verification.
+     *
+     * @param params.otpType - type of OTP to initialize (OtpType.Email or OtpType.Sms).
+     * @param params.contact - contact information for the user (e.g., email address or phone number).
+     * @param params.organizationId - optional organization ID to target (defaults to the session's organization ID or the parent organization ID).
+     * @returns A promise that resolves to the OTP ID required for verification.
+     * @throws {ZeroXKeyError} If there is an error during the OTP initialization process or if the maximum number of OTPs has been reached.
+     */
+    initOtp: (params: InitOtpParams) => Promise<InitOtpResult>;
+    /**
+     * Verifies the OTP code sent to the user.
+     *
+     * - This function verifies the OTP code entered by the user against the OTP sent to their contact information (email or phone) using the auth proxy.
+     * - If verification is successful, it returns the sub-organization ID associated with the contact (if it exists) and a verification token.
+     * - The verification token can be used for subsequent login or sign-up flows.
+     * - Handles both email and SMS OTP types.
+     *
+     * @param params.otpId - ID of the OTP to verify (returned from `initOtp`).
+     * @param params.otpCode - OTP code entered by the user.
+     * @param params.contact - contact information for the user (e.g., email address or phone number).
+     * @param params.otpType - type of OTP being verified (OtpType.Email or OtpType.Sms).
+     * @param params.publicKey - public key the verification token is bound to for ownership verification (client signature verification during login/signup). This public key is optional; if not provided, a new key pair will be generated.
+     * @returns A promise that resolves to an object containing:
+     *   - subOrganizationId: sub-organization ID if the contact is already associated with a sub-organization, or an empty string if not.
+     *   - verificationToken: verification token to be used for login or sign-up.
+     * @throws {ZeroXKeyError} If there is an error during the OTP verification process, such as an invalid code or network failure.
+     */
+    verifyOtp: (params: VerifyOtpParams) => Promise<VerifyOtpResult>;
+    /**
+     * Logs in a user using an OTP verification token.
+     *
+     * - This function logs in a user using the verification token received after OTP verification (from email or SMS).
+     * - If a public key is not provided, a new API key pair will be generated for authentication.
+     * - Optionally invalidates any existing sessions for the user if `invalidateExisting` is set to true.
+     * - Stores the resulting session token under the specified session key, or the default session key if not provided.
+     * - Handles cleanup of unused key pairs if login fails.
+     *
+     * @param params.verificationToken - verification token received after OTP verification.
+     * @param params.publicKey - public key to use for authentication. If not provided, a new key pair will be generated.
+     * @param params.organizationId - optional organization ID to target (defaults to the verified subOrg ID linked to the verification token contact).
+     * @param params.invalidateExisting - flag to invalidate existing session for the user.
+     * @param params.sessionKey - session key to use for session creation (defaults to the default session key).
+     * @returns A promise that resolves to a {@link BaseAuthResult}, which includes:
+     *          - `sessionToken`: the signed JWT session token.
+     * @throws {ZeroXKeyError} If there is an error during the OTP login process or if key pair cleanup fails.
+     */
+    loginWithOtp: (params: LoginWithOtpParams) => Promise<BaseAuthResult>;
+    /**
+     * Signs up a user using an OTP verification token.
+     *
+     * - This function signs up a user using the verification token received after OTP verification (from email or SMS).
+     * - Creates a new sub-organization for the user with the provided parameters and associates the contact (email or phone) with the sub-organization.
+     * - Automatically generates a new API key pair for authentication and session management.
+     * - Stores the resulting session token under the specified session key, or the default session key if not provided.
+     * - Handles both email and SMS OTP types, and supports additional sub-organization creation parameters.
+     *
+     * @param params.verificationToken - verification token received after OTP verification.
+     * @param params.contact - contact information for the user (e.g., email address or phone number).
+     * @param params.otpType - type of OTP being used (OtpType.Email or OtpType.Sms).
+     * @param params.createSubOrgParams - parameters for creating a sub-organization (e.g., authenticators, user metadata).
+     * @param params.invalidateExisting - flag to invalidate existing session for the user.
+     * @param params.sessionKey - session key to use for session creation (defaults to the default session key).
+     * @returns A promise that resolves to a {@link BaseAuthResult}, which includes:
+     *          - `sessionToken`: the signed JWT session token.
+     * @throws {ZeroXKeyError} If there is an error during the OTP sign-up process or session storage.
+     */
+    signUpWithOtp: (params: SignUpWithOtpParams) => Promise<BaseAuthResult>;
+    /**
+     * Completes the OTP authentication flow by verifying the OTP code and then either signing up or logging in the user.
+     *
+     * - This function first verifies the OTP code for the provided contact and OTP type.
+     * - If the contact is not associated with an existing sub-organization, it will automatically create a new sub-organization and complete the sign-up flow.
+     * - If the contact is already associated with a sub-organization, it will complete the login flow.
+     * - Supports passing a custom public key for authentication, invalidating existing session, specifying a session key, and providing additional sub-organization creation parameters.
+     * - Handles both email and SMS OTP types.
+     *
+     * @param params.otpId - ID of the OTP to complete (returned from `initOtp`).
+     * @param params.otpCode - OTP code entered by the user.
+     * @param params.contact - contact information for the user (e.g., email address or phone number).
+     * @param params.otpType - type of OTP being completed (OtpType.Email or OtpType.Sms).
+     * @param params.publicKey - public key to use for authentication. If not provided, a new key pair may be generated.
+     * @param params.invalidateExisting - flag to invalidate existing sessions for the user.
+     * @param params.sessionKey - session key to use for session creation (defaults to the default session key).
+     * @param params.createSubOrgParams - parameters for sub-organization creation (e.g., authenticators, user metadata).
+     * @returns A promise that resolves to an object containing:
+     *          - `sessionToken`: the signed JWT session token.
+     *          - `verificationToken`: the OTP verification token.
+     *          - `action`: whether the flow resulted in a login or signup ({@link AuthAction}).
+     * @throws {ZeroXKeyError} If there is an error during OTP verification, sign-up, or login.
+     */
+    completeOtp: (params: CompleteOtpParams) => Promise<BaseAuthResult & {
+        verificationToken: string;
+        action: AuthAction;
+    }>;
+    /**
+     * Completes the OAuth authentication flow by either signing up or logging in the user, depending on whether a sub-organization already exists for the provided OIDC token.
+     *
+     * - This function first checks if there is an existing sub-organization associated with the OIDC token.
+     * - If a sub-organization exists, it proceeds with the OAuth login flow.
+     * - If no sub-organization exists, it creates a new sub-organization and completes the sign-up flow.
+     * - Optionally accepts a custom OAuth provider name, session key, and additional sub-organization creation parameters.
+     * - Handles session storage and management, and supports invalidating existing sessions if specified.
+     *
+     * @param params.oidcToken - OIDC token received after successful authentication with the OAuth provider.
+     * @param params.publicKey - public key to use for authentication. Must be generated prior to calling this function, this is because the OIDC nonce has to be set to `sha256(publicKey)`.
+     * @param params.providerName - name of the OAuth provider (defaults to a generated name with a timestamp).
+     * @param params.createSubOrgParams - parameters for sub-organization creation (e.g., authenticators, user metadata).
+     * @param params.invalidateExisting - flag to invalidate existing sessions for the user.
+     * @param params.sessionKey - session key to use for session creation (defaults to the default session key).
+     *
+     * @returns A promise that resolves to an object containing:
+     *          - `sessionToken`: the signed JWT session token.
+     *          - `action`: whether the flow resulted in a login or signup ({@link AuthAction}).
+     * @throws {ZeroXKeyError} If there is an error during the OAuth completion process, such as account lookup, sign-up, or login.
+     */
+    completeOauth: (params: CompleteOauthParams) => Promise<BaseAuthResult & {
+        action: AuthAction;
+    }>;
+    /**
+     * Logs in a user using OAuth authentication.
+     *
+     * - This function logs in a user using the provided OIDC token and public key.
+     * - Optionally invalidates any existing sessions for the user if `invalidateExisting` is set to true.
+     * - Stores the resulting session token under the specified session key, or the default session key if not provided.
+     * - Handles cleanup of unused key pairs if login fails.
+     *
+     * @param params.oidcToken - OIDC token received after successful authentication with the OAuth provider.
+     * @param params.publicKey - The public key bound to the login session. This key is required because it is directly
+     *                           tied to the nonce used during OIDC token generation and must match the value
+     *                           encoded in the token.
+     * @param params.organizationId - ID of the organization to target when creating the session.
+     * @param params.invalidateExisting - flag to invalidate existing sessions for the user.
+     * @param params.sessionKey - session key to use for session creation (defaults to the default session key).
+     * @returns A promise that resolves to a {@link BaseAuthResult}, which includes:
+     *          - `sessionToken`: the signed JWT session token.
+     * @throws {ZeroXKeyError} If there is an error during the OAuth login process or if key pair cleanup fails.
+     */
+    loginWithOauth: (params: LoginWithOauthParams) => Promise<BaseAuthResult>;
+    /**
+     * Signs up a user using OAuth authentication.
+     *
+     * - This function creates a new sub-organization for the user using the provided OIDC token, public key, and provider name.
+     * - Handles the full OAuth sign-up flow, including sub-organization creation and session management.
+     * - Optionally accepts additional sub-organization creation parameters and a custom session key.
+     * - After successful sign-up, automatically logs in the user and returns a signed JWT session token.
+     *
+     * @param params.oidcToken - OIDC token received after successful authentication with the OAuth provider.
+     * @param params.publicKey - public key to associate with the new sub-organization.
+     * @param params.providerName - name of the OAuth provider (e.g., "Google", "Apple").
+     * @param params.createSubOrgParams - parameters for sub-organization creation (e.g., authenticators, user metadata).
+     * @param params.sessionKey - session key to use for session creation (defaults to the default session key).
+     * @returns A promise that resolves to a {@link BaseAuthResult}, which includes:
+     *          - `sessionToken`: the signed JWT session token.
+     * @throws {ZeroXKeyError} If there is an error during the OAuth sign-up or login process.
+     */
+    signUpWithOauth: (params: SignUpWithOauthParams) => Promise<BaseAuthResult>;
+    /**
+     * Fetches all wallets for the current user, including both embedded and connected wallets.
+     *
+     * - Retrieves all wallets associated with the organizationId from the current active session.
+     * - For each embedded wallet, automatically fetches and attaches all associated wallet accounts.
+     * - For connected wallets (e.g., browser extensions or external providers), groups providers by wallet name and attaches all connected accounts.
+     * - Returns both embedded and connected wallets in a single array, each with their respective accounts populated.
+     * - Optionally allows stamping the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     *
+     * @param params.walletProviders - array of wallet providers to use for fetching wallets.
+     * @param params.organizationId - organization ID to target (defaults to the session's organization ID).
+     * @param params.userId - user ID to target (defaults to the session's user ID).
+     * @param params.connectedOnly - if true, fetches only connected wallets; if false or undefined, fetches both embedded and connected wallets.
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @returns A promise that resolves to an array of `Wallet` objects.
+     * @throws {ZeroXKeyError} If no active session is found or if there is an error fetching wallets.
+     */
+    fetchWallets: (params?: FetchWalletsParams) => Promise<Wallet[]>;
+    /**
+     * Fetches all accounts for a specific wallet, including both embedded and connected wallet accounts.
+     *
+     * - For embedded wallets, retrieves accounts from the ZeroXKey API, supporting pagination (defaults to the first page with a limit of 100 accounts).
+     * - For connected wallets (e.g., browser extensions or external providers), constructs account objects for each connected address from the provided or discovered wallet providers.
+     * - Automatically determines the account type and populates relevant fields such as address, curve, and signing capability.
+     * - Optionally allows filtering by a specific set of wallet providers and supports custom pagination options.
+     * - Supports stamping the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     *
+     * @param params.wallet - wallet for which to fetch accounts.
+     * @param params.walletProviders - list of wallet providers to filter by (used for connected wallets).
+     * @param params.paginationOptions - pagination options for embedded wallets.
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @param params.organizationId - organization ID to target (defaults to the session's organization ID).
+     * @param params.userId - user ID to target (defaults to the session's user ID).
+     * @param params.authenticatorAddresses - optional authenticator addresses to avoid redundant user fetches (this is used for connected wallets to determine if a connected wallet is an authenticator)
+     *
+     * @returns A promise that resolves to an array of `v1WalletAccount` objects.
+     * @throws {ZeroXKeyError} If no active session is found or if there is an error fetching wallet accounts.
+     */
+    fetchWalletAccounts: (params: FetchWalletAccountsParams) => Promise<WalletAccount[]>;
+    /**
+     * Fetches all private keys for the current user.
+     *
+     * - Retrieves private keys from the ZeroXKey API.
+     * - Supports stamping the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     *
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @param params.organizationId - organization ID to target (defaults to the session's organization ID).
+     * @returns A promise that resolves to an array of `v1PrivateKey` objects.
+     * @throws {ZeroXKeyError} If no active session is found or if there is an error fetching private keys.
+     */
+    fetchPrivateKeys: (params?: FetchPrivateKeysParams) => Promise<v1PrivateKey[]>;
+    /**
+     * Signs a message using the specified wallet account.
+     *
+     * Behavior differs depending on the wallet type:
+     *
+     * - **Connected wallets**
+     *   - Delegates signing to the wallet provider’s native signing method.
+     *   - *Ethereum*: signatures always follow [EIP-191](https://eips.ethereum.org/EIPS/eip-191).
+     *     - The wallet automatically prefixes messages with
+     *       `"\x19Ethereum Signed Message:\n" + message length` before signing.
+     *     - As a result, these signatures cannot be used as raw transaction signatures or broadcast on-chain.
+     *     - If `addEthereumPrefix` is set to `false`, an error is thrown because connected Ethereum wallets always prefix.
+     *   - *Other chains*: follows the native connected wallet behavior.
+     *
+     * - **Embedded wallets**
+     *   - Uses the ZeroXKey API to sign the message directly.
+     *   - Supports optional `addEthereumPrefix`:
+     *     - If `true` (default for Ethereum), the message is prefixed before signing.
+     *     - If `false`, the raw message is signed without any prefix.
+     *
+     * Additional details:
+     * - Automatically handles encoding and hashing based on the wallet account’s address format,
+     *   unless explicitly overridden.
+     * - Optionally allows stamping with a specific stamper
+     *   (`StamperType.Passkey`, `StamperType.ApiKey`, or `StamperType.Wallet`).
+     *
+     * @param params.message - plaintext (UTF-8) message to sign.
+     * @param params.walletAccount - wallet account to use for signing.
+     * @param params.encoding - override for payload encoding (defaults to the encoding appropriate for the address format).
+     * @param params.hashFunction - override for hash function (defaults to the function appropriate for the address format).
+     * @param params.stampWith - optional stamper for the signing request.
+     * @param params.addEthereumPrefix - whether to prefix the message with Ethereum’s
+     *   `"\x19Ethereum Signed Message:\n"` string (default: `true` for Ethereum).
+     * @param params.organizationId - organization ID to target (defaults to the session's organization ID).
+     *
+     * @returns A promise that resolves to a `v1SignRawPayloadResult` containing the signature and metadata.
+     * @throws {ZeroXKeyError} If signing fails, the wallet type does not support message signing, or the response is invalid.
+     */
+    signMessage: (params: SignMessageParams) => Promise<v1SignRawPayloadResult>;
+    /**
+     * Signs a transaction using the specified wallet account.
+     *
+     * Behavior differs depending on the type of wallet:
+     *
+     * - **Connected wallets**
+     *   - Ethereum: does not support raw transaction signing. Calling this function will throw an error instructing you to use `signAndSendTransaction` instead.
+     *   - Solana: supports raw transaction signing via the connected wallet provider.
+     *   - Other chains: not supported; will throw an error.
+     *
+     * - **Embedded wallets**
+     *   - Delegates signing to the ZeroXKey API, which returns the signed transaction.
+     *   - Supports all ZeroXKey-supported transaction types (e.g., Ethereum/EVM, Solana, Tron).
+     *   - BSC and other EVM-compatible chains use `TRANSACTION_TYPE_ETHEREUM`; the chain is identified by the unsigned transaction's `chainId`.
+     *   - Optionally allows stamping with a specific stamper (`StamperType.Passkey`, `StamperType.ApiKey`, or `StamperType.Wallet`).
+     *   - Note: For embedded Ethereum wallets, the returned signature doesn’t include the `0x` prefix. You should add `0x` before
+     *     broadcasting if it’s missing. It’s a good idea to check whether the signature already starts with `0x` before adding it,
+     *     since we plan to include the prefix by default in a future breaking change.
+     *
+     * @param params.walletAccount - wallet account to use for signing.
+     * @param params.unsignedTransaction - unsigned transaction data as a serialized
+     *   string in the canonical encoding for the given `transactionType`.
+     * @param params.transactionType - type of transaction (e.g., "TRANSACTION_TYPE_ETHEREUM", "TRANSACTION_TYPE_SOLANA", "TRANSACTION_TYPE_TRON"). Use "TRANSACTION_TYPE_ETHEREUM" for BSC.
+     * @param params.stampWith - stamper to use for signing (`StamperType.Passkey`, `StamperType.ApiKey`, or `StamperType.Wallet`).
+     * @param params.organizationId - organization ID to target (defaults to the session's organization ID).
+     * @returns A promise that resolves to the signed transaction string.
+     * @throws {ZeroXKeyError} If the wallet type is unsupported, signing fails, or the response is invalid.
+     */
+    signTransaction: (params: SignTransactionParams) => Promise<string>;
+    /**
+     * Signs and broadcasts a transaction using the specified wallet account.
+     *
+     * Behavior differs depending on the type of wallet:
+     *
+     * - **Connected wallets**
+     *   - *Ethereum*: delegates to the wallet’s native `signAndSendTransaction` method.
+     *     - Does **not** require an `rpcUrl` (the wallet handles broadcasting).
+     *   - *Solana*: signs the transaction locally with the connected wallet, but requires an `rpcUrl` to broadcast it.
+     *   - Other chains: not supported; will throw an error.
+     *
+     * - **Embedded wallets**
+     *   - Signs the transaction using the ZeroXKey API.
+     *   - Requires an `rpcUrl` to broadcast the signed transaction, since ZeroXKey does not broadcast directly.
+     *   - Broadcasts the transaction using a JSON-RPC client and returns the resulting transaction hash/signature.
+     *   - Optionally allows stamping with a specific stamper (`StamperType.Passkey`, `StamperType.ApiKey`, or `StamperType.Wallet`).
+     *
+     * @param params.walletAccount - wallet account to use for signing and broadcasting.
+     * @param params.unsignedTransaction - unsigned transaction data as a serialized
+     *   string in the canonical encoding for the given `transactionType`.
+     * @param params.transactionType - type of transaction (e.g., `"TRANSACTION_TYPE_SOLANA"`, `"TRANSACTION_TYPE_ETHEREUM"`).
+     * @param params.rpcUrl - JSON-RPC endpoint used for broadcasting (required for Solana connected wallets and all embedded wallets).
+     * @param params.stampWith - optional stamper to use when signing (`StamperType.Passkey`, `StamperType.ApiKey`, or `StamperType.Wallet`).
+     * @param params.organizationId - **Only for ZeroXKey embedded wallets**: organization ID to target (defaults to the session's organization ID).
+     * @returns A promise that resolves to a transaction signature or hash.
+     * @throws {ZeroXKeyError} If the wallet type is unsupported, or if signing/broadcasting fails.
+     */
+    signAndSendTransaction: (params: SignAndSendTransactionParams) => Promise<string>;
+    /**
+     * @beta
+     * * **API subject to change**
+     *
+     * Signs and submits an ERC20 `transfer(address,uint256)` as an Ethereum transaction
+     * using a ZeroXKey-managed (embedded) wallet.
+     *
+     * This is a convenience wrapper around `ethSendTransaction`:
+     * - Encodes ERC20 transfer calldata.
+     * - Sends a transaction to the token contract.
+     * - Returns a `sendTransactionStatusId` for polling with `pollTransactionStatus`.
+     *
+     * @param params.organizationId - Organization ID to execute the transaction under.
+     *                                Defaults to the active session's organization.
+     * @param params.stampWith - Optional stamper to authorize signing (e.g., passkey).
+     * @param params.transfer - ERC20 transfer parameters.
+     * @returns A promise resolving to the `sendTransactionStatusId`.
+     * @throws {ZeroXKeyError} If amount encoding fails or ZeroXKey rejects the transaction.
+     */
+    ethSendErc20Transfer: (params: EthSendErc20TransferParams) => Promise<string>;
+    /**
+     * @beta
+     * * **API subject to change**
+     *
+     * Signs and submits an Ethereum transaction using a ZeroXKey-managed (embedded) wallet.
+     *
+     * This method performs **authorization and signing**, and submits the transaction
+     * to ZeroXKey’s coordinator. It **does not perform any polling** — callers must use
+     * `pollTransactionStatus` to obtain the final on-chain result.
+     *
+     * Behavior:
+     *
+     * - **Connected wallets**
+     *   - Connected wallets are **not supported** by this method.
+     *   - They must instead use `signAndSendTransaction`.
+     *
+     * - **Embedded wallets**
+     *   - Constructs the payload for ZeroXKey's `eth_send_transaction` endpoint.
+     *   - Forwards transaction fields directly to ZeroXKey's coordinator.
+     *   - Signs and submits the transaction through ZeroXKey.
+     *   - Returns a `sendTransactionStatusId`, which the caller must pass to
+     *     `pollTransactionStatus` to obtain the final result (tx hash + status).
+     *
+     * @param params.organizationId - Organization ID to execute the transaction under.
+     *                                Defaults to the active session's organization.
+     *
+     * @param params.stampWith - Optional stamper to authorize signing (e.g., passkey).
+     *
+     * @param params.transaction - The Ethereum transaction details.
+     * @returns A promise resolving to the `sendTransactionStatusId`.
+     *          This ID must be passed to `pollTransactionStatus`.
+     *
+     * @throws {ZeroXKeyError} If the transaction is invalid or ZeroXKey rejects it.
+     */
+    ethSendTransaction: (params: EthSendTransactionParams) => Promise<string>;
+    /**
+     * @beta
+     * * **API subject to change**
+     *
+     * Signs and submits a Solana transaction using a ZeroXKey-managed (embedded) wallet.
+     *
+     * This method performs **authorization and signing**, and submits the transaction
+     * to ZeroXKey’s coordinator. It **does not perform any polling** — callers must use
+     * `pollTransactionStatus` to obtain the final on-chain result.
+     *
+     * Behavior:
+     *
+     * - **Connected wallets**
+     *   - Connected wallets are **not supported** by this method.
+     *   - They must instead use `signAndSendTransaction`.
+     *
+     * - **Embedded wallets**
+     *   - Constructs the payload for ZeroXKey's `sol_send_transaction` endpoint.
+     *   - Signs and submits the transaction through ZeroXKey.
+     *   - Returns a `sendTransactionStatusId`, which the caller must pass to
+     *     `pollTransactionStatus` to obtain the final result (signature + status).
+     *
+     * @param params.organizationId - Organization ID to execute the transaction under.
+     *                                Defaults to the active session's organization.
+     * @param params.stampWith - Optional stamper to authorize signing (e.g., passkey).
+     * @param params.transaction - The Solana transaction details.
+     * @returns A promise resolving to the `sendTransactionStatusId`.
+     *          This ID must be passed to `pollTransactionStatus`.
+     * @throws {ZeroXKeyError} If the transaction is invalid or ZeroXKey rejects it.
+     */
+    solSendTransaction: (params: SolSendTransactionParams) => Promise<string>;
+    /**
+     * @beta
+     * **API subject to change**
+     *
+     * Polls ZeroXKey for the final result of a previously submitted transaction.
+     *
+     * This function repeatedly calls `getSendTransactionStatus` until the transaction
+     * reaches a terminal state.
+     *
+     * Terminal states:
+     * - **COMPLETED** or **INCLUDED** → resolves with chain-specific transaction details
+     * - **FAILED** rejects with an error
+     *
+     * Behavior:
+     *
+     * - Queries ZeroXKey every 500ms.
+     * - Stops polling automatically when a terminal state is reached.
+     * - Returns the full status payload from ZeroXKey.
+     * - When available, Ethereum transaction details are exposed at `resp.eth.txHash`.
+     *
+     * @param params.organizationId - Organization ID under which the transaction was submitted.
+     * @param params.sendTransactionStatusId - Status ID returned by `ethSendTransaction` or `solSendTransaction`.
+     * @param params.pollingIntervalMs - Optional polling interval in milliseconds (default: 500ms).
+     * @param params.stampWith - Optional stamper to use for polling.
+     *
+     * @returns A promise resolving to the transaction status payload if successful.
+     * @throws {ZeroXKeyError} If the transaction fails, is cancelled, or times out.
+     */
+    pollTransactionStatus(params: PollTransactionStatusParams): Promise<TGetSendTransactionStatusResponse>;
+    /**
+     * Fetches the user details for the current session or a specified user.
+     *
+     * - Retrieves user details from the ZeroXKey API using the provided userId and organizationId, or defaults to those from the active session.
+     * - If no userId is provided, the userId from the current session is used.
+     * - If no organizationId is provided, the organizationId from the current session is used.
+     * - Optionally allows stamping the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * - Ensures that an active session exists before making the request.
+     *
+     * @param params.organizationId - organization ID to specify the sub-organization (defaults to the current session's organizationId).
+     * @param params.userId - user ID to fetch specific user details (defaults to the current session's userId).
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @returns A promise that resolves to a `v1User` object containing the user details.
+     * @throws {ZeroXKeyError} If there is no active session, if there is no userId, or if there is an error fetching user details.
+     */
+    fetchUser: (params?: FetchUserParams) => Promise<v1User>;
+    /**
+     * Fetches an existing user by P-256 API key public key, or creates a new one if none exists.
+     *
+     * - This function is idempotent: multiple calls with the same `publicKey` will always return the same user.
+     * - Attempts to find a user whose API keys include the given P-256 public key.
+     * - If a matching user is found, it is returned as-is.
+     * - If no matching user is found, a new user is created with the given public key as a P-256 API key.
+     *
+     * @param params.publicKey - the P-256 public key to use for lookup and creation.
+     * @param params.createParams.userName - optional username to assign if creating a new user (defaults to `"Public Key User"`).
+     * @param params.createParams.apiKeyName - optional API key name to assign if creating a new API key (defaults to `public-key-user-${publicKey}`).
+     * @param params.organizationId - organization ID to specify the sub-organization (defaults to the current session's organizationId).
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @returns A promise that resolves to the existing or newly created {@link v1User}.
+     * @throws {ZeroXKeyError} If there is no active session, if the input is invalid, if user retrieval fails, or if user creation fails.
+     */
+    fetchOrCreateP256ApiKeyUser: (params: FetchOrCreateP256ApiKeyUserParams) => Promise<v1User>;
+    /**
+     * Fetches each requested policy if it exists, or creates it if it does not.
+     *
+     * - This function is idempotent: multiple calls with the same policies will not create duplicates.
+     * - For every policy in the request:
+     *   - If it already exists, it is returned with its `policyId`.
+     *   - If it does not exist, it is created and returned with its new `policyId`.
+     *
+     * @param params.policies - the list of policies to fetch or create.
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @param params.organizationId - organization ID to specify the sub-organization (defaults to the current session's organizationId).
+     * @returns A promise that resolves to an array of objects, each containing:
+     *          - `policyId`: the unique identifier of the policy.
+     *          - `policyName`: human-readable name of the policy.
+     *          - `effect`: the instruction to DENY or ALLOW an activity.
+     *          - `condition`: (optional) the condition expression that triggers the effect.
+     *          - `consensus`: (optional) the consensus expression that triggers the effect.
+     *          - `notes`: (optional) developer notes or description for the policy.
+     * @throws {ZeroXKeyError} If there is no active session, if the input is invalid,
+     *                        if fetching policies fails, or if creating policies fails.
+     */
+    fetchOrCreatePolicies: (params: FetchOrCreatePoliciesParams) => Promise<FetchOrCreatePoliciesResult>;
+    /**
+     * Updates the user's email address.
+     *
+     * - This function updates the user's email address and, if provided, verifies it using a verification token (typically from an OTP flow).
+     * - If a userId is provided, it updates the email for that specific user; otherwise, it uses the current session's userId.
+     * - If a verificationToken is not provided, the email will be updated but will not be marked as verified.
+     * - Automatically ensures an active session exists before making the request.
+     * - Handles session management and error reporting for both update and verification flows.
+     *
+     * @param params.email - new email address to set for the user.
+     * @param params.verificationToken - verification token from OTP email verification (required if verifying the email).
+     * @param params.userId - user ID to update a specific user's email (defaults to the current session's userId).
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @param params.organizationId - organization ID to specify the sub-organization (defaults to the current session's organizationId).
+     * @returns A promise that resolves to the userId of the updated user.
+     * @throws {ZeroXKeyError} If there is no active session, if the userId is missing, or if there is an error updating or verifying the user email.
+     */
+    updateUserEmail: (params: UpdateUserEmailParams) => Promise<string>;
+    /**
+     * Removes the user's email address.
+     *
+     * - This function removes the user's email address by setting it to an empty string.
+     * - If a userId is provided, it removes the email for that specific user; otherwise, it uses the current session's userId.
+     * - Automatically ensures an active session exists before making the request.
+     * - Optionally allows stamping the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     *
+     * @param params.userId - user ID to remove a specific user's email address (defaults to the current session's userId).
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @param params.organizationId - organization ID to specify the sub-organization (defaults to the current session's organizationId).
+     * @returns A promise that resolves to the userId of the user whose email was removed.
+     * @throws {ZeroXKeyError} If there is no active session, if the userId is missing, or if there is an error removing the user email.
+     */
+    removeUserEmail: (params?: RemoveUserEmailParams) => Promise<string>;
+    /**
+     * Updates the user's phone number.
+     *
+     * - This function updates the user's phone number and, if provided, verifies it using a verification token (from an OTP flow).
+     * - If a userId is provided, it updates the phone number for that specific user; otherwise, it uses the current session's userId.
+     * - If a verificationToken is not provided, the phone number will be updated but will not be marked as verified.
+     * - Automatically ensures an active session exists before making the request.
+     * - Handles session management and error reporting for both update and verification flows.
+     *
+     * @param params.phoneNumber - new phone number to set for the user.
+     * @param params.verificationToken - verification token from OTP phone verification (required if verifying the phone number).
+     * @param params.userId - user ID to update a specific user's phone number (defaults to the current session's userId).
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @param params.organizationId - organization ID to specify the sub-organization (defaults to the current session's organizationId).
+     * @returns A promise that resolves to the userId of the updated user.
+     * @throws {ZeroXKeyError} If there is no active session, if the userId is missing, or if there is an error updating or verifying the user phone number.
+     */
+    updateUserPhoneNumber: (params: UpdateUserPhoneNumberParams) => Promise<string>;
+    /**
+     * Removes the user's phone number.
+     *
+     * - This function removes the user's phone number by setting it to an empty string.
+     * - If a userId is provided, it removes the phone number for that specific user; otherwise, it uses the current session's userId.
+     * - Automatically ensures an active session exists before making the request.
+     * - Optionally allows stamping the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     *
+     * @param params.userId - user ID to remove a specific user's phone number (defaults to the current session's userId).
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @param params.organizationId - organization ID to specify the sub-organization (defaults to the current session's organizationId).
+     * @returns A promise that resolves to the userId of the user whose phone number was removed.
+     * @throws {ZeroXKeyError} If there is no active session, if the userId is missing, or if there is an error removing the user phone number.
+     */
+    removeUserPhoneNumber: (params?: RemoveUserPhoneNumberParams) => Promise<string>;
+    /**
+     * Updates the user's name.
+     *
+     * - This function updates the user's display name.
+     * - If a userId is provided, it updates the name for that specific user; otherwise, it uses the current session's userId.
+     * - Automatically ensures an active session exists before making the request.
+     * - Optionally allows stamping the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * - Handles session management and error reporting for the update flow.
+     *
+     * @param params.userName - new name to set for the user.
+     * @param params.userId - user ID to update a specific user's name (defaults to the current session's userId).
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @param params.organizationId - organization ID to specify the sub-organization (defaults to the current session's organizationId).
+     * @returns A promise that resolves to the userId of the updated user.
+     * @throws {ZeroXKeyError} If there is no active session, if the userId is missing, or if there is an error updating the user name.
+     */
+    updateUserName: (params: UpdateUserNameParams) => Promise<string>;
+    /**
+     * Adds an OAuth provider to the user.
+     *
+     * - This function adds an OAuth provider (e.g., Google, Apple) to the user account.
+     * - If a userId is provided, it adds the provider for that specific user; otherwise, it uses the current session's userId.
+     * - Automatically checks if an account already exists for the provided OIDC token and prevents duplicate associations.
+     * - If the user's email is not set or not verified, attempts to update and verify the email using the email from the OIDC token.
+     * - Handles session management and error reporting for the add provider flow.
+     * - Optionally allows stamping the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     *
+     * @param params.providerName - name of the OAuth provider to add (e.g., "Google", "Apple").
+     * @param params.oidcToken - OIDC token for the OAuth provider.
+     * @param params.organizationId - organization ID to specify the sub-organization (defaults to the current session's organizationId).
+     * @param params.userId - user ID to add the provider for a specific user (defaults to current session's userId).
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @returns A promise that resolves to an array of provider IDs associated with the user.
+     * @throws {ZeroXKeyError} If there is no active session, if the account already exists, or if there is an error adding the OAuth provider.
+     */
+    addOauthProvider: (params: AddOauthProviderParams) => Promise<string[]>;
+    /**
+     * Removes a list of OAuth providers from the user.
+     *
+     * - This function removes OAuth providers (e.g., Google, Apple) from the user's account.
+     * - If a userId is provided, it removes the providers for that specific user; otherwise, it uses the current session's userId.
+     * - Automatically ensures an active session exists before making the request.
+     * - Optionally allows stamping the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * - Returns an array of remaining provider IDs associated with the user after removal.
+     *
+     * @param params.providerIds - IDs of the OAuth providers to remove.
+     * @param params.userId - user ID to remove the provider for a specific user (defaults to the current session's userId).
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @param params.organizationId - organization ID to specify the sub-organization (defaults to the current session's organizationId).
+     * @returns A promise that resolves to an array of provider IDs that were removed.
+     * @throws {ZeroXKeyError} If there is no active session, if the userId is missing, or if there is an error removing the OAuth provider.
+     */
+    removeOauthProviders: (params: RemoveOauthProvidersParams) => Promise<string[]>;
+    /**
+     * Adds a new passkey authenticator for the user.
+     *
+     * - This function prompts the user to create a new passkey (WebAuthn/FIDO2) and adds it as an authenticator for the user.
+     * - Handles both web and React Native environments, automatically selecting the appropriate passkey creation flow.
+     * - If a userId is provided, the passkey is added for that specific user; otherwise, it uses the current session's userId.
+     * - The passkey's name and display name can be customized; if not provided, defaults are generated.
+     * - The resulting passkey attestation and challenge are registered with ZeroXKey as a new authenticator.
+     *
+     * @param params.name - name of the passkey (defaults to "ZeroXKey Passkey-`timestamp`").
+     * @param params.displayName - display name of the passkey (defaults to the value of `name`).
+     * @param params.userId - user ID to add the passkey for a specific user (defaults to the current session's userId).
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @param params.organizationId - organization ID to specify the sub-organization (defaults to the current session's organizationId).
+     * @returns A promise that resolves to an array of authenticator IDs for the newly added passkey(s).
+     * @throws {ZeroXKeyError} If there is no active session, if passkey creation fails, or if there is an error adding the passkey.
+     */
+    addPasskey: (params?: AddPasskeyParams) => Promise<string[]>;
+    /**
+     * Removes passkeys (authenticator) from the user.
+     *
+     * - This function removes passkeys (WebAuthn/FIDO2 authenticators) from the user's account.
+     * - If a userId is provided, it removes the passkeys for that specific user; otherwise, it uses the current session's userId.
+     * - Automatically ensures an active session exists before making the request.
+     * - Optionally allows stamping the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * - Returns an array of remaining authenticator IDs for the user after removal.
+     *
+     * @param params.authenticatorIds - IDs of the authenticators (passkeys) to remove.
+     * @param params.userId - user ID to remove the passkeys for a specific user (defaults to the current session's userId).
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @param params.organizationId - organization ID to specify the sub-organization (defaults to the current session's organizationId).
+     * @returns A promise that resolves to an array of authenticator IDs that were removed.
+     * @throws {ZeroXKeyError} If there is no active session, if the userId is missing, or if there is an error removing the passkeys.
+     */
+    removePasskeys: (params: RemovePasskeyParams) => Promise<string[]>;
+    /**
+     * Creates a new wallet for sub-organization.
+     *
+     * - This function creates a new wallet for the current sub-organization.
+     * - If an organizationId is provided, the wallet will be created under that specific sub-organization; otherwise, it uses the current session's organizationId.
+     * - If a list of address formats is provided, accounts will be created in the wallet based on those formats (starting from path index 0).
+     * - If a list of account parameters is provided, those accounts will be created in the wallet.
+     * - If no accounts or address formats are provided, default Ethereum and Solana accounts will be created.
+     * - Optionally allows specifying the mnemonic length for the wallet seed phrase (defaults to 12).
+     * - Optionally allows stamping the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     *
+     * @param params.walletName - name of the wallet to create.
+     * @param params.accounts - array of account parameters or address formats to create in the wallet.
+     * @param params.organizationId - organization ID to create the wallet under a specific sub-organization (defaults to the current session's organizationId).
+     * @param params.mnemonicLength - mnemonic length for the wallet seed phrase (defaults to 12).
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @returns A promise that resolves to the ID of the newly created wallet.
+     * @throws {ZeroXKeyError} If there is no active session or if there is an error creating the wallet.
+     */
+    createWallet: (params: CreateWalletParams) => Promise<string>;
+    /**
+     * Creates new accounts in the specified wallet.
+     *
+     * - This function creates new wallet accounts based on the provided account parameters or address formats.
+     * - If a walletId is provided, it creates the accounts in that specific wallet; otherwise, it uses the current session's wallet.
+     * - If a list of address formats is provided, it will create accounts in the wallet based on those formats, automatically determining the next available path indexes to avoid duplicates with existing accounts.
+     * - If account parameters are provided, they are used directly for account creation.
+     * - Automatically queries existing wallet accounts to prevent duplicate account creation for the same address format and path.
+     * - Supports stamping the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     *
+     * @param params.accounts - An array of account parameters or address formats to create in the wallet.
+     * @param params.walletId - ID of the wallet to create accounts in.
+     * @param params.organizationId - organization ID to create the accounts under a specific organization (walletId must be associated with the sub-organization).
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @returns A promise that resolves to an array of addresses for the newly created accounts.
+     * @throws {ZeroXKeyError} If there is no active session, if the wallet does not exist, or if there is an error creating the wallet accounts.
+     */
+    createWalletAccounts: (params: CreateWalletAccountsParams) => Promise<string[]>;
+    /**
+     * Exports a wallet as an encrypted bundle.
+     *
+     * - This function exports the specified wallet and its accounts as an encrypted bundle, suitable for backup or transfer.
+     * - The exported bundle contains the wallet's seed phrase, encrypted to the provided target public key.
+     * - If a targetPublicKey is provided, the bundle will be encrypted to that public key; otherwise, an error will be thrown.
+     * - If an organizationId is provided, the wallet will be exported under that sub-organization; otherwise, the current session's organizationId is used.
+     * - Optionally allows stamping the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * - The exported bundle can later be imported using the `importWallet` method.
+     *
+     * @param params.walletId - ID of the wallet to export.
+     * @param params.targetPublicKey - public key to encrypt the bundle to (required).
+     * @param params.organizationId - organization ID to export the wallet under a specific sub-organization (walletId must be associated with the sub-organization).
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @returns A promise that resolves to an `ExportBundle` object containing the encrypted wallet seed phrase and metadata.
+     * @throws {ZeroXKeyError} If there is no active session, if the targetPublicKey is missing, or if there is an error exporting the wallet.
+     */
+    exportWallet: (params: ExportWalletParams) => Promise<ExportBundle>;
+    /**
+     * Exports a private key as an encrypted bundle.
+     *
+     * - This function exports the specified private key as an encrypted bundle, suitable for backup or transfer.
+     * - The exported bundle contains the private key's key material, encrypted to the provided target public key.
+     * - If a targetPublicKey is provided, the bundle will be encrypted to that public key; otherwise, an error will be thrown.
+     * - If an organizationId is provided, the private key will be exported under that sub-organization; otherwise, the current session's organizationId is used.
+     * - Optionally allows stamping the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     *
+     * @param params.privateKeyId - ID of the private key to export.
+     * @param params.targetPublicKey - public key to encrypt the bundle to (required).
+     * @param params.organizationId - organization ID to export the private key under a specific sub
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @returns A promise that resolves to an `ExportBundle` object containing the encrypted private key and metadata.
+     * @throws {ZeroXKeyError} If there is no active session, if the targetPublicKey is missing, or if there is an error exporting the private key.
+     */
+    exportPrivateKey: (params: ExportPrivateKeyParams) => Promise<ExportBundle>;
+    /**
+     * Exports a wallet account as an encrypted bundle.
+     *
+     * - This function exports the specified wallet account as an encrypted bundle, suitable for backup or transfer.
+     * - The exported bundle contains the wallet account's key material, encrypted to the provided target public key.
+     * - If a targetPublicKey is provided, the bundle will be encrypted to that public key; otherwise, an error will be thrown.
+     * - If an organizationId is provided, the wallet account will be exported under that sub-organization; otherwise, the current session's organizationId is used.
+     * - Optionally allows stamping the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     *
+     * @param params.address - address of the wallet account to export.
+     * @param params.targetPublicKey - public key to encrypt the bundle to.
+     * @param params.organizationId - organization ID to export the wallet account under a specific sub-organization.
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @returns A promise that resolves to an `ExportBundle` object containing the encrypted wallet account and metadata.
+     * @throws {ZeroXKeyError} If there is no active session, if the targetPublicKey is missing, or if there is an error exporting the wallet account.
+     *
+     */
+    exportWalletAccount: (params: ExportWalletAccountParams) => Promise<ExportBundle>;
+    /**
+     * Imports a wallet from an encrypted bundle.
+     *
+     * - This function imports a wallet using the provided encrypted bundle and creates accounts based on the provided parameters.
+     * - If a userId is provided, the wallet will be imported for that specific user; otherwise, it uses the current session's userId.
+     * - If an accounts array is provided, those accounts will be created in the imported wallet; otherwise, default Ethereum and Solana accounts will be created.
+     * - The encrypted bundle MUST be encrypted to
+     * - Automatically ensures an active session exists before making the request.
+     * - Optionally allows stamping the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     *
+     * @param params.encryptedBundle - encrypted bundle containing the wallet seed phrase and metadata.
+     * @param params.walletName - name of the wallet to create upon import.
+     * @param params.accounts - array of account parameters to create in the imported wallet (defaults to standard Ethereum and Solana accounts).
+     * @param params.organizationId - organization ID to import the wallet under a specific sub-organization (wallet will be associated with the sub-organization).
+     * @param params.userId - user ID to import the wallet for a specific user (defaults to the current session's userId).
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @returns A promise that resolves to the ID of the imported wallet.
+     * @throws {ZeroXKeyError} If there is no active session, if the encrypted bundle is invalid, or if there is an error importing the wallet.
+     */
+    importWallet: (params: ImportWalletParams) => Promise<string>;
+    /**
+     * Imports a private key from an encrypted bundle.
+     *
+     * - This function imports a private key using the provided encrypted bundle.
+     * - If a userId is provided, the private key will be imported for that specific user; otherwise, it uses the current session's userId.
+     * - Requires address formats to
+     * - Automatically infers the cryptographic curve used to generate the private key based on the address format (can be optionally overriden if needed).
+     * - The encrypted bundle MUST be encrypted to ensure security.
+     * - Automatically ensures an active session exists before making the request.
+     * - Optionally allows stamping the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     *
+     * @param params.encryptedBundle - encrypted bundle containing the private key key material and metadata.
+     * @param params.privateKeyName - name of the private key to create upon import.
+     * @param params.curve - the cryptographic curve used to generate a given private key
+     * @param params.addressFormat - address format of the private key to import.
+     * @param params.organizationId - organization ID to import the private key under a specific sub-organization (private key will be associated with the sub-organization).
+     * @param params.userId - user ID to import the wallet for a specific user (defaults to the current session's userId).
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @returns A promise that resolves to the ID of the imported wallet.
+     * @throws {ZeroXKeyError} If there is no active session, if the encrypted bundle is invalid, or if there is an error importing the wallet.
+     */
+    importPrivateKey: (params: ImportPrivateKeyParams) => Promise<string>;
+    /**
+     * Deletes the current sub-organization (sub-org) for the active session.
+     *
+     * - This function deletes the sub-organization associated with the current active session.
+     * - By default, the deletion will fail if any wallets associated with the sub-organization have not been exported.
+     * - If `deleteWithoutExport` is set to true, the sub-organization will be deleted even if its wallets have not been exported (potentially resulting in loss of access to those wallets).
+     * - Requires an active session; otherwise, an error is thrown.
+     * - Optionally allows stamping the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     *
+     * @param params.deleteWithoutExport - flag to delete the sub-organization without requiring all wallets to be exported first (defaults to false).
+     * @param params.organizationId - organization ID to delete a specific sub-organization (defaults to the current session's organizationId).
+     * @param params.stampWith - parameter to stamp the request with a specific stamper.
+     * @returns A promise that resolves to a `TDeleteSubOrganizationResponse` object containing the result of the deletion.
+     * @throws {ZeroXKeyError} If there is no active session or if there is an error deleting the sub-organization.
+     */
+    deleteSubOrganization: (params?: DeleteSubOrganizationParams) => Promise<TDeleteSubOrganizationResponse>;
+    /**
+     * Stores a session token and updates the session associated with the specified session key, or by default the active session.
+     *
+     * - This function parses and stores a signed JWT session token in local storage, associating it with the given session key.
+     * - If a sessionKey is provided, the session will be stored under that key; otherwise, it will use the default session key.
+     * - If a session already exists for the session key, its associated key pair will be deleted before storing the new session.
+     * - After storing the session, any unused key pairs are automatically cleared from storage.
+     * - Ensures that session management is consistent and prevents orphaned key pairs.
+     *
+     * @param params.sessionToken - JWT session token to store.
+     * @param params.sessionKey - session key to store the session under (defaults to the default session key).
+     * @returns A promise that resolves when the session is successfully stored.
+     * @throws {ZeroXKeyError} If there is an error storing the session or cleaning up key pairs.
+     */
+    storeSession: (params: StoreSessionParams) => Promise<void>;
+    /**
+     * Clears the session associated with the specified session key, or the active session by default.
+     *
+     * - This function deletes the session and its associated key pair from storage.
+     * - If a sessionKey is provided, it will clear the session under that key; otherwise, it will clear the default (active) session.
+     * - Removes the session data from local storage and deletes the corresponding API key pair from the key store.
+     * - Throws an error if the session does not exist or if there is an error during the clearing process.
+     *
+     * @param params.sessionKey - session key to clear the session under (defaults to the default session key).
+     * @returns A promise that resolves when the session is successfully cleared.
+     * @throws {ZeroXKeyError} If the session does not exist or if there is an error clearing the session.
+     */
+    clearSession: (params?: ClearSessionParams) => Promise<void>;
+    /**
+     * Clears all sessions and resets the active session state.
+     *
+     * - This function removes all session data from the client and persistent storage, including all associated key pairs.
+     * - Iterates through all stored session keys, clearing each session and deleting its corresponding API key pair.
+     * - After clearing, there will be no active session, and all session-related data will be removed from local storage.
+     * - Throws an error if no sessions exist or if there is an error during the clearing process.
+     *
+     * @returns A promise that resolves when all sessions are successfully cleared.
+     * @throws {ZeroXKeyError} If no sessions exist or if there is an error clearing all sessions.
+     */
+    clearAllSessions: () => Promise<void>;
+    /**
+     * Refreshes the session associated with the specified session key, or the active session by default.
+     *
+     * - This function refreshes the session and updates the session token and key pair associated with the given session key.
+     * - If a sessionKey is provided, it will refresh the session under that key; otherwise, it will use the current active session key.
+     * - Optionally allows specifying a new expiration time for the session, a custom public key, and whether to invalidate the existing session after refreshing.
+     * - Makes a request to the ZeroXKey API to stamp a new login and stores the refreshed session token.
+     * - Automatically manages key pair cleanup and session storage to ensure consistency.
+     * - Optionally allows stamping the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     *
+     * @param params.sessionKey - session key to refresh the session under (defaults to the active session key).
+     * @param params.expirationSeconds - expiration time in seconds for the refreshed session (defaults to the configured default).
+     * @param params.publicKey - public key to use for the refreshed session (if not provided, a new key pair will be generated).
+     * @param params.invalidateExisitng - flag to invalidate the existing session before refreshing (defaults to false).
+     * @param params.stampWith - parameter to stamp the request with a specific stamper.
+     * @returns A promise that resolves to a `TStampLoginResponse` object containing the refreshed session details.
+     * @throws {ZeroXKeyError} If the session key does not exist, if there is no active session, or if there is an error refreshing the session.
+     */
+    refreshSession: (params?: RefreshSessionParams) => Promise<TStampLoginResponse | undefined>;
+    /**
+     * Retrieves the session associated with the specified session key, or the active session by default.
+     *
+     * - This function retrieves the session object from storage, using the provided session key or, if not specified, the current active session key.
+     * - If no session key is provided and there is no active session, it returns undefined.
+     * - Returns the session details, including public key, organization ID, user ID, and expiration.
+     *
+     * @param params.sessionKey - session key to retrieve a specific session (defaults to the current active session key).
+     * @returns A promise that resolves to a `Session` object containing the session details, or undefined if not found.
+     * @throws {ZeroXKeyError} If there is an error retrieving the session from storage.
+     */
+    getSession: (params?: GetSessionParams) => Promise<Session | undefined>;
+    /**
+     * Retrieves all sessions stored in persistent storage.
+     *
+     * - This function fetches all session objects currently stored by the client, including those that are not active.
+     * - Returns a record mapping each session key to its corresponding `Session` object.
+     * - Useful for session management, auditing, or displaying all available sessions to the user.
+     * - Automatically skips any session keys that do not have a valid session object.
+     *
+     * @returns A promise that resolves to a record of session keys and their corresponding `Session` objects, or `undefined` if no sessions exist.
+     * @throws {ZeroXKeyError} If there is an error retrieving sessions from storage.
+     */
+    getAllSessions: () => Promise<Record<string, Session> | undefined>;
+    /**
+     * Sets the active session to the specified session key.
+     *
+     * - This function updates the `activeSessionKey` in persistent storage to the specified session key.
+     * - Ensures that subsequent operations use the session associated with this key as the active session.
+     * - Does not validate whether the session key exists or is valid; it simply updates the pointer.
+     * - Useful for switching between multiple stored sessions or restoring a previous session context.
+     *
+     * @param params.sessionKey - session key to set as the active session.
+     * @returns A promise that resolves when the active session key is successfully set.
+     * @throws {ZeroXKeyError} If the client is not initialized or if there is an error setting the active session key.
+     */
+    setActiveSession: (params: SetActiveSessionParams) => Promise<void>;
+    /**
+     * Retrieves the active session key currently set in persistent storage.
+     *
+     * - This function fetches the session key that is currently marked as active in the client's persistent storage.
+     * - The active session key determines which session is used for all session-dependent operations.
+     * - If no active session key is set, returns `undefined`.
+     * - Useful for determining which session is currently in use, especially when managing multiple sessions.
+     *
+     * @returns A promise that resolves to the active session key as a string, or `undefined` if no active session is set.
+     * @throws {ZeroXKeyError} If there is an error retrieving the active session key from storage.
+     */
+    getActiveSessionKey: () => Promise<string | undefined>;
+    /**
+     * Clears any unused API key pairs from persistent storage.
+     *
+     * - This function scans all API key pairs stored in indexedDB and removes any key pairs that are not associated with a session in persistent storage.
+     * - Ensures that only key pairs referenced by existing sessions are retained, preventing orphaned or stale key pairs from accumulating.
+     * - Iterates through all stored session keys and builds a map of in-use public keys, then deletes any key pairs not present in this map.
+     * - Intended to be called after session changes (e.g., login, logout, session replacement) to keep key storage clean and secure.
+     *
+     * @returns A promise that resolves when all unused key pairs are successfully cleared.
+     * @throws {ZeroXKeyError} If there is an error listing, checking, or deleting unused key pairs.
+     */
+    clearUnusedKeyPairs: () => Promise<void>;
+    /**
+     * Creates a new API key pair and returns the public key.
+     *
+     * - This function generates a new API key pair and stores it in the underlying key store (IndexedDB).
+     * - If an external key pair is provided, it will use that key pair for creation instead of generating a new one.
+     * - If `storeOverride` is set to true, the generated or provided public key will be set as the override key in the API key stamper, making it the active key for subsequent signing operations.
+     * - Ensures the API key stamper is initialized before proceeding.
+     * - Handles both native CryptoKeyPair objects and raw key material.
+     *
+     * @param params.externalKeyPair - An externally generated key pair (either a CryptoKeyPair or an object with publicKey/privateKey strings) to use instead of generating a new one.
+     * @param params.storeOverride - If true, sets the generated or provided public key as the override key in the API key stamper (defaults to false).
+     * @return A promise that resolves to the public key of the created or provided API key pair as a string.
+     * @throws {ZeroXKeyError} If the API key stamper is not initialized or if there is an error during key pair creation or storage.
+     */
+    createApiKeyPair: (params?: CreateApiKeyPairParams) => Promise<string>;
+    /**
+     * Fetches the WalletKit proxy authentication configuration from the auth proxy.
+     *
+     * - This function makes a request to the ZeroXKey auth proxy to retrieve the current WalletKit configuration,
+     *   including supported authentication methods, OAuth providers, and any custom proxy settings.
+     * - Useful for dynamically configuring the client UI or authentication flows based on the proxy's capabilities.
+     * - Ensures that the client is aware of the latest proxy-side configuration, which may affect available login/signup options.
+     *
+     * @returns A promise that resolves to a `ProxyTGetWalletKitConfigResponse` object containing the proxy authentication configuration.
+     * @throws {ZeroXKeyError} If there is an error retrieving the proxy authentication configuration from the auth proxy.
+     */
+    getProxyAuthConfig: () => Promise<ProxyTGetWalletKitConfigResponse>;
+    /**
+     * Fetches the boot proof for a given app proof.
+     *
+     * - This function is idempotent: multiple calls with the same `app proof` will always return the boot proof.
+     * - Attempts to find the boot proof for the given app proof.
+     * - If a boot proof is found, it is returned as is.
+     * - If no boot proof is found, an error is thrown.
+     *
+     * @param params.appProof - the app proof for which the boot proof is being fetched.
+     * @param params.organizationId - organization ID to specify the sub-organization (defaults to the current session's organizationId).
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @returns A promise that resolves to the {@link v1BootProof} associated with the given app proof.
+     * @throws {ZeroXKeyError} If there is no active session, if the input is invalid, or if boot proof retrieval fails.
+     */
+    fetchBootProofForAppProof: (params: FetchBootProofForAppProofParams) => Promise<v1BootProof>;
+    /**
+     * Verifies a list of app proofs against their corresponding boot proofs.
+     *
+     * - This function iterates through each provided app proof, fetches the corresponding boot proof, and verifies the app proof against the boot proof.
+     * - If any app proof fails verification, an error is thrown.
+     * @param params.appProofs - the app proofs to verify.
+     * @param params.organizationId - organization ID to specify the sub-organization (defaults to the current session's organizationId).
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @returns A promise that resolves when all app proofs have been successfully verified.
+     * @throws {ZeroXKeyError} If there is no active session, if the input is invalid, or if verification fails.
+     */
+    verifyAppProofs: (params: VerifyAppProofsParams) => Promise<void>;
+}
+export {};
+//# sourceMappingURL=core.d.ts.map