import type { IdentifyParams as SegmentIdentifyParams, TrackParams as SegmentTrackParams } from '@segment/analytics-node';
type Timestamp = SegmentTrackParams['timestamp'];
export type MongoshAnalyticsIdentity = SegmentIdentifyParams;
export type AnalyticsIdentifyMessage = MongoshAnalyticsIdentity & {
    traits: {
        platform: string;
        session_id: string;
        device_id: string;
    } & SegmentIdentifyParams['traits'];
};
export type AnalyticsTrackMessage = MongoshAnalyticsIdentity & {
    event: string;
    properties: {
        mongosh_version: string;
        session_id: string;
        [key: string]: any;
    };
    timestamp?: Timestamp;
};
export interface MongoshAnalytics {
    identify(message: AnalyticsIdentifyMessage): void;
    track(message: AnalyticsTrackMessage): void;
    flush(): Promise<void>;
}
declare class Queue<T> {
    private applyFn;
    private queue;
    private state;
    constructor(applyFn: (val: T) => void);
    push(val: T): void;
    enable(): void;
    disable(): void;
    pause(): void;
    getState(): "paused" | "enabled" | "disabled";
}
export declare class NoopAnalytics implements MongoshAnalytics {
    identify(): void;
    track(): void;
    flush(): Promise<void>;
}
type AnalyticsEventsQueueItem = ['identify', Parameters<MongoshAnalytics['identify']>] | ['track', Parameters<MongoshAnalytics['track']>];
export declare class ToggleableAnalytics implements MongoshAnalytics {
    _queue: Queue<AnalyticsEventsQueueItem>;
    _target: MongoshAnalytics;
    _pendingError?: Error;
    constructor(target?: MongoshAnalytics);
    identify(...args: Parameters<MongoshAnalytics['identify']>): void;
    track(...args: Parameters<MongoshAnalytics['track']>): void;
    enable(): void;
    disable(): void;
    pause(): void;
    _validateArgs([firstArg]: [MongoshAnalyticsIdentity]): void;
    flush(): Promise<void>;
}
type ThrottledAnalyticsOptions = {
    target: MongoshAnalytics;
    throttle: {
        rate: number;
        timeframe?: number;
        metadataPath: string;
        lockfileStaleDuration?: number;
    } | null;
};
export declare class ThrottledAnalytics implements MongoshAnalytics {
    private trackQueue;
    private target;
    private currentUserId;
    private throttleOptions;
    private throttleState;
    private restorePromise;
    private unlock;
    constructor({ target, throttle }?: Partial<ThrottledAnalyticsOptions>);
    get metadataPath(): string;
    identify(message: AnalyticsIdentifyMessage): void;
    track(message: AnalyticsTrackMessage): void;
    private restoreThrottleState;
    private shouldEmitAnalyticsEvent;
    flush(): Promise<void>;
}
type SampledAnalyticsOptions = {
    target?: MongoshAnalytics;
    sampling: () => boolean;
};
export declare class SampledAnalytics implements MongoshAnalytics {
    private isEnabled;
    private target;
    constructor(configuration: SampledAnalyticsOptions);
    get enabled(): boolean;
    identify(message: AnalyticsIdentifyMessage): void;
    track(message: AnalyticsTrackMessage): void;
    flush(): Promise<void>;
}
export {};