import { City } from '@maxmind/geoip2-node';
import { Response, Headers } from 'node-fetch';
/** Input for a PostHog plugin. */
export type PluginInput = {
    config?: Record<string, any>;
    attachments?: Record<string, PluginAttachment | undefined>;
    global?: Record<string, any>;
    /** @deprecated */
    jobs?: Record<string, JobOptions>;
    /** @deprecated */
    metrics?: Record<string, AllowedMetricsOperations>;
};
export interface Webhook {
    url: string;
    body: string;
    headers?: Record<string, string>;
    method?: 'POST' | 'GET' | 'PUT' | 'DELETE' | 'PATCH';
}
/** A PostHog plugin. */
export interface Plugin<Input extends PluginInput = {}> {
    /** Ran when the plugin is loaded by the PostHog plugin server. */
    setupPlugin?: (meta: Meta<Input>) => void;
    /** Ran when the plugin is unloaded by the PostHog plugin server. */
    teardownPlugin?: (meta: Meta<Input>) => void;
    /** @deprecated */
    getSettings?: (meta: Meta<Input>) => PluginSettings;
    /** Not supported yet: Used for filtering events, return True to keep the event and False to drop it. */
    filterEvent?: (event: PostHogEvent, meta: Meta<Input>) => boolean;
    /** Not supported yet: Used for modifying events, return the updated event */
    modifyEvent?: (event: PostHogEvent, meta: Meta<Input>) => PostHogEvent;
    /** For filtering or modifing events */
    processEvent?: (event: PluginEvent, meta: Meta<Input>) => PluginEvent | null | Promise<PluginEvent | null>;
    /** @deprecated: use processEvent */
    processEventBatch?: (eventBatch: PluginEvent[], meta: Meta<Input>) => PluginEvent[] | Promise<PluginEvent[]>;
    /** @deprecated: use composeWebhook */
    exportEvents?: (events: ProcessedPluginEvent[], meta: Meta<Input>) => void | Promise<void>;
    /** @deprecated: use composeWebhook */
    onEvent?: (event: ProcessedPluginEvent, meta: Meta<Input>) => void | Promise<void>;
    onEventWithPostHogEvent?: (event: PostHogEvent, meta: Meta<Input>) => Promise<void> | void;
    /** Used for exporting a single event */
    composeWebhook?: (event: PostHogEvent, meta: Meta<Input>) => Webhook | null;
    /** @deprecated:  */
    runEveryMinute?: (meta: Meta<Input>) => void;
    /** @deprecated:  */
    runEveryHour?: (meta: Meta<Input>) => void;
    /** @deprecated:  */
    runEveryDay?: (meta: Meta<Input>) => void;
    /** @deprecated */
    jobs?: {
        [K in keyof Meta<Input>['jobs']]: (opts: Parameters<Meta<Input>['jobs'][K]>[0], meta: Meta<Input>) => void | Promise<void>;
    };
    /** @deprecated */
    metrics?: {
        [K in keyof Meta<Input>['metrics']]: AllowedMetricsOperations;
    };
    __internalMeta?: Meta<Input>;
}
export type PluginMeta<T> = T extends {
    __internalMeta?: infer M;
} ? M : never;
export type Properties = Record<string, any>;
/** We're moving to a single PostHogEvent model use this in any future apps/plugins
*/
export interface PostHogEvent {
    /** The assigned UUIDT of the event. */
    uuid: string;
    team_id: number;
    distinct_id: string;
    event: string;
    timestamp: Date;
    /** Optionally contains
     * $ip - for ip address, which will be removed later if project settings anonymize_ips is true
     * $set - for person properties to set
     * $set_once - for person properties to set if not already set
     * $elements_chain - for autocapture elements chain
     */
    properties: Properties;
    person?: PostHogPerson;
    groups?: Record<string, PostHogGroup>;
}
export interface PostHogPerson {
    uuid: string;
    properties: Properties;
    posthog_url: string;
}
export interface PostHogGroup {
    key: string;
    properties: Properties;
    posthog_url: string;
}
export interface PluginAttachment {
    content_type: string;
    file_name: string;
    contents: any;
}
interface BasePluginMeta {
    cache: CacheExtension;
    storage: StorageExtension;
    geoip: GeoIPExtension;
    config: Record<string, any>;
    global: Record<string, any>;
    attachments: Record<string, PluginAttachment | undefined>;
    jobs: Record<string, (opts: any) => JobControls>;
    metrics: Record<string, Partial<FullMetricsControls>>;
    utils: UtilsExtension;
}
export interface Meta<Input extends PluginInput = {}> extends BasePluginMeta {
    attachments: Input['attachments'] extends Record<string, PluginAttachment | undefined> ? Input['attachments'] : Record<string, PluginAttachment | undefined>;
    config: Input['config'] extends Record<string, any> ? Input['config'] : Record<string, any>;
    global: Input['global'] extends Record<string, any> ? Input['global'] : Record<string, any>;
    jobs: Input['jobs'] extends Record<string, JobOptions> ? MetaJobsFromJobOptions<Input['jobs']> : Record<string, (opts: any) => JobControls>;
    metrics: Input['metrics'] extends Record<string, AllowedMetricsOperations> ? MetaMetricsFromMetricsOptions<Input['metrics']> : Record<string, FullMetricsControls>;
}
type ConfigDependencyArrayValue = string | undefined;
type ConfigDependencySubArray = ConfigDependencyArrayValue[];
type ConfigDependencyArray = ConfigDependencySubArray[];
export interface PluginConfigStructure {
    key?: string;
    name?: string;
    default?: string;
    hint?: string;
    markdown?: string;
    order?: number;
    required?: boolean;
    secret?: boolean;
    required_if?: ConfigDependencyArray;
    visible_if?: ConfigDependencyArray;
}
export interface PluginConfigDefault extends PluginConfigStructure {
    type?: 'string' | 'json' | 'attachment';
}
export interface PluginConfigChoice extends PluginConfigStructure {
    type: 'choice';
    choices: string[];
}
export type PluginConfigSchema = PluginConfigDefault | PluginConfigChoice;
export interface ConsoleExtension {
    log: (...args: unknown[]) => void;
    error: (...args: unknown[]) => void;
    debug: (...args: unknown[]) => void;
    info: (...args: unknown[]) => void;
    warn: (...args: unknown[]) => void;
}
export interface PluginPerson {
    uuid: string;
    team_id: number;
    properties: Properties;
    created_at: string;
}
export declare enum MetricsOperation {
    Sum = "sum",
    Min = "min",
    Max = "max"
}
export type AllowedMetricsOperations = MetricsOperation.Sum | MetricsOperation.Max | MetricsOperation.Min;
export type PluginSettings = {
    /** Experimental:
    
        Some plugins incur high costs for small batches, e.g. S3. In these cases
        we want to signal that the plugin would prefer larger batches. There are other
        plugins that may not be written to handle large batches, for these we will want
        to keep batches small to not break their behaviour.
        
        Defaults to `false`.
    */
    handlesLargeBatches?: boolean;
};
/** @deprecated: Use PostHogEvent.properties['$elements_chain'] */
export interface Element {
    text?: string;
    tag_name?: string;
    href?: string;
    attr_id?: string;
    attr_class?: string[];
    nth_child?: number;
    nth_of_type?: number;
    attributes?: Record<string, any>;
    event_id?: number;
    order?: number;
    group_id?: number;
}
/** @deprecated: Use PostHogEvent */
export interface PluginEvent {
    distinct_id: string;
    ip: string | null;
    site_url: string;
    team_id: number;
    now: string;
    event: string;
    sent_at?: string;
    properties?: Properties;
    timestamp?: string;
    offset?: number;
    /** Person properties update (override). */
    $set?: Properties;
    /** Person properties update (if not set). */
    $set_once?: Properties;
    /** The assigned UUIDT of the event. */
    uuid: string;
    /** Person associated with the original distinct ID of the event. */
    person?: PluginPerson;
}
/** @deprecated: Use PostHogEvent */
export interface ProcessedPluginEvent {
    distinct_id: string;
    ip: string | null;
    team_id: number;
    event: string;
    properties: Properties;
    timestamp: string;
    /** Person properties update (override). */
    $set?: Properties;
    /** Person properties update (if not set). */
    $set_once?: Properties;
    /** The assigned UUIDT of the event. */
    uuid: string;
    /** Person associated with the original distinct ID of the event. */
    person?: PluginPerson;
    /** We process `$elements` out of `properties`, so we want to make sure we
     * maintain this in the processed event that we pass to plugins */
    elements?: Element[];
}
type JobOptions = Record<string, any> | undefined;
type JobControls = {
    runNow: () => Promise<void>;
    runIn: (duration: number, unit: string) => Promise<void>;
    runAt: (date: Date) => Promise<void>;
};
interface MetricsControlsIncrement {
    increment: (value: number) => Promise<void>;
}
interface MetricsControlsMax {
    max: (value: number) => Promise<void>;
}
interface MetricsControlsMin {
    min: (value: number) => Promise<void>;
}
type FullMetricsControls = MetricsControlsIncrement & MetricsControlsMax & MetricsControlsMin;
type MetricsControls<V> = V extends MetricsOperation.Sum ? MetricsControlsIncrement : V extends MetricsOperation.Max ? MetricsControlsMax : MetricsControlsMin;
type MetaMetricsFromMetricsOptions<J extends Record<string, string>> = {
    [K in keyof J]: MetricsControls<J[K]>;
};
type MetaJobsFromJobOptions<J extends Record<string, JobOptions>> = {
    [K in keyof J]: (opts: J[K]) => JobControls;
};
export interface CacheOptions {
    /** Whether input should be JSON-stringified/parsed. */
    jsonSerialize?: boolean;
}
export interface CacheExtension {
    set: (key: string, value: unknown, ttlSeconds?: number, options?: CacheOptions) => Promise<void>;
    get: (key: string, defaultValue: unknown, options?: CacheOptions) => Promise<unknown>;
    incr: (key: string) => Promise<number>;
    expire: (key: string, ttlSeconds: number) => Promise<boolean>;
    lpush: (key: string, elementOrArray: unknown[]) => Promise<number>;
    lrange: (key: string, startIndex: number, endIndex: number) => Promise<string[]>;
    llen: (key: string) => Promise<number>;
    lpop: (key: string, count: number) => Promise<string[]>;
    lrem: (key: string, count: number, elementKey: string) => Promise<number>;
}
export interface StorageExtension {
    set: (key: string, value: unknown) => Promise<void>;
    get: (key: string, defaultValue: unknown) => Promise<unknown>;
    del: (key: string) => Promise<void>;
}
export interface GeoIPExtension {
    locate: (ip: string) => Promise<City | null>;
}
export interface UtilsExtension {
    cursor: CursorUtils;
}
export interface CursorUtils {
    init: (key: string, initialValue?: number) => Promise<void>;
    increment: (key: string, incrementBy?: number) => Promise<number>;
}
interface ApiMethodOptions {
    headers?: Headers;
    data?: Record<string, any>;
    host?: string;
    projectApiKey?: string;
    personalApiKey?: string;
}
export interface ApiExtension {
    get(path: string, options?: ApiMethodOptions): Promise<Response>;
    post(path: string, options?: ApiMethodOptions): Promise<Response>;
    put(path: string, options?: ApiMethodOptions): Promise<Response>;
    delete(path: string, options?: ApiMethodOptions): Promise<Response>;
}
export interface PostHogExtension {
    capture(event: string, properties?: Record<string, any>): Promise<void>;
    api: ApiExtension;
}
export {};