interface optionsInterface {
    exclude?: string[];
    include?: string[];
    permissions_to_check?: PermissionName[];
    timeout?: number;
    logging?: boolean;
    api_key?: string;
    cache_api_call?: boolean;
    performance?: boolean;
    stabilize?: string[];
    experimental?: boolean;
    apiKey?: string;
    domain?: string;
    sessionId?: string;
    pageId?: string;
    extendedChecks?: boolean;
    fpcomApiKey?: string;
    fpcomDomain?: string;
}

type CompleteCallback = (success: boolean, error?: string) => void;
/**
 * A client for generating browser fingerprints with a persistent configuration.
 */
declare class Fingerprint {
    private options;
    private callback?;
    private isCollecting;
    private collectionPromise?;
    /**
     * Creates a new Fingerprint client instance.
     * @param options - Default configuration options for this instance.
     * If domain is provided, fingerprint will be automatically collected and sent.
     */
    constructor(options?: optionsInterface);
    /**
     * Extracts client_transaction_id from URL query parameters
     * @returns sessionId or undefined
     */
    private extractSessionIdFromUrl;
    /**
     * Collects fingerprint data and sends it to the configured domain
     */
    private collectAndSend;
    /**
     * Sends encrypted fingerprint data to the server
     * @param data - Encrypted fingerprint result
     */
    private sendToServer;
    /**
     * Register a callback to be called when fingerprint collection and sending completes
     * @param callback - Function to call with success status and optional error message
     */
    onComplete(callback: CompleteCallback): void;
}

declare function getAudio(): Promise<componentInterface | null>;

declare function getCanvas(): Promise<componentInterface | null>;

declare function getFonts(options?: optionsInterface): Promise<componentInterface | null>;

declare function getHardware(): Promise<componentInterface>;

declare function getLocales(): Promise<componentInterface>;

declare function getMath(): Promise<componentInterface>;

declare function getPermissions(options?: optionsInterface): Promise<componentInterface>;

declare function getPlugins(): Promise<componentInterface | null>;

declare function getScreen(): Promise<componentInterface>;

declare function getSystem(): Promise<componentInterface>;

declare function getWebGL(): Promise<componentInterface>;

declare function getWebGLInfo(): Promise<componentInterface>;

declare function getSpeech(): Promise<componentInterface>;

declare function getWebRTC(): Promise<componentInterface | null>;

declare function getMathML(): Promise<componentInterface | null>;

type WASMResult = componentInterface & {
    averageTime?: number;
    variance?: number;
    stdDev?: number;
    coefficientOfVariation?: number;
    minTime?: number;
    maxTime?: number;
    runs?: number;
};
declare function getWASM(): Promise<WASMResult>;

/**
 * CPU timing attack for VM detection
 * Runs Sieve of Eratosthenes algorithm multiple times and measures timing variance
 */
declare function getTimingCPU(): Promise<componentInterface>;

/**
 * Memory access timing attack for VM detection
 * Compares sequential vs random memory access patterns
 */
declare function getTimingMemory(): Promise<componentInterface>;

/**
 * High-precision timer granularity test for VM detection
 * VMs often reduce timer precision for security, resulting in coarser granularity
 */
declare function getTimingPrecision(): Promise<componentInterface>;

/**
 * Context switch detection via busy-wait timing
 * VMs exhibit more context switches due to hypervisor scheduling
 */
declare function getTimingContext(): Promise<componentInterface>;

/**
 * Canvas rendering timing attack for VM detection
 * GPU virtualization introduces timing variance
 */
declare function getTimingCanvas(): Promise<componentInterface>;

/**
 * Cryptographic operations timing attack for VM detection
 * Crypto operations are often slower and more variable on VMs
 */
declare function getTimingCrypto(): Promise<componentInterface>;

/**
 * Collects raw direct VM-detection signals from browser APIs.
 * No scoring is performed here — the server-side Go code handles scoring
 * before writing to Kafka. This keeps the scoring algorithm private and
 * updatable without redeploying the client library.
 *
 * Collected signals:
 *  - WebGL renderer/vendor strings (may reveal VM GPU driver names)
 *  - navigator.hardwareConcurrency (CPU core count)
 *  - navigator.deviceMemory (approximate RAM in GB)
 *  - Performance counter frequency via GCD on performance.now() samples
 */
declare function getVmSignals(): Promise<componentInterface>;

/**
 * This file is used to create the includeComponent function as well as the interfaces each of the
 * fingerprint components must implement.
 *
 */

/**
 * @description key->function map of built-in components. Do not call the function here.
 */
declare const tm_component_promises: {
    audio: typeof getAudio;
    canvas: typeof getCanvas;
    fonts: typeof getFonts;
    hardware: typeof getHardware;
    locales: typeof getLocales;
    math: typeof getMath;
    permissions: typeof getPermissions;
    plugins: typeof getPlugins;
    screen: typeof getScreen;
    speech: typeof getSpeech;
    system: typeof getSystem;
    webgl: typeof getWebGL;
    webglInfo: typeof getWebGLInfo;
};
/**
 * @description key->function map of experimental components. Only resolved during logging.
 */
declare const tm_experimental_component_promises: {
    webrtc: typeof getWebRTC;
    mathml: typeof getMathML;
    wasm: typeof getWASM;
    timingCpu: typeof getTimingCPU;
    timingMemory: typeof getTimingMemory;
    timingPrecision: typeof getTimingPrecision;
    timingContext: typeof getTimingContext;
    timingCanvas: typeof getTimingCanvas;
    timingCrypto: typeof getTimingCrypto;
    vmSignals: typeof getVmSignals;
};
interface componentInterface {
    [key: string]: string | string[] | number | boolean | componentInterface;
}

/**
 * Main encrypted export pipeline
 * Combines compression, encryption, and HMAC fingerprinting
 */

/**
 * Result of encrypted fingerprint data
 */
interface EncryptedFingerprintResult {
    /** Base64-encoded encrypted and compressed data */
    encryptedData: string;
    /** HMAC-SHA256 fingerprint hash (hex) from original JSON */
    fingerprint: string;
}

/**
 * EmbermindFingerprint: Main fingerprinting and API logic
 *
 * This module handles component collection, API calls, uniqueness scoring, and data filtering
 * for the EmbermindFingerprint browser fingerprinting library.
 *
 */

/**
 * Final fingerprint response structure
 */
interface fingerprintResponse {
    components: componentInterface;
    info: {
        [key: string]: any;
    };
    version: string;
    fingerprint: string;
    visitorId?: string;
    elapsed?: any;
    error?: string;
    experimental?: componentInterface;
}
/**
 * Main entry point: collects all components, optionally calls API, and returns fingerprint data.
 *
 * @param options - Options for fingerprinting and API
 * @returns fingerprintResponse (elapsed is present only if options.performance is true)
 */
declare function getFingerprint(options?: optionsInterface): Promise<fingerprintResponse>;
/**
 * Returns ONLY encrypted data + fingerprint hash
 * No raw components exposed
 *
 * This is the main entry point for encrypted fingerprinting.
 * Returns only encrypted data and HMAC fingerprint hash.
 *
 * @param options - Fingerprint options
 * @returns Encrypted fingerprint data and hash
 */
declare function getFingerprintEncrypted(options?: optionsInterface): Promise<EncryptedFingerprintResult>;

export { Fingerprint, getFingerprint, getFingerprintEncrypted, type optionsInterface, tm_component_promises, tm_experimental_component_promises };