import { EventEmitterSlug } from './event-emitter-types';
import type { JSONSchema4 } from 'json-schema';
import { Action, ActionDefinition, ActionHookDefinition, ActionHookType, hookTypeStrings, ActionHookResponse, BaseActionDefinition, RequestFn, ExecuteDynamicFieldInput } from './action';
import { JSONLikeObject, JSONObject } from '../json-object';
import { SegmentEvent } from '../segment-event';
import { fieldsToJsonSchema, MinimalInputField } from './fields-to-jsonschema';
import { RequestClient, ResponseError } from '../create-request-client';
import type { ModifiedResponse } from '../types';
import type { GlobalSetting, RequestExtension, ExecuteInput, Result, Deletion, DynamicFieldResponse, ResultMultiStatusNode } from './types';
import type { AllRequestOptions } from '../request-client';
import { AuthTokens } from './parse-settings';
import { Features } from '../mapping-kit';
import { HTTPError } from '..';
export type { BaseActionDefinition, ActionDefinition, ActionHookDefinition, ActionHookResponse, ActionHookType, ExecuteInput, RequestFn, Result };
export { hookTypeStrings };
export type { MinimalInputField };
export { fieldsToJsonSchema };
export interface SubscriptionStats {
    duration: number;
    destination: string;
    action: string;
    subscribe: string;
    input: JSONLikeObject;
    output: Result[] | null;
}
interface PartnerActions<Settings, Payload extends JSONLikeObject, AudienceSettings = any> {
    [key: string]: Action<Settings, Payload, AudienceSettings>;
}
export interface BaseDefinition {
    name: string;
    mode: 'cloud' | 'device' | 'warehouse';
    description?: string;
    slug?: string;
    actions: Record<string, BaseActionDefinition>;
    presets?: Preset[];
}
export type AudienceResult = {
    externalId: string;
};
export type AudienceMode = {
    type: 'realtime';
} | {
    type: 'synced';
    full_audience_sync: boolean;
};
export type Personas = {
    computation_id: string;
    computation_key: string;
    namespace: string;
    [key: string]: unknown;
};
export type CreateAudienceInput<Settings = unknown, AudienceSettings = unknown> = {
    settings: Settings;
    audienceSettings?: AudienceSettings;
    personas?: Personas;
    audienceName: string;
    statsContext?: StatsContext;
    features?: Features;
};
export type GetAudienceInput<Settings = unknown, AudienceSettings = unknown> = {
    settings: Settings;
    audienceSettings?: AudienceSettings;
    externalId: string;
    statsContext?: StatsContext;
    features?: Features;
};
export interface AudienceDestinationConfiguration {
    mode: AudienceMode;
}
export interface AudienceDestinationConfigurationWithCreateGet<Settings = unknown, AudienceSettings = unknown> extends AudienceDestinationConfiguration {
    createAudience(request: RequestClient, createAudienceInput: CreateAudienceInput<Settings, AudienceSettings>): Promise<AudienceResult>;
    getAudience(request: RequestClient, getAudienceInput: GetAudienceInput<Settings, AudienceSettings>): Promise<AudienceResult>;
}
export interface AudienceDestinationDefinition<Settings = unknown, AudienceSettings = unknown> extends DestinationDefinition<Settings> {
    audienceConfig: AudienceDestinationConfigurationWithCreateGet<Settings, AudienceSettings> | AudienceDestinationConfiguration;
    audienceFields: Record<string, GlobalSetting>;
    actions: Record<string, ActionDefinition<Settings, any, AudienceSettings>>;
}
export interface DestinationDefinition<Settings = unknown> extends BaseDefinition {
    mode: 'cloud';
    actions: Record<string, ActionDefinition<Settings>>;
    extendRequest?: RequestExtension<Settings, any>;
    authentication?: AuthenticationScheme<Settings>;
    onDelete?: Deletion<Settings>;
}
export interface WarehouseDestinationDefinition<Settings = unknown> extends BaseDefinition {
    mode: 'warehouse';
    actions: Record<string, ActionDefinition<Settings>>;
    settings: Record<string, GlobalSetting>;
    onDelete?: Deletion<Settings>;
}
interface AutomaticPreset extends Subscription {
    type: 'automatic';
}
interface SpecificEventPreset extends Omit<Subscription, 'subscribe'> {
    type: 'specificEvent';
    eventSlug: EventEmitterSlug;
}
export type Preset = AutomaticPreset | SpecificEventPreset;
export interface Subscription {
    name?: string;
    partnerAction: string;
    subscribe: string;
    mapping?: JSONObject;
    ActionID?: string;
    ConfigID?: string;
    ID?: string;
    ProjectID?: string;
}
export interface OAuth2ClientCredentials extends AuthTokens {
    clientId: string;
    clientSecret: string;
}
export interface RefreshAccessTokenResult {
    accessToken: string;
    refreshToken?: string;
}
interface AuthSettings<Settings> {
    settings: Settings;
    auth: AuthTokens;
}
interface RefreshAuthSettings<Settings> {
    settings: Settings;
    auth: OAuth2ClientCredentials;
}
interface Authentication<Settings> {
    scheme: 'basic' | 'custom' | 'oauth2' | 'oauth-managed';
    fields: Record<string, GlobalSetting>;
    testAuthentication?: (request: RequestClient, input: AuthSettings<Settings>) => Promise<unknown> | unknown;
}
export interface CustomAuthentication<Settings> extends Authentication<Settings> {
    scheme: 'custom';
}
export interface BasicAuthentication<Settings> extends Authentication<Settings> {
    scheme: 'basic';
}
export interface OAuth2Authentication<Settings> extends Authentication<Settings> {
    scheme: 'oauth2';
    refreshAccessToken?: (request: RequestClient, input: RefreshAuthSettings<Settings>) => Promise<RefreshAccessTokenResult>;
}
export interface OAuthManagedAuthentication<Settings> extends Authentication<Settings> {
    scheme: 'oauth-managed';
    refreshAccessToken?: (request: RequestClient, input: RefreshAuthSettings<Settings>) => Promise<RefreshAccessTokenResult>;
}
export type AuthenticationScheme<Settings = any> = BasicAuthentication<Settings> | CustomAuthentication<Settings> | OAuth2Authentication<Settings> | OAuthManagedAuthentication<Settings>;
export type SubscriptionMetadata = {
    actionConfigId?: string;
    destinationConfigId?: string;
    actionId?: string;
    sourceId?: string;
};
interface EventInput<Settings> {
    readonly event: SegmentEvent;
    readonly mapping: JSONObject;
    readonly settings: Settings;
    readonly auth?: AuthTokens;
    readonly features?: Features;
    readonly statsContext?: StatsContext;
    readonly logger?: Logger;
    readonly engageDestinationCache?: EngageDestinationCache;
    readonly transactionContext?: TransactionContext;
    readonly stateContext?: StateContext;
    readonly subscriptionMetadata?: SubscriptionMetadata;
    readonly signal?: AbortSignal;
}
interface BatchEventInput<Settings> {
    readonly events: SegmentEvent[];
    readonly mapping: JSONObject;
    readonly settings: Settings;
    readonly auth?: AuthTokens;
    readonly features?: Features;
    readonly statsContext?: StatsContext;
    readonly logger?: Logger;
    readonly engageDestinationCache?: EngageDestinationCache;
    readonly transactionContext?: TransactionContext;
    readonly stateContext?: StateContext;
    readonly subscriptionMetadata?: SubscriptionMetadata;
    readonly signal?: AbortSignal;
}
export interface DecoratedResponse extends ModifiedResponse {
    request: Request;
    options: AllRequestOptions;
}
interface OnEventOptions {
    onTokenRefresh?: (tokens: RefreshAccessTokenResult) => Promise<void>;
    onComplete?: (stats: SubscriptionStats) => void;
    features?: Features;
    statsContext?: StatsContext;
    logger?: Logger;
    readonly engageDestinationCache?: EngageDestinationCache;
    transactionContext?: TransactionContext;
    stateContext?: StateContext;
    synchronizeRefreshAccessToken?: () => Promise<void>;
    signal?: AbortSignal;
}
export interface TransactionContext {
    transaction: Record<string, string>;
    setTransaction: (key: string, value: string) => void;
}
export interface StateContext {
    getRequestContext(key: string, cb?: (res?: string) => any): any;
    setResponseContext(key: string, value: string, ttl: {
        hour?: number;
        minute?: number;
        second?: number;
    }): void;
}
export interface StatsClient {
    observe: (metric: any) => any;
    _name(name: string): string;
    _tags(tags?: string[]): string[];
    incr(name: string, value?: number, tags?: string[]): void;
    set(name: string, value: number, tags?: string[]): void;
    histogram(name: string, value?: number, tags?: string[]): void;
}
export interface StatsContext {
    statsClient: StatsClient;
    tags: string[];
}
export interface Logger {
    level: string;
    name: string;
    debug(...message: string[]): void;
    info(...message: string[]): void;
    warn(...message: string[]): void;
    error(...message: string[]): void;
    crit(...message: string[]): void;
    log(...message: string[]): void;
    withTags(extraTags: any): void;
}
export interface EngageDestinationCache {
    getByKey: (key: string) => Promise<string | null>;
    readonly maxExpirySeconds: number;
    readonly maxValueSizeBytes: number;
    setByKey: (key: string, value: string, expiryInSeconds?: number) => Promise<boolean>;
    setByKeyNX: (key: string, value: string, expiryInSeconds?: number) => Promise<boolean>;
    delByKey: (key: string) => Promise<number>;
}
export declare class Destination<Settings = JSONObject, AudienceSettings = JSONObject> {
    readonly definition: DestinationDefinition<Settings>;
    readonly name: string;
    readonly authentication?: AuthenticationScheme<Settings>;
    readonly extendRequest?: RequestExtension<Settings, any>;
    readonly actions: PartnerActions<Settings, any, AudienceSettings>;
    readonly responses: DecoratedResponse[];
    readonly settingsSchema?: JSONSchema4;
    onDelete?: (event: SegmentEvent, settings: JSONObject, options?: OnEventOptions) => Promise<Result>;
    constructor(destination: DestinationDefinition<Settings>);
    validateSettings(settings: Settings): void;
    createAudience(createAudienceInput: CreateAudienceInput<Settings, AudienceSettings>): Promise<AudienceResult>;
    getAudience(getAudienceInput: GetAudienceInput<Settings, AudienceSettings>): Promise<AudienceResult>;
    testAuthentication(settings: Settings): Promise<void>;
    refreshAccessToken(settings: Settings, oauthData: OAuth2ClientCredentials, synchronizeRefreshAccessToken?: () => Promise<void>): Promise<RefreshAccessTokenResult | undefined>;
    private partnerAction;
    protected executeAction(actionSlug: string, { event, mapping, subscriptionMetadata, settings, auth, features, statsContext, logger, engageDestinationCache, transactionContext, stateContext, signal }: EventInput<Settings>): Promise<Result[]>;
    executeBatch(actionSlug: string, { events, mapping, subscriptionMetadata, settings, auth, features, statsContext, logger, engageDestinationCache, transactionContext, stateContext, signal }: BatchEventInput<Settings>): Promise<ResultMultiStatusNode[]>;
    executeDynamicField(actionSlug: string, fieldKey: string, data: ExecuteDynamicFieldInput<Settings, object>, dynamicFn?: RequestFn<Settings, any, DynamicFieldResponse, AudienceSettings>): Promise<never[] | DynamicFieldResponse>;
    private onSubscription;
    onEvent(event: SegmentEvent, settings: JSONObject, options?: OnEventOptions): Promise<Result[]>;
    onBatch(events: SegmentEvent[], settings: JSONObject, options?: OnEventOptions): Promise<Result[]>;
    private _onDelete;
    private onSubscriptions;
    private getSubscriptions;
    private getDestinationSettings;
    handleError(error: ResponseError | HTTPError, settings: JSONObject, options?: OnEventOptions): Promise<JSONObject>;
    handleAuthError(settings: JSONObject, options?: OnEventOptions): Promise<JSONObject>;
    refreshTokenAndGetNewToken(settings: JSONObject, options?: OnEventOptions): Promise<RefreshAccessTokenResult>;
}