import type Fetch from '../../fetch';
import type { Crypto } from '@voiceflow/common';
import Fetcher from '../fetcher';
interface HashOptions<K> {
    envIDs?: K[];
    hashed?: K[];
    teamhashed?: K[];
}
interface TrackOptions<P extends Record<string, any>, K extends keyof P> extends HashOptions<K> {
    properties?: P;
}
interface PublicTrackOptions<P extends Record<string, any>, K extends keyof P> extends TrackOptions<P, K> {
    anonymousID?: string;
}
interface IdentifyOptions<T extends Record<string, any>, K extends keyof T> extends HashOptions<K> {
    traits: T;
}
interface AnalyticsOptions {
    encryption?: Crypto.Synchronous;
    batching?: boolean;
}
declare class Analytics extends Fetcher<Analytics, AnalyticsOptions> {
    private batching?;
    private encryption?;
    private publicQueue;
    private privateQueue;
    constructor(fetch: Fetch, options?: AnalyticsOptions);
    protected get endpoint(): "analytics" | "vf-ping";
    private get encrypted();
    private encryptedPayload;
    private onFlushPublic;
    private onFlushPrivate;
    setBatching(batching: boolean): void;
    flush(): Promise<void>;
    track<P extends Record<string, any>, K extends keyof P>(event: string, { envIDs, hashed, teamhashed, properties }?: TrackOptions<P, K>): Promise<void>;
    trackPublic<P extends Record<string, any>, K extends keyof P>(event: string, { envIDs, hashed, teamhashed, anonymousID, properties }?: PublicTrackOptions<P, K>): Promise<void>;
    identify<T extends Record<string, any>, K extends keyof T>({ envIDs, traits, hashed, teamhashed, }: IdentifyOptions<T, K>): Promise<void>;
    identifyWorkspace<T extends {
        name: string;
    }>(id: string, properties: T): Promise<void>;
}
export default Analytics;
//# sourceMappingURL=index.d.ts.map