import { EventEmitter } from 'events';
import createRequestClient from '../create-request-client';
import { JSONLikeObject, JSONObject } from '../json-object';
import { InputData, Features } from '../mapping-kit';
import type { DynamicFieldResponse, InputField, RequestExtension, ExecuteInput, Result, SyncModeDefinition, DynamicFieldContext, ActionDestinationSuccessResponseType, ActionDestinationErrorResponseType, ResultMultiStatusNode, AudienceMembership } from './types';
import type { JSONSchema4 } from 'json-schema';
import { AuthTokens } from './parse-settings';
import { Logger, StatsContext, Personas, TransactionContext, StateContext, EngageDestinationCache, SubscriptionMetadata } from './index';
type MaybePromise<T> = T | Promise<T>;
type RequestClient = ReturnType<typeof createRequestClient>;
export type RequestFn<Settings, Payload, Return = any, AudienceSettings = any, ActionHookInputs = any, AudienceMembershipType = AudienceMembership | AudienceMembership[]> = (request: RequestClient, data: ExecuteInput<Settings, Payload, AudienceSettings, ActionHookInputs, any, AudienceMembershipType>) => MaybePromise<Return>;
interface ReservedInputFields {
    batch_keys?: {
        label: string;
        description: string;
        type: 'string';
        unsafe_hidden?: true;
        multiple?: true;
        required?: false;
        default?: string[];
    };
}
type ActionFields = Omit<Record<string, InputField>, keyof ReservedInputFields> & ReservedInputFields;
export interface BaseActionDefinition {
    title: string;
    description: string;
    platform?: 'cloud' | 'web';
    defaultSubscription?: string;
    hidden?: boolean;
    fields: ActionFields;
}
type HookValueTypes = string | boolean | number | Array<string | boolean | number>;
type GenericActionHookValues = Record<string, HookValueTypes>;
type IsArray<T> = T extends (infer U)[] ? U : never;
type PerformBatchResponse = MaybePromise<MultiStatusResponse> | MaybePromise<unknown>;
export interface ActionDefinition<Settings, Payload = any, AudienceSettings = any, GeneratedActionHookInputs = any, GeneratedActionHookOutputs = any> extends BaseActionDefinition {
    dynamicFields?: {
        [K in keyof Payload]?: IsArray<Payload[K]> extends never ? Payload[K] extends object | undefined ? {
            [ObjectProperty in keyof NonNullable<Payload[K]> | '__keys__' | '__values__']?: RequestFn<Settings, Payload, DynamicFieldResponse, AudienceSettings>;
        } : RequestFn<Settings, Payload, DynamicFieldResponse, AudienceSettings> : IsArray<Payload[K]> extends object ? {
            [ObjectProperty in keyof NonNullable<IsArray<Payload[K]>> | '__keys__' | '__values__']?: RequestFn<Settings, Payload, DynamicFieldResponse, AudienceSettings>;
        } : never;
    };
    perform: RequestFn<Settings, Payload, any, AudienceSettings, any, AudienceMembership>;
    performBatch?: RequestFn<Settings, Payload[], PerformBatchResponse, AudienceSettings, any, AudienceMembership[]>;
    hooks?: {
        [K in ActionHookType]?: ActionHookDefinition<Settings, Payload, AudienceSettings, NonNullable<GeneratedActionHookInputs>, NonNullable<GeneratedActionHookOutputs>>;
    };
    syncMode?: SyncModeDefinition;
}
export declare const hookTypeStrings: readonly ["onMappingSave", "retlOnMappingSave"];
export type ActionHookType = typeof hookTypeStrings[number];
export interface ActionHookResponse<GeneratedActionHookOutputs> {
    successMessage?: string;
    savedData?: GeneratedActionHookOutputs;
    error?: {
        message: string;
        code: string;
    };
}
export interface ActionHookDefinition<Settings, Payload, AudienceSettings, GeneratedActionHookTypesInputs, GeneratedActionHookOutputs> {
    label: string;
    description: string;
    inputFields?: Record<string, Omit<InputField, 'dynamic'> & {
        dynamic?: RequestFn<Settings, Payload, DynamicFieldResponse, AudienceSettings, GeneratedActionHookTypesInputs>;
    }>;
    outputTypes?: Record<string, {
        label: string;
        description: string;
        type: string;
        required: boolean;
    }>;
    performHook: RequestFn<Settings, Payload, ActionHookResponse<GeneratedActionHookOutputs>, AudienceSettings, GeneratedActionHookTypesInputs>;
}
export interface ExecuteDynamicFieldInput<Settings, Payload, AudienceSettings = any> {
    settings: Settings;
    audienceSettings?: AudienceSettings;
    payload: Payload;
    page?: string;
    auth?: AuthTokens;
    features?: Features | undefined;
    statsContext?: StatsContext | undefined;
    hookInputs?: GenericActionHookValues;
    dynamicFieldContext?: DynamicFieldContext;
}
interface ExecuteBundle<T = unknown, Data = unknown, AudienceSettings = any, ActionHookValues = any> {
    data: Data;
    settings: T;
    audienceSettings?: AudienceSettings;
    mapping: JSONObject;
    auth: AuthTokens | undefined;
    hookOutputs?: Record<ActionHookType, ActionHookValues>;
    features?: Features | undefined;
    statsContext?: StatsContext | undefined;
    personasContext?: Personas | undefined;
    logger?: Logger | undefined;
    engageDestinationCache?: EngageDestinationCache;
    transactionContext?: TransactionContext;
    stateContext?: StateContext;
    subscriptionMetadata?: SubscriptionMetadata;
    signal?: AbortSignal;
}
export declare class Action<Settings, Payload extends JSONLikeObject, AudienceSettings = any> extends EventEmitter {
    readonly definition: ActionDefinition<Settings, Payload, AudienceSettings>;
    readonly destinationName: string;
    readonly schema?: JSONSchema4;
    readonly hookSchemas?: Record<string, JSONSchema4>;
    readonly hasBatchSupport: boolean;
    readonly hasHookSupport: boolean;
    private extendRequest;
    constructor(destinationName: string, definition: ActionDefinition<Settings, Payload, AudienceSettings>, extendRequest?: RequestExtension<Settings, any>);
    execute(bundle: ExecuteBundle<Settings, InputData | undefined, AudienceSettings>): Promise<Result[]>;
    executeBatch(bundle: ExecuteBundle<Settings, InputData[], AudienceSettings>): Promise<ResultMultiStatusNode[]>;
    private extractFieldContextAndHandler;
    executeDynamicField(field: string, data: ExecuteDynamicFieldInput<Settings, Payload, AudienceSettings>, dynamicFn?: RequestFn<Settings, Payload, DynamicFieldResponse, AudienceSettings>): Promise<DynamicFieldResponse>;
    executeHook(hookType: ActionHookType, data: ExecuteInput<Settings, Payload, AudienceSettings>): Promise<ActionHookResponse<any>>;
    private performRequest;
    private createRequestClient;
    private afterResponse;
    private parseResponse;
    private fillMultiStatusResponse;
}
export declare class ActionDestinationSuccessResponse {
    private data;
    constructor(data: ActionDestinationSuccessResponseType);
    value(): ActionDestinationSuccessResponseType;
}
export declare class ActionDestinationErrorResponse {
    private data;
    constructor(data: ActionDestinationErrorResponseType);
    value(): ActionDestinationErrorResponseType;
}
export declare class MultiStatusResponse {
    private responses;
    length(): number;
    pushResponseObject(response: ActionDestinationSuccessResponse | ActionDestinationErrorResponse): void;
    pushSuccessResponse(response: ActionDestinationSuccessResponse | ActionDestinationSuccessResponseType): void;
    pushErrorResponse(response: ActionDestinationErrorResponse | ActionDestinationErrorResponseType): void;
    pushResponseObjectAtIndex(index: number, response: ActionDestinationSuccessResponse | ActionDestinationErrorResponse): void;
    setSuccessResponseAtIndex(index: number, response: ActionDestinationSuccessResponse | ActionDestinationSuccessResponseType): void;
    setErrorResponseAtIndex(index: number, response: ActionDestinationErrorResponse | ActionDestinationErrorResponseType): void;
    unsetResponseAtIndex(index: number): void;
    isSuccessResponseAtIndex(index: number): boolean;
    isErrorResponseAtIndex(index: number): boolean;
    getResponseAtIndex(index: number): ActionDestinationSuccessResponse | ActionDestinationErrorResponse;
    getAllResponses(): (ActionDestinationSuccessResponse | ActionDestinationErrorResponse)[];
}
export {};