import type { EmblemAuthConfig, AuthSession, WalletAuthParams, AuthEventKey, AuthEventHandler, VaultInfo, Hex, EmailSendOtpParams, EmailVerifyOtpParams, EmailLoginParams, OAuthProvider } from './types';
import type { EmblemEthersWallet } from './signers/ethers';
import type { EmblemSolanaSigner } from './signers/solana';
import type { EmblemWeb3Adapter } from './signers/web3';
import type { EmblemBitcoinSigner } from './signers/bitcoin';
export declare class EmblemAuthSDK {
    private readonly config;
    private session;
    private pendingNonce;
    private readonly messageHandler;
    private overlayEl;
    private _iframeEl;
    private overlayCleanup;
    private readonly sessionMgr;
    private readonly events;
    private _cachedVaultInfo;
    private readonly storageKey;
    private readonly visitorIdKey;
    private _visitorId;
    constructor(config: EmblemAuthConfig);
    private tryConsumeSessionFromHash;
    /**
     * Authenticate with a wallet signature (programmatic/headless auth)
     * Uses the external verification endpoint for cross-origin compatibility
     */
    authenticateWallet(params: WalletAuthParams): Promise<AuthSession | null>;
    /**
     * Start OAuth sign-in (google/twitter) using authUrl's /auth/oauth/init proxy flow.
     * This uses the same postMessage contract as openAuthModal().
     */
    openOAuth(provider: OAuthProvider): Promise<void>;
    /**
     * Email registration: request OTP (server will send email; optionally returns OTP in dev).
     */
    sendEmailOtp(params: EmailSendOtpParams): Promise<{
        success: boolean;
        expiresAt?: string;
        otp?: string;
    }>;
    /**
     * Email registration: verify OTP and create a session.
     */
    verifyEmailOtp(params: EmailVerifyOtpParams): Promise<AuthSession | null>;
    /**
     * Email login (email + password) -> session.
     */
    authenticateEmail(params: EmailLoginParams): Promise<AuthSession | null>;
    /**
     * Authenticate with a password (for AI agents / headless auth)
     * Password is hashed with appId to create a deterministic identifier.
     * Same password = same vault, different password = different vault.
     * No email or browser required - ideal for AI agents.
     *
     * @param params.password - Must be at least 16 characters (use long random strings like API keys)
     *
     * @example
     * ```typescript
     * const session = await sdk.authenticatePassword({
     *   password: 'my-super-secret-agent-password-123'
     * });
     * ```
     */
    authenticatePassword(params: {
        password: string;
    }): Promise<AuthSession | null>;
    /**
     * Open the authentication modal
     */
    openAuthModal(): Promise<void>;
    /**
     * Get the current session
     */
    getSession(): AuthSession | null;
    /**
     * Get the visitor ID from the last authentication
     * This is the VaultFP fingerprint ID captured during auth
     */
    getVisitorId(): string | null;
    /**
     * Refresh the current session
     * Supports two modes:
     * - Web apps: Uses httpOnly cookies (credentials: include, no body)
     * - Mobile/Native apps: Uses refresh token from session (sent in body)
     */
    refreshSession(): Promise<AuthSession | null>;
    /**
     * Get vault information
     */
    getVaultInfo(): Promise<VaultInfo>;
    /**
     * Get or create the vault API key
     */
    getVaultApiKey(): Promise<string>;
    /**
     * Hydrate a previously saved session
     */
    hydrateSession(session: AuthSession): void;
    /**
     * Logout and clear the session
     */
    logout(): void;
    /**
     * Subscribe to auth events
     */
    on<K extends AuthEventKey>(event: K, handler: AuthEventHandler<K>): void;
    /**
     * Unsubscribe from auth events
     */
    off<K extends AuthEventKey>(event: K, handler: AuthEventHandler<K>): void;
    /**
     * Helper to get signer config and vault info
     */
    private getSignerContext;
    /**
     * Create a viem-compatible account adapter for EVM signing
     * Requires an active session with authToken
     *
     * @example
     * ```typescript
     * const account = await sdk.toViemAccount();
     * const signature = await account.signMessage({ message: 'Hello' });
     * ```
     */
    toViemAccount(): Promise<{
        address: Hex;
        signMessage: (args: {
            message: unknown;
        }) => Promise<Hex>;
        signTypedData: (typedData: unknown) => Promise<Hex>;
        signTransaction: (tx: unknown, opts?: unknown) => Promise<Hex>;
        type: 'local';
        source: 'custom';
    }>;
    /**
     * Create an ethers v6 compatible wallet adapter for EVM signing
     * Requires an active session with authToken
     *
     * @param provider - Optional ethers Provider for transaction population
     *
     * @example
     * ```typescript
     * const wallet = await sdk.toEthersWallet(provider);
     * const signature = await wallet.signMessage('Hello');
     * const tx = await wallet.sendTransaction({ to, value });
     * ```
     */
    toEthersWallet(provider?: unknown | null): Promise<EmblemEthersWallet>;
    /**
     * Create a Web3.js compatible adapter for EVM signing
     * Requires an active session with authToken
     *
     * @example
     * ```typescript
     * const adapter = await sdk.toWeb3Adapter();
     * const signature = await adapter.signMessage('Hello');
     * ```
     */
    toWeb3Adapter(): Promise<EmblemWeb3Adapter>;
    /**
     * Create a Solana Web3.js compatible signer
     * Requires an active session with authToken
     *
     * @example
     * ```typescript
     * const signer = await sdk.toSolanaWeb3Signer();
     * const signature = await signer.signMessage('Hello');
     * const signedTx = await signer.signTransaction(tx);
     * ```
     */
    toSolanaWeb3Signer(): Promise<EmblemSolanaSigner>;
    /**
     * Create a Solana Kit compatible signer
     * Requires an active session with authToken
     *
     * @example
     * ```typescript
     * const signer = await sdk.toSolanaKitSigner();
     * const signature = await signer.signMessage('Hello');
     * ```
     */
    toSolanaKitSigner(): Promise<EmblemSolanaSigner>;
    /**
     * Create a Bitcoin signer for PSBT signing
     * Requires an active session with authToken
     *
     * @example
     * ```typescript
     * const signer = await sdk.toBitcoinSigner();
     * console.log('Bitcoin addresses:', signer.addresses);
     *
     * // Sign a PSBT
     * const result = await signer.signPsbt(psbtBase64, {
     *   transactionType: 'p2wpkh'
     * });
     * console.log('Signed TX:', result.signedTxHex);
     * ```
     */
    toBitcoinSigner(): Promise<EmblemBitcoinSigner>;
    /**
     * Clean up event listeners
     */
    destroy(): void;
    private resolveModalUrl;
    private authDebugEnabled;
    private authDebug;
    /**
     * Normalize a configured URL. Accepts absolute URLs (https://...) or relative paths (/...).
     * If a host-like string is provided without a scheme (e.g. "api.emblemvault.ai"),
     * we assume https://.
     */
    private normalizeBaseUrl;
    private onMessage;
    private emit;
    private emitError;
    private popupFeatures;
    private randomId;
    private tryGetOriginFromConfig;
    private tryGetOriginFromApiUrl;
    private getAuthInit;
    private openIframeModal;
    private closeOverlay;
    /**
     * Cancel authentication (called when user closes modal via X button or Escape)
     */
    private cancelAuth;
    private safeJson;
    private loadPersistedSession;
    private persistSession;
    private loadPersistedVisitorId;
    private persistVisitorId;
}
//# sourceMappingURL=EmblemAuthSDK.d.ts.map