import { RequestClient } from '@segment/actions-core/create-request-client';
import { EngageDestinationCache, ExecuteInput } from '@segment/actions-core/destination-kit';
import { MaybePromise } from '@segment/actions-core/destination-kit/types';
import { EngageLogger } from './EngageLogger';
import { EngageStats } from './EngageStats';
import { OperationContext } from './track';
import { RequestOptions } from '@segment/actions-core/request-client';
import { IntegrationError } from '@segment/actions-core';
import { Awaited, StatsTags } from './operationTracking';
import { ValueOrError } from './getOrCatch';
import { GetOrRetryArgs } from './getOrRetry';
export declare abstract class EngageActionPerformer<TSettings = any, TPayload = any, TReturn = any> {
    readonly requestClient: RequestClient;
    readonly executeInput: ExecuteInput<TSettings, TPayload>;
    readonly logger: EngageLogger;
    readonly statsClient: EngageStats;
    readonly engageDestinationCache?: EngageDestinationCache;
    readonly currentOperation: OperationContext | undefined;
    readonly payload: TPayload;
    readonly settings: TSettings;
    constructor(requestClient: RequestClient, executeInput: ExecuteInput<TSettings, TPayload>);
    beforePerform?(): void | Promise<void>;
    perform(): Promise<TReturn>;
    abstract doPerform(): MaybePromise<TReturn>;
    abstract getIntegrationStatsName(): string;
    abstract getChannelType(): string;
    request<Data = unknown>(url: string, options?: RequestOptions): Promise<import("@segment/actions-core/create-request-client").ModifiedResponse<Data>>;
    onResponse?(args: {
        response?: Awaited<ReturnType<RequestClient>>;
        error?: any;
        operation: OperationContext;
    }): void;
    redactPii(pii: string | undefined): string | undefined;
    isFeatureActive(featureName: string, getDefault?: () => boolean): boolean | undefined;
    logInfo(msg: string, metadata?: object): void;
    logError(msg: string, metadata?: object): void;
    logWarn(msg: string, metadata?: object): void;
    logOnError(logMessage: string | ((ctx: OperationContext) => string)): void;
    statsIncr(metric: string, value?: number, tags?: StatsTags): void;
    statsHistogram(metric: string, value: number, tags?: StatsTags): void;
    statsSet(metric: string, value: number, tags?: StatsTags): void;
    get logDetails(): Record<string, unknown>;
    get tags(): string[];
    rethrowIntegrationError(error: unknown, getWrapper: () => IntegrationError | ConstructorParameters<typeof IntegrationError>): never;
    throwRetryableError(message: string, code?: string): never;
    createStepLogger(args: LogStepDetails): StepLogger;
    getOrAddCache<T>(key: string, createValue: () => Promise<T>, options: {
        cacheGroup?: string;
        serializer?: CacheSerializer<T>;
        expiryInSeconds?: number;
        lockOptions?: LockOptions;
        saveRetry?: GetOrRetryArgs;
        onSaveFailed?: (error: Error) => void;
    }): Promise<T>;
    withDistributedLock<T>(key: string, createValue: () => Promise<T>, options: LockOptions): Promise<T>;
    isLockExpirationExtended(): boolean | undefined;
    isRequestTimeoutExtended(): boolean | undefined;
}
export type CacheSerializer<T> = {
    stringify: (cacheable: ValueOrError<T>) => string | void;
    parse: (cachedValue: string) => ValueOrError<T> | void;
};
export declare const DefaultSerializer: CacheSerializer<any>;
export type LockOptions = {
    acquireLockMaxWaitTimeMs: number;
    acquireLockRetryIntervalMs?: number;
    lockMaxTimeMs: number;
    cacheGroup?: string;
};
export declare function isNone(cacheValue: any): cacheValue is null | undefined | void;
type StepLogger = LogStepDetails & {
    track<T>(stepName: string, fn: (details: LogStepDetails) => T): T;
    write(stepName: string, details?: Partial<LogStepDetails>): void;
};
type LogStepDetails = {
    tags: Record<string, any>;
    logs: Record<string, any>;
    level?: 'info' | 'warn' | 'error';
};
export {};