import type { ValidationOptions, ValidationResult } from '../validation/index';
import type { PluginRegistry } from '../workflow-builder/plugins/registry';
export interface IDataObject {
    [key: string]: string | number | boolean | null | undefined | object | IDataObject | Array<string | number | boolean | null | object | IDataObject>;
}
export interface BinaryData {
    [key: string]: {
        fileName?: string;
        mimeType?: string;
        fileExtension?: string;
        fileSize?: string;
        data?: string;
    };
}
export interface Item<T = IDataObject> {
    json: T;
    binary?: BinaryData;
}
export type Items<T = IDataObject> = Array<Item<T>>;
export interface CredentialReference {
    name: string;
    id: string;
}
export interface NewCredentialValue {
    readonly __newCredential: true;
    readonly name: string;
    readonly id?: string;
}
export type OnError = 'stopWorkflow' | 'continueRegularOutput' | 'continueErrorOutput';
export interface WorkflowSettings {
    timezone?: string;
    errorWorkflow?: string;
    saveDataErrorExecution?: 'all' | 'none';
    saveDataSuccessExecution?: 'all' | 'none';
    saveManualExecutions?: boolean;
    saveExecutionProgress?: boolean;
    executionTimeout?: number;
    executionOrder?: 'v0' | 'v1';
    callerPolicy?: 'any' | 'none' | 'workflowsFromAList' | 'workflowsFromSameOwner';
    callerIds?: string;
    [key: string]: unknown;
}
export type GenericValue = string | object | number | boolean | undefined | null;
export interface IConnection {
    node: string;
    type: string;
    index: number;
}
export type NodeInputConnections = Array<IConnection[] | null>;
export interface INodeConnections {
    [key: string]: NodeInputConnections;
}
export interface IConnections {
    [key: string]: INodeConnections;
}
interface ErrorIndexNodeInfo {
    name?: string;
    type: string;
    parameters?: IDataObject;
}
export declare function resolveErrorOutputIndex(type: string, parameters?: IDataObject): number;
export declare function foldLegacyErrorConnections(connections: IConnections, nodes?: readonly ErrorIndexNodeInfo[]): void;
export declare function normalizeConnections(connections: IConnections): void;
export declare function generateUniqueName(baseName: string, exists: (name: string) => boolean): string;
export interface NodeJSON {
    id: string;
    name?: string;
    type: string;
    typeVersion: number;
    position: [number, number];
    parameters?: IDataObject;
    credentials?: Record<string, {
        id?: string;
        name: string;
    }>;
    webhookId?: string;
    disabled?: boolean;
    notes?: string;
    notesInFlow?: boolean;
    executeOnce?: boolean;
    retryOnFail?: boolean;
    maxTries?: number;
    waitBetweenTries?: number;
    alwaysOutputData?: boolean;
    onError?: OnError;
    extendsCredential?: string;
}
export interface WorkflowJSON {
    id?: string;
    name: string;
    nodes: NodeJSON[];
    connections: IConnections;
    settings?: WorkflowSettings;
    pinData?: Record<string, IDataObject[]>;
    meta?: {
        templateId?: string;
        instanceId?: string;
    };
}
export interface ConnectionTarget {
    node: string;
    type: string;
    index: number;
}
export interface GraphNode {
    instance: NodeInstance<string, string, unknown>;
    connections: Map<string, Map<number, ConnectionTarget[]>>;
}
export interface DeclaredConnection {
    target: NodeInstance<string, string, unknown> | InputTarget;
    outputIndex: number;
    targetInputIndex?: number;
    connectionType?: string;
}
export interface InputTarget {
    readonly _isInputTarget: true;
    readonly node: NodeInstance<string, string, unknown>;
    readonly inputIndex: number;
}
export interface OutputSelector<TType extends string, TVersion extends string, TOutput = unknown> {
    readonly _isOutputSelector: true;
    readonly node: NodeInstance<TType, TVersion, TOutput>;
    readonly outputIndex: number;
    to<T extends NodeInstance<string, string, unknown>>(target: T | T[] | InputTarget): NodeChain<NodeInstance<TType, TVersion, TOutput>, T>;
}
export interface ExecutionContext {
    id: string;
    mode: 'test' | 'production';
    resumeUrl?: string;
}
export interface WorkflowContext {
    id?: string;
    name?: string;
    active: boolean;
}
export interface NodeConfig<TParams = IDataObject> {
    parameters?: TParams;
    credentials?: Record<string, string | CredentialReference | NewCredentialValue | {
        value: string;
    }>;
    name?: string;
    position?: [number, number];
    webhookId?: string;
    disabled?: boolean;
    notes?: string;
    notesInFlow?: boolean;
    executeOnce?: boolean;
    retryOnFail?: boolean;
    maxTries?: number;
    waitBetweenTries?: number;
    alwaysOutputData?: boolean;
    onError?: OnError;
    extendsCredential?: string;
    pinData?: IDataObject[];
    output?: IDataObject[];
    subnodes?: SubnodeConfig;
}
export interface StickyNoteConfig {
    color?: number;
    position?: [number, number];
    width?: number;
    height?: number;
    name?: string;
}
export interface SubnodeConfig {
    model?: LanguageModelInstance | LanguageModelInstance[] | LanguageModelInstance[][];
    memory?: MemoryInstance;
    tools?: ToolInstance[];
    outputParser?: OutputParserInstance;
    embedding?: EmbeddingInstance | EmbeddingInstance[];
    embeddings?: EmbeddingInstance | EmbeddingInstance[];
    vectorStore?: VectorStoreInstance;
    retriever?: RetrieverInstance;
    documentLoader?: DocumentLoaderInstance | DocumentLoaderInstance[];
    textSplitter?: TextSplitterInstance;
    reranker?: RerankerInstance | RerankerInstance[];
}
export interface NodeInstance<TType extends string, TVersion extends string, TOutput = unknown> {
    readonly type: TType;
    readonly version: TVersion;
    readonly config: NodeConfig;
    readonly id: string;
    readonly name: string;
    readonly _outputType?: TOutput;
    update(config: Partial<NodeConfig>): NodeInstance<TType, TVersion, TOutput>;
    to<T extends NodeInstance<string, string, unknown>>(target: T | T[] | InputTarget, outputIndex?: number): NodeChain<NodeInstance<TType, TVersion, TOutput>, T>;
    to<T>(target: IfElseBuilder<T>, outputIndex?: number): NodeChain<NodeInstance<TType, TVersion, TOutput>, NodeInstance<'n8n-nodes-base.if', string, T>>;
    to<T>(target: SwitchCaseBuilder<T>, outputIndex?: number): NodeChain<NodeInstance<TType, TVersion, TOutput>, NodeInstance<'n8n-nodes-base.switch', string, T>>;
    to<T>(target: SplitInBatchesBuilder<T>, outputIndex?: number): NodeChain<NodeInstance<TType, TVersion, TOutput>, NodeInstance<TType, TVersion, TOutput>>;
    input(index: number): InputTarget;
    output(index: number): OutputSelector<TType, TVersion, TOutput>;
    onTrue?(target: IfElseTarget): IfElseBuilder<TOutput>;
    onFalse?(target: IfElseTarget): IfElseBuilder<TOutput>;
    onCase?(index: number, target: SwitchCaseTarget): SwitchCaseBuilder<TOutput>;
    onError<T extends NodeInstance<string, string, unknown>>(handler: T): this;
    getConnections(): DeclaredConnection[];
}
export interface TriggerInstance<TType extends string, TVersion extends string, TOutput = unknown> extends NodeInstance<TType, TVersion, TOutput> {
    readonly isTrigger: true;
}
export interface NodeChain<THead extends NodeInstance<string, string, unknown> = NodeInstance<string, string, unknown>, TTail extends NodeInstance<string, string, unknown> = NodeInstance<string, string, unknown>> extends NodeInstance<TTail['type'], TTail['version'], TTail['_outputType']> {
    readonly _isChain: true;
    readonly head: THead;
    readonly tail: TTail;
    readonly allNodes: Array<NodeInstance<string, string, unknown>>;
    to<T extends NodeInstance<string, string, unknown>>(target: T | T[] | InputTarget, outputIndex?: number): NodeChain<THead, T>;
    to<T>(target: IfElseBuilder<T>, outputIndex?: number): NodeChain<THead, NodeInstance<'n8n-nodes-base.if', string, T>>;
    to<T>(target: SwitchCaseBuilder<T>, outputIndex?: number): NodeChain<THead, NodeInstance<'n8n-nodes-base.switch', string, T>>;
    to<T>(target: SplitInBatchesBuilder<T>, outputIndex?: number): NodeChain<THead, TTail>;
}
export declare function isNodeChain(value: unknown): value is NodeChain<NodeInstance<string, string, unknown>, NodeInstance<string, string, unknown>>;
export declare function isNodeInstance(value: unknown): value is NodeInstance<string, string, unknown>;
export interface SubnodeInstance<TType extends string, TVersion extends string, TOutput, TSubnodeType extends string> extends NodeInstance<TType, TVersion, TOutput> {
    readonly _subnodeType: TSubnodeType;
}
export type LanguageModelInstance<TType extends string = string, TVersion extends string = string, TOutput = unknown> = SubnodeInstance<TType, TVersion, TOutput, 'ai_languageModel'>;
export type MemoryInstance<TType extends string = string, TVersion extends string = string, TOutput = unknown> = SubnodeInstance<TType, TVersion, TOutput, 'ai_memory'>;
export type ToolInstance<TType extends string = string, TVersion extends string = string, TOutput = unknown> = SubnodeInstance<TType, TVersion, TOutput, 'ai_tool'>;
export type OutputParserInstance<TType extends string = string, TVersion extends string = string, TOutput = unknown> = SubnodeInstance<TType, TVersion, TOutput, 'ai_outputParser'>;
export type EmbeddingInstance<TType extends string = string, TVersion extends string = string, TOutput = unknown> = SubnodeInstance<TType, TVersion, TOutput, 'ai_embedding'>;
export type VectorStoreInstance<TType extends string = string, TVersion extends string = string, TOutput = unknown> = SubnodeInstance<TType, TVersion, TOutput, 'ai_vectorStore'>;
export type RetrieverInstance<TType extends string = string, TVersion extends string = string, TOutput = unknown> = SubnodeInstance<TType, TVersion, TOutput, 'ai_retriever'>;
export type DocumentLoaderInstance<TType extends string = string, TVersion extends string = string, TOutput = unknown> = SubnodeInstance<TType, TVersion, TOutput, 'ai_document'>;
export type TextSplitterInstance<TType extends string = string, TVersion extends string = string, TOutput = unknown> = SubnodeInstance<TType, TVersion, TOutput, 'ai_textSplitter'>;
export type RerankerInstance<TType extends string = string, TVersion extends string = string, TOutput = unknown> = SubnodeInstance<TType, TVersion, TOutput, 'ai_reranker'>;
export interface IfElseConfig {
    version: number;
    config?: NodeConfig;
}
export interface IfElseComposite {
    readonly ifNode: NodeInstance<'n8n-nodes-base.if', string, unknown>;
    readonly trueBranch: NodeInstance<string, string, unknown> | Array<NodeInstance<string, string, unknown>>;
    readonly falseBranch: NodeInstance<string, string, unknown> | Array<NodeInstance<string, string, unknown>>;
}
export interface SwitchCaseConfig {
    version: number;
    config?: NodeConfig;
}
export interface SwitchCaseComposite {
    readonly switchNode: NodeInstance<'n8n-nodes-base.switch', string, unknown>;
    readonly cases: Array<NodeInstance<string, string, unknown> | Array<NodeInstance<string, string, unknown>> | null>;
}
export type IfElseTarget = null | NodeInstance<string, string, unknown> | NodeChain<NodeInstance<string, string, unknown>, NodeInstance<string, string, unknown>> | Array<NodeInstance<string, string, unknown> | NodeChain<NodeInstance<string, string, unknown>, NodeInstance<string, string, unknown>>> | IfElseBuilder<unknown> | SwitchCaseBuilder<unknown> | SplitInBatchesBuilder<unknown> | InputTarget;
export type SwitchCaseTarget = null | NodeInstance<string, string, unknown> | NodeChain<NodeInstance<string, string, unknown>, NodeInstance<string, string, unknown>> | Array<NodeInstance<string, string, unknown> | NodeChain<NodeInstance<string, string, unknown>, NodeInstance<string, string, unknown>>> | IfElseBuilder<unknown> | SwitchCaseBuilder<unknown> | SplitInBatchesBuilder<unknown> | InputTarget;
export type SplitInBatchesTarget = null | NodeInstance<string, string, unknown> | NodeChain<NodeInstance<string, string, unknown>, NodeInstance<string, string, unknown>> | Array<NodeInstance<string, string, unknown> | NodeChain<NodeInstance<string, string, unknown>, NodeInstance<string, string, unknown>>> | IfElseBuilder<unknown> | SwitchCaseBuilder<unknown> | SplitInBatchesBuilder<unknown>;
export interface IfElseBuilder<TOutput = unknown> {
    readonly _isIfElseBuilder: true;
    readonly ifNode: NodeInstance<'n8n-nodes-base.if', string, TOutput>;
    readonly trueBranch: IfElseTarget;
    readonly falseBranch: IfElseTarget;
    readonly errorBranch?: IfElseTarget;
    onTrue(target: IfElseTarget): IfElseBuilder<TOutput>;
    onFalse(target: IfElseTarget): IfElseBuilder<TOutput>;
    onError(target: IfElseTarget): IfElseBuilder<TOutput>;
    to<T extends NodeInstance<string, string, unknown>>(target: T | T[], outputIndex?: number): NodeChain<NodeInstance<'n8n-nodes-base.if', string, TOutput>, T>;
}
export interface SwitchCaseBuilder<TOutput = unknown> {
    readonly _isSwitchCaseBuilder: true;
    readonly switchNode: NodeInstance<'n8n-nodes-base.switch', string, TOutput>;
    readonly caseMapping: Map<number, SwitchCaseTarget>;
    onCase(index: number, target: SwitchCaseTarget): SwitchCaseBuilder<TOutput>;
    to<T extends NodeInstance<string, string, unknown>>(target: T | T[], outputIndex?: number): NodeChain<NodeInstance<'n8n-nodes-base.switch', string, TOutput>, T>;
}
export interface SplitInBatchesFactoryConfig {
    version: number | string;
    config?: NodeConfig;
}
export interface SplitInBatchesConfig extends NodeConfig {
    version?: number | string;
    id?: string;
}
export interface SplitInBatchesBuilder<TOutput = unknown> {
    readonly sibNode: NodeInstance<'n8n-nodes-base.splitInBatches', string, unknown>;
    onEachBatch(target: SplitInBatchesTarget): SplitInBatchesBuilder<TOutput>;
    onDone(target: SplitInBatchesTarget): SplitInBatchesBuilder<TOutput>;
}
export interface GeneratePinDataOptions {
    beforeWorkflow?: WorkflowJSON;
}
export interface ToJSONOptions {
    tidyUp?: boolean;
}
export interface WorkflowBuilder {
    readonly id: string;
    readonly name: string;
    add<N extends NodeInstance<string, string, unknown> | TriggerInstance<string, string, unknown> | NodeChain | IfElseBuilder<unknown> | SwitchCaseBuilder<unknown>>(node: N): WorkflowBuilder;
    to<N extends NodeInstance<string, string, unknown>>(node: N): WorkflowBuilder;
    to(inputTarget: InputTarget): WorkflowBuilder;
    to(ifElse: IfElseComposite): WorkflowBuilder;
    to(switchCase: SwitchCaseComposite): WorkflowBuilder;
    to<T>(splitInBatches: SplitInBatchesBuilder<T>): WorkflowBuilder;
    to<T>(ifElseBuilder: IfElseBuilder<T>): WorkflowBuilder;
    to<T>(switchCaseBuilder: SwitchCaseBuilder<T>): WorkflowBuilder;
    to(nodes: Array<NodeInstance<string, string, unknown> | NodeChain | null>): WorkflowBuilder;
    onTrue(target: IfElseTarget): WorkflowBuilder;
    onFalse(target: IfElseTarget): WorkflowBuilder;
    onCase(index: number, target: SwitchCaseTarget): WorkflowBuilder;
    settings(settings: WorkflowSettings): WorkflowBuilder;
    connect(source: NodeInstance<string, string, unknown>, sourceOutput: number, target: NodeInstance<string, string, unknown>, targetInput: number): WorkflowBuilder;
    getNode(name: string): NodeInstance<string, string, unknown> | undefined;
    validate(options?: ValidationOptions): ValidationResult;
    toJSON(options?: ToJSONOptions): WorkflowJSON;
    toFormat<T>(format: string): T;
    toString(): string;
    generatePinData(options?: GeneratePinDataOptions): WorkflowBuilder;
    regenerateNodeIds(): void;
}
export interface WorkflowBuilderOptions {
    settings?: WorkflowSettings;
    registry?: PluginRegistry;
}
export interface WorkflowBuilderStatic {
    (id: string, name: string, options?: WorkflowSettings | WorkflowBuilderOptions): WorkflowBuilder;
    fromJSON(json: WorkflowJSON): WorkflowBuilder;
}
export interface NodeInput<TType extends string = string, TVersion extends number = number, TParams = unknown> {
    type: TType;
    version: TVersion;
    config: NodeConfig<TParams>;
    output?: IDataObject[];
}
export interface TriggerInput<TType extends string = string, TVersion extends number = number, TParams = unknown> {
    type: TType;
    version: TVersion;
    config: NodeConfig<TParams>;
    output?: IDataObject[];
}
export type WorkflowFn = WorkflowBuilderStatic;
export type NodeFn = <TNode extends NodeInput>(input: TNode) => NodeInstance<TNode['type'], `${TNode['version']}`, unknown>;
export type TriggerFn = <TTrigger extends TriggerInput>(input: TTrigger) => TriggerInstance<TTrigger['type'], `${TTrigger['version']}`, unknown>;
export type StickyFn = (content: string, nodes?: Array<NodeInstance<string, string, unknown>>, config?: StickyNoteConfig) => NodeInstance<'n8n-nodes-base.stickyNote', 'v1', void>;
export type PlaceholderFn = (hint: string) => string;
export type NewCredentialFn = (name: string, id?: string) => NewCredentialValue;
export type IfElseFn = (branches: [
    NodeInstance<string, string, unknown> | null,
    NodeInstance<string, string, unknown> | null
], config?: IfElseConfig) => IfElseComposite;
export type SwitchCaseFn = (config?: SwitchCaseConfig) => NodeInstance<'n8n-nodes-base.switch', string, unknown>;
export type SplitInBatchesFn = (configOrNode: SplitInBatchesFactoryConfig | NodeInstance<'n8n-nodes-base.splitInBatches', string, unknown>) => SplitInBatchesBuilder<unknown>;
export interface AllItemsContext {
    $input: {
        all(): IDataObject[];
        first(): IDataObject;
        last(): IDataObject;
        itemMatching(index: number): IDataObject;
    };
    $env: IDataObject;
    $vars: IDataObject;
    $secrets: IDataObject;
    $now: Date;
    $today: Date;
    $runIndex: number;
    $execution: ExecutionContext;
    $workflow: WorkflowContext;
    (nodeName: string): {
        json: IDataObject;
    };
    $jmespath: (data: unknown, expr: string) => unknown;
}
export interface EachItemContext {
    $input: {
        item: IDataObject;
    };
    $itemIndex: number;
    $env: IDataObject;
    $vars: IDataObject;
    $secrets: IDataObject;
    $now: Date;
    $today: Date;
    $runIndex: number;
    $execution: ExecutionContext;
    $workflow: WorkflowContext;
    (nodeName: string): {
        json: IDataObject;
    };
    $jmespath: (data: unknown, expr: string) => unknown;
}
export interface CodeResult<T> {
    mode: 'runOnceForAllItems' | 'runOnceForEachItem';
    jsCode: string;
    _outputType?: T;
}
export type RunOnceForAllItemsFn = <T = unknown>(fn: (ctx: AllItemsContext) => Array<{
    json: T;
}>) => CodeResult<T>;
export type RunOnceForEachItemFn = <T = unknown>(fn: (ctx: EachItemContext) => {
    json: T;
} | null) => CodeResult<T>;
export type FromAIArgumentType = 'string' | 'number' | 'boolean' | 'json';
export {};