import { AddressType, PresignTransactionContext, SpendingLimitError } from '@phantom/client';
import { NetworkId, ClientSideSdkHeaders } from '@phantom/constants';
import { ParsedSignatureResult, ParsedTransactionResult } from '@phantom/parsers';
import { Algorithm, StamperWithKeyManagement, Transaction, VersionedTransaction } from '@phantom/sdk-types';
import { ISolanaChain, IEthereumChain, SignAndSendTransactionOptions, EthTransactionRequest } from '@phantom/chain-interfaces';
import { Logger } from '@phantom/utils';
export { Logger as DebugLogger } from '@phantom/utils';

interface WalletAddress {
    addressType: AddressType;
    address: string;
}
interface ConnectResult {
    walletId?: string;
    addresses: WalletAddress[];
    status?: "pending" | "completed";
    authUserId?: string;
    authProvider: EmbeddedProviderAuthType;
}
interface SignMessageParams {
    message: string;
    networkId: NetworkId;
}
interface SignTypedDataV4Params {
    typedData: any;
    networkId: NetworkId;
}
interface SignMessageResult extends ParsedSignatureResult {
}
interface SignTransactionParams {
    transaction: any;
    networkId: NetworkId;
}
interface SignAndSendTransactionParams {
    transaction: any;
    networkId: NetworkId;
    presignTransaction?: (transaction: string, context: PresignTransactionContext) => Promise<string>;
}
interface SignedTransaction extends ParsedTransactionResult {
}
type EmbeddedProviderAuthType = "google" | "apple" | "phantom" | "device";
interface AuthOptions {
    provider: EmbeddedProviderAuthType;
    customAuthData?: Record<string, any>;
}
interface EmbeddedProviderConfig {
    apiBaseUrl: string;
    appId: string;
    authOptions: {
        authUrl: string;
        redirectUrl: string;
        authApiBaseUrl: string;
    };
    embeddedWalletType: "app-wallet" | "user-wallet" | (string & Record<never, never>);
    addressTypes: AddressType[];
}

interface Keypair {
    publicKey: string;
    secretKey: string;
}
interface StamperInfo {
    keyId: string;
    publicKey: string;
    createdAt?: number;
    authenticatorId?: string;
}
interface Session {
    sessionId: string;
    walletId: string;
    organizationId: string;
    appId: string;
    stamperInfo: StamperInfo;
    keypair?: Keypair;
    authProvider: EmbeddedProviderAuthType;
    status: "pending" | "completed" | "failed";
    createdAt: number;
    lastUsed: number;
    authenticatorCreatedAt: number;
    authenticatorExpiresAt: number;
    lastRenewalAttempt?: number;
    accountDerivationIndex?: number;
    authUserId?: string;
    pkceCodeVerifier?: string;
    salt?: string;
    bearerToken?: string;
}
interface EmbeddedStorage {
    getSession(): Promise<Session | null>;
    saveSession(session: Session): Promise<void>;
    clearSession(): Promise<void>;
    getShouldClearPreviousSession(): Promise<boolean>;
    setShouldClearPreviousSession(should: boolean): Promise<void>;
}

/**
 * URL parameter accessor abstraction
 *
 * This allows us to abstract URL parameter access for different environments:
 * - Browser: window.location.search via URLSearchParams
 * - React Native: deep links or webview callback URLs
 * - Mobile WebView: in-app browser navigation state
 *
 * This abstraction makes the auth flow code portable across platforms
 * without needing to mock window.location directly in tests.
 */
interface URLParamsAccessor {
    /**
     * Get a URL parameter value by key
     * @param key - The parameter key to retrieve
     * @returns The parameter value or null if not found
     */
    getParam(key: string): string | null;
}

interface AuthResult {
    walletId: string;
    organizationId: string;
    provider: EmbeddedProviderAuthType;
    accountDerivationIndex: number;
    expiresInMs: number;
    authUserId?: string;
    bearerToken?: string;
}
interface PhantomConnectOptions {
    publicKey: string;
    appId: string;
    provider: EmbeddedProviderAuthType;
    redirectUrl?: string;
    authUrl?: string;
    sessionId: string;
    clearPreviousSession?: boolean;
    allowRefresh?: boolean;
    algorithm?: Algorithm;
}
interface AuthProvider {
    authenticate(options: PhantomConnectOptions): Promise<void | AuthResult>;
    resumeAuthFromRedirect?(provider: EmbeddedProviderAuthType): Promise<AuthResult | null>;
}
interface PhantomAppAuthOptions {
    publicKey: string;
    appId: string;
    sessionId: string;
}
interface PhantomAppProvider {
    authenticate(options: PhantomAppAuthOptions): Promise<AuthResult>;
    isAvailable(): boolean;
}

interface PlatformAdapter {
    name: string;
    storage: EmbeddedStorage;
    authProvider: AuthProvider;
    phantomAppProvider: PhantomAppProvider;
    urlParamsAccessor: URLParamsAccessor;
    stamper: StamperWithKeyManagement;
    analyticsHeaders?: Partial<ClientSideSdkHeaders>;
}

type EmbeddedProviderEvent = "connect" | "connect_start" | "connect_error" | "disconnect" | "error" | "spending_limit_reached";
interface ConnectEventData extends ConnectResult {
    source: "auto-connect" | "manual-connect" | "manual-existing" | "existing-session" | "manual";
}
interface ConnectStartEventData {
    source: "auto-connect" | "manual-connect";
    authOptions?: {
        provider?: string;
    };
    walletId?: string;
}
interface ConnectErrorEventData {
    error: string;
    source: "auto-connect" | "manual-connect";
}
interface DisconnectEventData {
    source: "manual";
}
interface EmbeddedProviderEventMap {
    connect: ConnectEventData;
    connect_start: ConnectStartEventData;
    connect_error: ConnectErrorEventData;
    disconnect: DisconnectEventData;
    error: any;
    spending_limit_reached: {
        error: SpendingLimitError;
    };
}
type EventCallback<T = any> = (data: T) => void;
declare class EmbeddedProvider {
    private config;
    private platform;
    private storage;
    private authProvider;
    private phantomAppProvider;
    private urlParamsAccessor;
    private stamper;
    private logger;
    private client;
    private walletId;
    private addresses;
    readonly solana: ISolanaChain;
    readonly ethereum: IEthereumChain;
    private eventListeners;
    constructor(config: EmbeddedProviderConfig, platform: PlatformAdapter, logger: Logger);
    on<K extends EmbeddedProviderEvent>(event: K, callback: EventCallback<EmbeddedProviderEventMap[K]>): void;
    off<K extends EmbeddedProviderEvent>(event: K, callback: EventCallback<EmbeddedProviderEventMap[K]>): void;
    private emit;
    /**
     * Get the appropriate address for a given network ID from available addresses
     */
    private getAddressForNetwork;
    private getAndFilterWalletAddresses;
    private validateAndCleanSession;
    private tryExistingConnection;
    private validateAuthOptions;
    private isSessionValid;
    autoConnect(): Promise<void>;
    private initializeStamper;
    private createOrganizationForAppWallet;
    connect(authOptions: AuthOptions): Promise<ConnectResult>;
    disconnect(shouldClearPreviousSession?: boolean): Promise<void>;
    /**
     * Handles errors from signing operations.
     * Disconnects the user if the server returns a 401/403 (revoked or expired authenticator)
     * or if the Auth2 token (a2t) has expired.
     */
    private handleSigningError;
    signMessage(params: SignMessageParams): Promise<ParsedSignatureResult>;
    signEthereumMessage(params: SignMessageParams): Promise<ParsedSignatureResult>;
    signTypedDataV4(params: SignTypedDataV4Params): Promise<ParsedSignatureResult>;
    signTransaction(params: SignTransactionParams): Promise<ParsedTransactionResult>;
    signAndSendTransaction(params: SignAndSendTransactionParams): Promise<ParsedTransactionResult>;
    getAddresses(): WalletAddress[];
    isConnected(): boolean;
    private handleAuthFlow;
    private handlePhantomAuth;
    private handleRedirectAuth;
    private completeAuthConnection;
    private ensureValidAuthenticator;
    private initializeClientFromSession;
}

declare function generateSessionId(): string;

declare function retryWithBackoff<T>(operation: () => Promise<T>, operationName: string, logger: Logger, maxRetries?: number, baseDelay?: number): Promise<T>;

/**
 * Embedded Solana chain implementation that is wallet adapter compliant
 */
declare class EmbeddedSolanaChain implements ISolanaChain {
    private provider;
    private currentNetworkId;
    private _publicKey;
    private eventEmitter;
    constructor(provider: EmbeddedProvider);
    get publicKey(): string | null;
    get isConnected(): boolean;
    private ensureConnected;
    signMessage(message: string | Uint8Array): Promise<{
        signature: Uint8Array;
        publicKey: string;
    }>;
    signTransaction(transaction: Transaction | VersionedTransaction): Promise<Transaction | VersionedTransaction>;
    signAndSendTransaction(transaction: Transaction | VersionedTransaction, options?: SignAndSendTransactionOptions): Promise<{
        signature: string;
    }>;
    signAllTransactions(transactions: (Transaction | VersionedTransaction)[]): Promise<(Transaction | VersionedTransaction)[]>;
    signAndSendAllTransactions(transactions: (Transaction | VersionedTransaction)[]): Promise<{
        signatures: string[];
    }>;
    connect(_options?: {
        onlyIfTrusted?: boolean;
    }): Promise<{
        publicKey: string;
    }>;
    disconnect(): Promise<void>;
    switchNetwork(network: "mainnet" | "devnet"): Promise<void>;
    private setupEventListeners;
    private syncInitialState;
    on(event: string, listener: (...args: any[]) => void): void;
    off(event: string, listener: (...args: any[]) => void): void;
}

/**
 * Embedded Ethereum chain implementation that is EIP-1193 compliant
 */
declare class EmbeddedEthereumChain implements IEthereumChain {
    private provider;
    private currentNetworkId;
    private _accounts;
    private eventEmitter;
    constructor(provider: EmbeddedProvider);
    get chainId(): string;
    get accounts(): string[];
    private ensureConnected;
    request<T = any>(args: {
        method: string;
        params?: unknown[];
    }): Promise<T>;
    connect(): Promise<string[]>;
    disconnect(): Promise<void>;
    signPersonalMessage(message: string, address: string): Promise<string>;
    signTypedData(typedData: any, address: string): Promise<string>;
    signTransaction(transaction: EthTransactionRequest): Promise<string>;
    sendTransaction(transaction: EthTransactionRequest): Promise<string>;
    switchChain(chainId: number | string): Promise<void>;
    getChainId(): Promise<number>;
    getAccounts(): Promise<string[]>;
    isConnected(): boolean;
    private setupEventListeners;
    private syncInitialState;
    private updateConnectionState;
    private handleEmbeddedRequest;
    on(event: string, listener: (...args: any[]) => void): void;
    off(event: string, listener: (...args: any[]) => void): void;
}

/**
 * How long an authenticator is valid before it expires (in milliseconds)
 * Default: 31 days
 * For testing: Use smaller values like 5 * 60 * 1000 (5 minutes)
 */
declare const AUTHENTICATOR_EXPIRATION_TIME_MS: number;
/**
 * How long before expiration should we attempt to renew the authenticator (in milliseconds)
 * Default: 2 days before expiration
 * For testing: Use smaller values like 2 * 60 * 1000 (2 minutes)
 */
declare const AUTHENTICATOR_RENEWAL_WINDOW_MS: number;
declare const EMBEDDED_PROVIDER_AUTH_TYPES: EmbeddedProviderAuthType[];

export { AUTHENTICATOR_EXPIRATION_TIME_MS, AUTHENTICATOR_RENEWAL_WINDOW_MS, AuthOptions, AuthProvider, AuthResult, ConnectErrorEventData, ConnectEventData, ConnectResult, ConnectStartEventData, DisconnectEventData, EMBEDDED_PROVIDER_AUTH_TYPES, EmbeddedEthereumChain, EmbeddedProvider, EmbeddedProviderAuthType, EmbeddedProviderConfig, EmbeddedProviderEvent, EmbeddedProviderEventMap, EmbeddedSolanaChain, EmbeddedStorage, EventCallback, Keypair, PhantomAppAuthOptions, PhantomAppProvider, PhantomConnectOptions, PlatformAdapter, Session, SignAndSendTransactionParams, SignMessageParams, SignMessageResult, SignTransactionParams, SignTypedDataV4Params, SignedTransaction, StamperInfo, URLParamsAccessor, WalletAddress, generateSessionId, retryWithBackoff };