import { z } from 'zod';
import { PlatformId } from '../../management/platform';
import { ProjectId } from '../../management/project/project';
import { ExecutionToolStatus, PredefinedInputsStructure } from '../agents';
import { AppConnectionValue } from '../app-connection/app-connection';
import { ExecutionState, ExecutionType, ResumePayload } from '../flow-run/execution/execution-output';
import { FlowRunId, RunEnvironment } from '../flow-run/flow-run';
import { FlowVersion } from '../flows/flow-version';
import { PiecePackage } from '../pieces';
import { ScheduleOptions } from '../trigger';
export declare enum EngineOperationType {
    EXTRACT_PIECE_METADATA = "EXTRACT_PIECE_METADATA",
    EXECUTE_FLOW = "EXECUTE_FLOW",
    EXECUTE_PROPERTY = "EXECUTE_PROPERTY",
    EXECUTE_TRIGGER_HOOK = "EXECUTE_TRIGGER_HOOK",
    EXECUTE_VALIDATE_AUTH = "EXECUTE_VALIDATE_AUTH"
}
export declare enum TriggerHookType {
    ON_ENABLE = "ON_ENABLE",
    ON_DISABLE = "ON_DISABLE",
    HANDSHAKE = "HANDSHAKE",
    RENEW = "RENEW",
    RUN = "RUN",
    TEST = "TEST"
}
export type EngineOperation = ExecuteToolOperation | ExecuteFlowOperation | ExecutePropsOptions | ExecuteTriggerOperation<TriggerHookType> | ExecuteExtractPieceMetadataOperation | ExecuteValidateAuthOperation;
export declare const EngineStdout: z.ZodObject<{
    message: z.ZodString;
}, z.core.$strip>;
export declare const EngineStderr: z.ZodObject<{
    message: z.ZodString;
}, z.core.$strip>;
export type EngineStdout = z.infer<typeof EngineStdout>;
export type EngineStderr = z.infer<typeof EngineStderr>;
export type BaseEngineOperation = {
    projectId: ProjectId;
    engineToken: string;
    internalApiUrl: string;
    publicApiUrl: string;
    timeoutInSeconds: number;
    platformId: PlatformId;
};
export type ExecuteValidateAuthOperation = Omit<BaseEngineOperation, 'projectId'> & {
    piece: PiecePackage;
    auth: AppConnectionValue;
};
export type ExecuteExtractPieceMetadata = PiecePackage & {
    platformId: PlatformId;
};
export type ExecuteExtractPieceMetadataOperation = ExecuteExtractPieceMetadata & {
    timeoutInSeconds: number;
    platformId: PlatformId;
};
export type ExecuteToolOperation = BaseEngineOperation & {
    actionName: string;
    pieceName: string;
    pieceVersion: string;
    predefinedInput?: PredefinedInputsStructure;
    instruction: string;
};
export type ExecutePropsOptions = BaseEngineOperation & {
    piece: PiecePackage;
    propertyName: string;
    actionOrTriggerName: string;
    flowVersion?: FlowVersion;
    input: Record<string, unknown>;
    sampleData: Record<string, unknown>;
    searchValue?: string;
};
type BaseExecuteFlowOperation<T extends ExecutionType> = BaseEngineOperation & {
    flowVersion: FlowVersion;
    flowRunId: FlowRunId;
    executionType: T;
    runEnvironment: RunEnvironment;
    executionState: ExecutionState;
    workerHandlerId: string | null;
    httpRequestId: string | null;
    streamStepProgress: StreamStepProgress;
    stepNameToTest: string | null;
    sampleData?: Record<string, unknown>;
    logsUploadUrl?: string;
    logsFileId?: string;
};
export declare enum StreamStepProgress {
    WEBSOCKET = "WEBSOCKET",
    NONE = "NONE"
}
export type BeginExecuteFlowOperation = BaseExecuteFlowOperation<ExecutionType.BEGIN> & {
    triggerPayload: unknown;
    executeTrigger: boolean;
};
export type ResumeExecuteFlowOperation = BaseExecuteFlowOperation<ExecutionType.RESUME> & {
    resumePayload: ResumePayload;
};
export type ExecuteFlowOperation = BeginExecuteFlowOperation | ResumeExecuteFlowOperation;
export type ExecuteTriggerOperation<HT extends TriggerHookType> = BaseEngineOperation & {
    hookType: HT;
    test: boolean;
    flowVersion: FlowVersion;
    webhookUrl: string;
    triggerPayload?: TriggerPayload;
    appWebhookUrl?: string;
    webhookSecret?: string | Record<string, string>;
};
export declare const TriggerPayload: z.ZodObject<{
    body: z.ZodUnknown;
    rawBody: z.ZodOptional<z.ZodUnknown>;
    headers: z.ZodRecord<z.ZodString, z.ZodString>;
    queryParams: z.ZodRecord<z.ZodString, z.ZodString>;
}, z.core.$strip>;
export type TriggerPayload<T = unknown> = {
    body: T;
    rawBody?: unknown;
    headers: Record<string, string>;
    queryParams: Record<string, string>;
};
export type EventPayload<B = unknown> = {
    body: B;
    rawBody?: unknown;
    method: string;
    headers: Record<string, string>;
    queryParams: Record<string, string>;
};
export type ParseEventResponse = {
    event?: string;
    identifierValue?: string;
    reply?: {
        headers: Record<string, string>;
        body: unknown;
    };
};
export type AppEventListener = {
    events: string[];
    identifierValue: string;
};
type ExecuteTestOrRunTriggerResponse = {
    message?: string;
    output: unknown[];
};
type ExecuteHandshakeTriggerResponse = {
    message?: string;
    response?: {
        status: number;
        body?: unknown;
        headers?: Record<string, string>;
    };
};
type ExecuteOnEnableTriggerResponse = {
    listeners: AppEventListener[];
    scheduleOptions?: ScheduleOptions;
};
export declare const EngineHttpResponse: z.ZodObject<{
    status: z.ZodNumber;
    body: z.ZodUnknown;
    headers: z.ZodRecord<z.ZodString, z.ZodString>;
}, z.core.$strip>;
export type EngineHttpResponse = z.infer<typeof EngineHttpResponse>;
export type ExecuteTriggerResponse<H extends TriggerHookType> = H extends TriggerHookType.RUN ? ExecuteTestOrRunTriggerResponse : H extends TriggerHookType.HANDSHAKE ? ExecuteHandshakeTriggerResponse : H extends TriggerHookType.TEST ? ExecuteTestOrRunTriggerResponse : H extends TriggerHookType.RENEW ? Record<string, never> : H extends TriggerHookType.ON_DISABLE ? Record<string, never> : ExecuteOnEnableTriggerResponse;
export type ExecuteToolResponse = {
    status: ExecutionToolStatus;
    output?: unknown;
    resolvedInput: Record<string, unknown>;
    errorMessage?: unknown;
};
export declare function normalizeToolOutputToExecuteResponse(raw: unknown): ExecuteToolResponse;
export type ExecuteActionResponse = {
    success: boolean;
    input: unknown;
    output: unknown;
    message?: string;
};
type BaseExecuteValidateAuthResponseOutput<Valid extends boolean> = {
    valid: Valid;
};
type ValidExecuteValidateAuthResponseOutput = BaseExecuteValidateAuthResponseOutput<true>;
type InvalidExecuteValidateAuthResponseOutput = BaseExecuteValidateAuthResponseOutput<false> & {
    error: string;
};
export type ExecuteValidateAuthResponse = ValidExecuteValidateAuthResponseOutput | InvalidExecuteValidateAuthResponseOutput;
export type EngineResponse<T = unknown> = {
    status: EngineResponseStatus;
    response: T;
    error?: string;
};
export declare enum EngineResponseStatus {
    OK = "OK",
    USER_FAILURE = "USER_FAILURE",
    INTERNAL_ERROR = "INTERNAL_ERROR",
    TIMEOUT = "TIMEOUT",
    MEMORY_ISSUE = "MEMORY_ISSUE",
    LOG_SIZE_EXCEEDED = "LOG_SIZE_EXCEEDED"
}
export {};
//# sourceMappingURL=engine-operation.d.ts.map