import { EcdsaSignature, MessageHash, type EcdsaPublicKey } from '#internal/web';
import { AuthMode, BackupLocation, DynamicApiClient, ThresholdSignatureScheme, WalletOperation, type BackupLocationWithExternalKeyShareId, type BitcoinConfig, type DynamicWalletClientProps, type FeatureFlags, type InitializeResult, type KeyShareBackupInfo, type TraceContext } from '@dynamic-labs-wallet/core';
import { type InstrumentOptions } from '@dynamic-labs/logger';
import { RoomTypeEnum, type SignMessageContext } from '@dynamic-labs/sdk-api-core';
import type { ClientInitKeygenResult, ClientKeyShare } from './mpc/types.js';
import { type SupportedStorage } from './services/localStorage.js';
import { type Room, type ShareDistribution, type WalletBusyOperation, type WalletProperties } from './types.js';
export declare class DynamicWalletClient {
    environmentId: string;
    storageKey: string;
    debug: boolean;
    protected userId: string | undefined;
    protected sessionId: string | undefined;
    protected initializePromise: Promise<InitializeResult> | null;
    protected logger: import("@dynamic-labs/logger").Logger;
    protected apiClient: DynamicApiClient;
    protected walletMap: Record<string, WalletProperties>;
    protected storage: SupportedStorage;
    protected memoryStorage: {
        [key: string]: string;
    } | null;
    protected baseMPCRelayApiUrl?: string;
    protected iframe: HTMLIFrameElement | null;
    protected forwardMPCEnabled: boolean;
    readonly instanceId: string;
    readonly iframeDomain: string;
    readonly featureFlags: FeatureFlags;
    protected authMode: AuthMode;
    protected sdkVersion?: string;
    protected baseClientKeysharesRelayApiUrl?: string;
    protected static rooms: Record<number, Room[]>;
    protected static roomsInitializing: Record<number, boolean>;
    protected static walletBusyMap: Record<string, WalletBusyOperation | undefined>;
    protected static walletBusyPromiseMap: Record<string, Promise<void> | undefined>;
    constructor({ environmentId, baseApiUrl, baseMPCRelayApiUrl, storageKey, debug, featureFlags, authMode, authToken, backupServiceAuthToken, sdkVersion, forwardMPCClient, baseClientKeysharesRelayApiUrl, iCloudConfig, }: DynamicWalletClientProps);
    private initializeForwardMPCClient;
    getWalletBusyOperation(accountAddress: string): WalletBusyOperation | undefined;
    isWalletBusy(accountAddress: string): boolean;
    private waitForWalletNotBusy;
    private withWalletBusyLock;
    getAuthMode(): AuthMode;
    /**
     * Get environment settings from the API client.
     * Used to retrieve configuration like iCloud settings.
     */
    getEnvironmentSettings(): Promise<any>;
    /**
     * Check if the SDK version meets the requirement for signed session ID
     * Uses namespace-specific version requirements when available
     * @returns boolean indicating if requireSignedSessionId should be set to true
     */
    private requiresSignedSessionId;
    initLoggerContext(authToken: string): Promise<void>;
    initialize(traceContext?: TraceContext): Promise<InitializeResult>;
    /**
     * Client initialization logic
     */
    protected _initialize(traceContext?: TraceContext): Promise<InitializeResult>;
    serverInitializeKeyGen({ chainName, clientKeygenIds, dynamicRequestId, thresholdSignatureScheme, bitcoinConfig, onError, onCeremonyComplete, }: {
        chainName: string;
        clientKeygenIds: string[];
        dynamicRequestId: string;
        thresholdSignatureScheme: ThresholdSignatureScheme;
        bitcoinConfig?: BitcoinConfig;
        onError?: (error: Error) => void;
        onCeremonyComplete?: (accountAddress: string, walletId: string) => void;
    }): Promise<import("@dynamic-labs-wallet/core").KeygenCompleteResponse>;
    clientInitializeKeyGen({ chainName, thresholdSignatureScheme, bitcoinConfig, }: {
        chainName: string;
        thresholdSignatureScheme: ThresholdSignatureScheme;
        bitcoinConfig?: BitcoinConfig;
    }): Promise<ClientInitKeygenResult[]>;
    derivePublicKey({ chainName, keyShare, derivationPath, bitcoinConfig, }: {
        chainName: string;
        keyShare: ClientKeyShare;
        derivationPath: Uint32Array | undefined;
        bitcoinConfig?: BitcoinConfig;
    }): Promise<EcdsaPublicKey | Uint8Array | string | undefined>;
    clientKeyGen({ chainName, roomId, serverKeygenIds, clientKeygenInitResults, thresholdSignatureScheme, bitcoinConfig, }: {
        chainName: string;
        roomId: string;
        serverKeygenIds: string[];
        clientKeygenInitResults: ClientInitKeygenResult[];
        thresholdSignatureScheme: ThresholdSignatureScheme;
        bitcoinConfig?: BitcoinConfig;
    }): Promise<{
        rawPublicKey: EcdsaPublicKey | Uint8Array | string | undefined;
        clientKeygenResults: ClientKeyShare[];
    }>;
    keyGen({ chainName, thresholdSignatureScheme, bitcoinConfig, onError, onCeremonyComplete, traceContext, }: {
        chainName: string;
        thresholdSignatureScheme: ThresholdSignatureScheme;
        bitcoinConfig?: BitcoinConfig;
        onError?: (error: Error) => void;
        onCeremonyComplete?: (accountAddress: string, walletId: string) => void;
        traceContext?: TraceContext;
    }): Promise<{
        rawPublicKey: EcdsaPublicKey | Uint8Array | string | undefined;
        clientKeyShares: ClientKeyShare[];
    }>;
    importRawPrivateKey({ chainName, privateKey, thresholdSignatureScheme, bitcoinConfig, onError, onCeremonyComplete, traceContext, legacyWalletId, }: {
        chainName: string;
        privateKey: string;
        thresholdSignatureScheme: ThresholdSignatureScheme;
        bitcoinConfig?: BitcoinConfig;
        onError?: (error: Error) => void;
        onCeremonyComplete?: (accountAddress: string, walletId: string) => void;
        traceContext?: TraceContext;
        /** ID of the legacy embedded wallet being upgraded to v3 */
        legacyWalletId?: string;
    }): Promise<{
        rawPublicKey: EcdsaPublicKey | Uint8Array | string | undefined;
        clientKeyShares: ClientKeyShare[];
    }>;
    serverSign({ walletId, message, isFormatted, mfaToken, roomId, context, onError, dynamicRequestId, traceContext, bitcoinConfig, }: {
        walletId: string;
        message: string | Uint8Array;
        dynamicRequestId: string;
        isFormatted?: boolean;
        mfaToken?: string;
        roomId?: string;
        context?: SignMessageContext;
        onError?: (error: Error) => void;
        traceContext?: TraceContext;
        bitcoinConfig?: BitcoinConfig;
    }): Promise<import("@dynamic-labs-wallet/core").OpenRoomResponse>;
    forwardMPCClientSign({ chainName, message, roomId, keyShare, derivationPath, formattedMessage, dynamicRequestId, isFormatted, traceContext, }: {
        chainName: string;
        message: string | Uint8Array;
        roomId: string;
        keyShare: ClientKeyShare;
        derivationPath: Uint32Array | undefined;
        formattedMessage: string | Uint8Array | MessageHash;
        dynamicRequestId: string;
        isFormatted?: boolean;
        traceContext?: TraceContext;
    }): Promise<Uint8Array | EcdsaSignature>;
    clientSign({ chainName, message, roomId, keyShare, derivationPath, isFormatted, dynamicRequestId, traceContext, bitcoinConfig, }: {
        chainName: string;
        message: string | Uint8Array;
        roomId: string;
        dynamicRequestId: string;
        keyShare: ClientKeyShare;
        derivationPath: Uint32Array | undefined;
        isFormatted?: boolean;
        traceContext?: TraceContext;
        bitcoinConfig?: BitcoinConfig;
    }): Promise<Uint8Array | EcdsaSignature>;
    sign({ accountAddress, message, chainName, password, isFormatted, signedSessionId, mfaToken, context, onError, traceContext, bitcoinConfig, }: {
        accountAddress: string;
        message: string | Uint8Array;
        chainName: string;
        password?: string;
        isFormatted?: boolean;
        signedSessionId: string;
        mfaToken?: string;
        context?: SignMessageContext;
        onError?: (error: Error) => void;
        traceContext?: TraceContext;
        bitcoinConfig?: BitcoinConfig;
    }): Promise<Uint8Array | EcdsaSignature>;
    refreshWalletAccountShares({ accountAddress, chainName, password, signedSessionId, mfaToken, traceContext, }: {
        accountAddress: string;
        chainName: string;
        password?: string;
        signedSessionId: string;
        mfaToken?: string;
        traceContext?: TraceContext;
    }): Promise<void>;
    private internalRefreshWalletAccountShares;
    getExportId({ chainName, clientKeyShare, bitcoinConfig, }: {
        chainName: string;
        clientKeyShare: ClientKeyShare;
        bitcoinConfig?: BitcoinConfig;
    }): Promise<string>;
    /**
     * Helper function to create client shares required to complete a reshare ceremony.
     * @param {string} chainName - The chain to create shares for
     * @param {WalletProperties} wallet - The wallet to reshare
     * @param {ThresholdSignatureScheme} oldThresholdSignatureScheme - The current threshold signature scheme
     * @param {ThresholdSignatureScheme} newThresholdSignatureScheme - The target threshold signature scheme
     * @returns {Promise<{
     *   newClientInitKeygenResults: ClientInitKeygenResult[],
     *   newClientKeygenIds: string[],
     *   existingClientKeygenIds: string[],
     *   existingClientKeyShares: ClientKeyShare[]
     * }>} Object containing new and existing client keygen results, IDs and shares
     * @todo Support higher to lower reshare strategies
     */
    reshareStrategy({ chainName, wallet, accountAddress, oldThresholdSignatureScheme, newThresholdSignatureScheme, }: {
        chainName: string;
        wallet: WalletProperties;
        accountAddress: string;
        oldThresholdSignatureScheme: ThresholdSignatureScheme;
        newThresholdSignatureScheme: ThresholdSignatureScheme;
    }): Promise<{
        newClientInitKeygenResults: ClientInitKeygenResult[];
        newClientKeygenIds: string[];
        existingClientKeygenIds: string[];
        existingClientKeyShares: ClientKeyShare[];
    }>;
    reshare({ chainName, accountAddress, oldThresholdSignatureScheme, newThresholdSignatureScheme, password, signedSessionId, cloudProviders, delegateToProjectEnvironment, mfaToken, revokeDelegation, }: {
        chainName: string;
        accountAddress: string;
        oldThresholdSignatureScheme: ThresholdSignatureScheme;
        newThresholdSignatureScheme: ThresholdSignatureScheme;
        password?: string;
        signedSessionId: string;
        cloudProviders?: BackupLocation[];
        delegateToProjectEnvironment?: boolean;
        mfaToken?: string;
        revokeDelegation?: boolean;
    }): Promise<void>;
    private internalReshare;
    private performDelegationOperation;
    delegateKeyShares({ accountAddress, password, signedSessionId, mfaToken, }: {
        accountAddress: string;
        password?: string;
        signedSessionId: string;
        mfaToken?: string;
    }): Promise<BackupLocationWithExternalKeyShareId[]>;
    revokeDelegation({ accountAddress, password, signedSessionId, mfaToken, }: {
        accountAddress: string;
        password?: string;
        signedSessionId: string;
        mfaToken?: string;
    }): Promise<void>;
    private createKeygenResult;
    exportKey({ accountAddress, chainName, bitcoinConfig, password, signedSessionId, mfaToken, traceContext, }: {
        accountAddress: string;
        chainName: string;
        bitcoinConfig?: BitcoinConfig;
        password?: string;
        signedSessionId: string;
        mfaToken?: string;
        traceContext?: TraceContext;
    }): Promise<{
        derivedPrivateKey: string | undefined;
    }>;
    private getReconstructedKeyShare;
    private performMPCExport;
    private derivePrivateKeyFromExport;
    offlineExportKey({ chainName, keyShares, derivationPath, }: {
        chainName: string;
        keyShares: ClientKeyShare[];
        derivationPath?: string;
    }): Promise<{
        derivedPrivateKey: string | undefined;
        rawPublicKey: EcdsaPublicKey | Uint8Array | string | undefined;
    }>;
    encryptKeyShare({ keyShare, password, }: {
        keyShare: ClientKeyShare;
        password?: string;
    }): Promise<string>;
    /**
     * helper function to store encrypted backup by wallet from iframe local storage
     */
    getClientKeySharesFromLocalStorage({ accountAddress, }: {
        accountAddress: string;
    }): Promise<ClientKeyShare[]>;
    /**
     * helper function to store encrypted backup by wallet from iframe local storage
     */
    setClientKeySharesToLocalStorage({ accountAddress, clientKeyShares, overwriteOrMerge, }: {
        accountAddress: string;
        clientKeyShares: ClientKeyShare[];
        overwriteOrMerge?: 'overwrite' | 'merge';
    }): Promise<void>;
    backupSharesWithDistribution({ accountAddress, password, signedSessionId, distribution, preserveDelegatedLocation, }: {
        accountAddress: string;
        password?: string;
        signedSessionId: string;
        distribution: ShareDistribution;
        preserveDelegatedLocation?: boolean;
    }): Promise<{
        message: string;
        walletId: string;
        locationsWithKeyShares: {
            location: BackupLocation;
            keyShareId: string;
            externalKeyShareId?: string;
        }[];
    }>;
    /**
     * Central backup orchestrator that encrypts and stores wallet key shares.
     *
     * This method serves as the main backup coordinator, handling the distribution of encrypted
     * key shares between Dynamic's backend and Google Drive based on the wallet's threshold scheme.
     * It is used by multiple operations including reshare, refresh, and manual backup requests.
     *
     * **Backup Distribution Strategy:**
     * - **Single share wallets**: All shares stored on Dynamic's backend only
     * - **Multi-share wallets (2+)**: When backing up to Google Drive, N-1 shares on Dynamic's backend, 1 share on Google Drive
     * - **Multi-share wallets (2+)**: When not backing up to Google Drive, all shares on Dynamic's backend
     *
     * **Process Flow:**
     * 1. Encrypts all client key shares with the provided password (or environment ID if no password)
     * 2. For multi-share wallets (2+): conditionally distributes N-1 to backend, 1 to Google Drive
     * 3. For other configurations: stores all shares on Dynamic's backend
     * 4. Updates backup metadata and synchronizes wallet state
     * 5. Persists the updated wallet map to local storage
     *
     * **Delegated Key Shares:**
     * - When delegatedKeyshare is provided, the method will not store the delegated key share but it will mark the delegated share as backed up on Dynamic's backend
     * - and encrypt the delegated key share to publish it to the webhook
     *
     * @param params - The backup operation parameters
     * @param params.accountAddress - The account address of the wallet to backup
     * @param params.clientKeyShares - Optional specific key shares to backup (uses localStorage if not provided)
     * @param params.password - Optional password for encryption (uses environment ID if not provided)
     * @param params.signedSessionId - Optional signed session ID for authentication
     * @param params.backupToGoogleDrive - Whether to backup to Google Drive (defaults to false)
     * @returns Promise with backup metadata including share locations and IDs
     */
    storeEncryptedBackupByWallet({ accountAddress, clientKeyShares, password, signedSessionId, cloudProviders, delegatedKeyshare, }: {
        accountAddress: string;
        clientKeyShares?: ClientKeyShare[];
        password?: string;
        signedSessionId: string;
        cloudProviders?: BackupLocation[];
        delegatedKeyshare?: ClientKeyShare;
    }): Promise<{
        keyShareIds: string[];
        message: string;
        walletId: string;
        locationsWithKeyShares: {
            location: BackupLocation;
            keyShareId: string;
            externalKeyShareId?: string;
        }[];
    }>;
    storeEncryptedBackupByWalletWithRetry({ accountAddress, clientKeyShares, password, signedSessionId, }: {
        accountAddress: string;
        clientKeyShares?: ClientKeyShare[];
        password?: string;
        signedSessionId: string;
    }): Promise<void>;
    updatePassword({ accountAddress, existingPassword, newPassword, signedSessionId, }: {
        accountAddress: string;
        existingPassword?: string;
        newPassword?: string;
        signedSessionId: string;
    }): Promise<void>;
    decryptKeyShare({ keyShare, password, }: {
        keyShare: string;
        password?: string;
    }): Promise<ClientKeyShare>;
    /**
     * Helper function to get Google OAuth Account ID or throw an error if not found.
     * @param accountAddress - The account address for logging purposes
     * @returns The Google OAuth Account ID
     * @throws Error if no Google OAuth account ID is found
     */
    private getGoogleOauthAccountIdOrThrow;
    /**
     * Helper function to determine keyshare recovery strategy for dynamic shares.
     * For REFRESH operations, retrieves enough shares to meet the client threshold.
     * For all other operations, retrieves just 1 share.
     *
     * @param clientKeyShareBackupInfo - Information about backed up key shares
     * @param thresholdSignatureScheme - The signature scheme being used (2-of-2, 2-of-3, etc)
     * @param walletOperation - The operation being performed (REFRESH, SIGN_MESSAGE, etc)
     * @param shareCount - The number of shares to recover if specified for reshare operations
     * @returns @shares: Object mapping backup locations to arrays of share IDs to recover
     * @returns @requiredShareCount: The number of shares required to recover
     */
    recoverStrategy({ clientKeyShareBackupInfo, thresholdSignatureScheme, walletOperation, shareCount, }: {
        clientKeyShareBackupInfo: KeyShareBackupInfo;
        thresholdSignatureScheme: ThresholdSignatureScheme;
        walletOperation: WalletOperation;
        shareCount?: number;
    }): {
        shares: Partial<Record<BackupLocation, string[]>>;
        requiredShareCount: number;
    };
    recoverEncryptedBackupByWallet({ accountAddress, password, walletOperation, signedSessionId, shareCount, storeRecoveredShares, mfaToken, }: {
        accountAddress: string;
        password?: string;
        walletOperation: WalletOperation;
        signedSessionId: string;
        shareCount?: number;
        storeRecoveredShares?: boolean;
        mfaToken?: string;
    }): Promise<any[]>;
    restoreWallets(): Promise<void>;
    /**
     * Internal helper method that handles the complete flow for ensuring wallet key shares are backed up to a cloud provider.
     * - For 2-of-2 wallets: Automatically reshares to 2-of-3 threshold, then distributes shares (1 to backend, 1 to cloud)
     * - For 2-of-3 wallets: Call storeEncryptedBackupByWallet to backup for backend and cloud
     */
    private backupKeySharesToCloudProvider;
    /**
     * This method handles the complete flow for ensuring wallet key shares are backed up to Google Drive:
     * - For 2-of-2 wallets: Automatically reshares to 2-of-3 threshold, then distributes shares (1 to backend, 1 to Google Drive)
     * - For 2-of-3 wallets: Call storeEncryptedBackupByWallet to backup for backend and Google Drive
     *
     * @param params - The backup parameters
     * @param params.accountAddress - The wallet account address to backup
     * @param params.password - Optional password for encryption (uses environment ID if not provided)
     * @param params.signedSessionId - Optional signed session ID for authentication
     */
    backupKeySharesToGoogleDrive({ accountAddress, password, signedSessionId, }: {
        accountAddress: string;
        password?: string;
        signedSessionId: string;
    }): Promise<void>;
    /**
     * This method handles the complete flow for ensuring wallet key shares are backed up to iCloud:
     * - For 2-of-2 wallets: Automatically reshares to 2-of-3 threshold, then distributes shares (1 to backend, 1 to iCloud)
     * - For 2-of-3 wallets: Call storeEncryptedBackupByWallet to backup for backend and iCloud
     *
     * @param params - The backup parameters
     * @param params.accountAddress - The wallet account address to backup
     * @param params.password - Optional password for encryption (uses environment ID if not provided)
     * @param params.signedSessionId - Optional signed session ID for authentication
     */
    backupKeySharesToICloud({ accountAddress, password, signedSessionId, }: {
        accountAddress: string;
        password?: string;
        signedSessionId: string;
    }): Promise<void>;
    /**
     * Generic router method that uploads encrypted key shares to the specified cloud provider
     * @param provider - The cloud backup provider (GOOGLE_DRIVE, ICLOUD, etc.)
     * @param accountAddress - Wallet account address
     * @param encryptedKeyShares - Already encrypted key shares to upload
     * @returns Promise<void>
     */
    private uploadToCloudProvider;
    /**
     * This method handles only the Google Drive upload mechanics without any reshare logic.
     * It encrypts the provided key shares, uploads them to Google Drive, and updates the
     * backup metadata. This method is intended for internal use by storeEncryptedBackupByWallet
     * and should not be called directly from external code.
     *
     * @param params - The upload parameters
     * @param params.accountAddress - The wallet account address
     * @param params.password - Optional password for encryption (uses environment ID if not provided)
     * @param params.encryptedKeyShares - The specific key shares to upload to Google Drive
     * @returns Promise<string[]> - Array of Google Drive key share IDs that were uploaded
     */
    private uploadKeySharesToGoogleDrive;
    /**
     * Private method that handles only the iCloud upload mechanics without any reshare logic.
     * It takes already encrypted key shares and uploads them to iCloud.
     * @param accountAddress - The wallet account address
     * @param encryptedKeyShares - Already encrypted key shares to upload
     * @returns Promise<void>
     */
    private uploadKeySharesToICloud;
    exportClientKeysharesFromGoogleDrive({ accountAddress, password, signedSessionId, }: {
        accountAddress: string;
        password?: string;
        signedSessionId: string;
    }): Promise<void>;
    exportClientKeyshares({ accountAddress, password, signedSessionId, }: {
        accountAddress: string;
        password?: string;
        signedSessionId: string;
    }): Promise<void>;
    getClientKeyShares({ accountAddress, password, signedSessionId, }: {
        accountAddress: string;
        password?: string;
        signedSessionId: string;
    }): Promise<ClientKeyShare[]>;
    /**
     * Helper function to check if the required wallet fields are present and valid
     * @param accountAddress - The account address of the wallet to check
     * @param walletOperation - The wallet operation that determines required fields
     * @returns boolean indicating if wallet needs to be re-fetched and restored from server
     */
    private checkWalletFields;
    /**
     * verifyPassword attempts to recover and decrypt a single client key share using the provided password.
     * If successful, the key share is encrypted with the new password. This method solely performs the recovery
     * and decryption without storing the restored key shares. If unsuccessful, it throws an error.
     */
    verifyPassword({ accountAddress, password, walletOperation, signedSessionId, }: {
        accountAddress: string;
        password?: string;
        walletOperation?: WalletOperation;
        signedSessionId: string;
    }): Promise<void>;
    isPasswordEncrypted({ accountAddress, }: {
        accountAddress: string;
    }): Promise<boolean>;
    /**
     * check if the operation requires a password
     */
    requiresPasswordForOperation({ accountAddress, walletOperation, }: {
        accountAddress: string;
        walletOperation?: WalletOperation;
    }): Promise<boolean>;
    /**
     * check if the operation requires restoring backup shares
     */
    requiresRestoreBackupSharesForOperation({ accountAddress, walletOperation, }: {
        accountAddress: string;
        walletOperation?: WalletOperation;
    }): Promise<boolean>;
    getWalletClientKeyShareBackupInfo({ accountAddress, }: {
        accountAddress: string;
    }): Promise<KeyShareBackupInfo>;
    getWallet({ accountAddress, walletOperation, shareCount, password, signedSessionId, }: {
        accountAddress: string;
        walletOperation?: WalletOperation;
        shareCount?: number;
        password?: string;
        signedSessionId: string;
    }): Promise<WalletProperties>;
    getWallets(): Promise<any>;
    /**
     * sync auth token with api client
     * @param authToken - auth token to sync
     */
    syncAuthToken(authToken: string): void;
    createRooms({ roomType, thresholdSignatureScheme, roomCount, }: {
        roomType: RoomTypeEnum;
        thresholdSignatureScheme: ThresholdSignatureScheme;
        roomCount?: number;
    }): Promise<void>;
    restoreRooms(): Promise<Record<number, Room[]>>;
    getRooms(roomType?: RoomTypeEnum, thresholdSignatureScheme?: ThresholdSignatureScheme): Promise<Room[] | Record<number, Room[]>>;
    setRooms(numberOfParties: number, rooms: Room[]): Promise<void>;
    getNumberOfParties(roomType: RoomTypeEnum, thresholdSignatureScheme: ThresholdSignatureScheme): number;
    getRoom(roomType: RoomTypeEnum, thresholdSignatureScheme: ThresholdSignatureScheme): Promise<Room | undefined>;
    /**
     * Helper method to instrument with automatic properties inclusion
     */
    instrument(message: string, context: InstrumentOptions & Record<string, any>): void;
    getTraceContext(traceContext?: TraceContext): TraceContext & {
        now: number;
        time: number;
    };
}
//# sourceMappingURL=client.d.ts.map