@openapi-flow/n8n 0.0.0-stage → 0.2.0

package/dist/types/request-deployment.d.ts

@@ -0,0 +1,17 @@
+import type { CredentialBindings } from './legacy/request-workflow.js';
+import type { HttpRequestAuthenticationMapping } from './authentication.js';
+export interface HttpRequestDeploymentOptions {
+    baseUrl?: string;
+    credentialBindings?: CredentialBindings;
+    securityRequirementIndex?: number;
+}
+export interface ResolveHttpRequestDeploymentInput extends HttpRequestDeploymentOptions {
+    documentId: string;
+    authentication?: HttpRequestAuthenticationMapping;
+}
+export interface ResolvedHttpRequestDeployment {
+    baseUrl: string;
+    credentialBindings: CredentialBindings;
+    pendingFields: string[];
+    authentication?: HttpRequestAuthenticationMapping;
+}

package/dist/types/request-deployment.js

@@ -0,0 +1 @@
+export {};

package/dist/types/request-materialization.d.ts

@@ -0,0 +1,22 @@
+import type { ApiCallArguments, ApiOperationContract, JsonValue } from '@openapi-flow/core';
+import type { Operation } from '@openapi-flow/core/internal';
+import type { PreparedRequestBody, RequestHeader } from './legacy/request-node.js';
+export interface RequestMaterializationConfig {
+    contract: ApiOperationContract;
+    operation: Operation;
+    arguments: ApiCallArguments;
+    templateUrl: string;
+}
+export interface MaterializedHttpRequest {
+    url: string;
+    headers: RequestHeader[];
+    body?: PreparedRequestBody;
+}
+export type ResponseBodies = Record<string, JsonValue>;
+export interface RuntimeHttpRequest extends MaterializedHttpRequest {
+    headersJson: string;
+}
+export interface RuntimeRequestValidator {
+    (value: unknown): boolean;
+    errors?: unknown;
+}

package/dist/types/request-materialization.js

@@ -0,0 +1 @@
+export {};

package/dist/types/response-check-compilation.d.ts

@@ -0,0 +1,11 @@
+import type { CompileNativeNodeInput, NativeCheck } from './native-capability.js';
+import type { N8nApiResponseSource } from './output-binding-source.js';
+export interface CreateResponseCheckReaderInput extends Pick<CompileNativeNodeInput, 'apiNodeNames' | 'apiResponseContracts'> {
+    nodeId: string;
+    checks: NativeCheck[];
+    linked: boolean;
+}
+export interface CompiledResponseCheckReader {
+    code: string;
+    bindingSources: N8nApiResponseSource[];
+}

package/dist/types/response-check-compilation.js

@@ -0,0 +1 @@
+export {};

package/dist/types/response-check-guard.d.ts

@@ -0,0 +1,6 @@
+export interface CreateResponseCheckGuardInput {
+    nodeId: string;
+    readerCode: string;
+    linked: boolean;
+    position: [number, number];
+}

package/dist/types/response-check-guard.js

@@ -0,0 +1 @@
+export {};

package/dist/types/response-collection.d.ts

@@ -0,0 +1,7 @@
+import type { ApiBindingMaterial } from '@openapi-flow/core';
+import type { z } from 'zod';
+import type { responseCollectionParametersSchema } from '../schemas/response-collection-schema.js';
+export type ResponseCollectionParameters = z.infer<typeof responseCollectionParametersSchema>;
+export interface CreateResponseCollectionCapabilityInput {
+    materials: ApiBindingMaterial[];
+}

package/dist/types/response-collection.js

@@ -0,0 +1 @@
+export {};

package/dist/types/reviewable-workflow.d.ts

@@ -0,0 +1,27 @@
+import type { ReviewableWorkflowGraphPlan, ReviewableWorkflowApiMaterial, WorkflowReviewGap, ApiOperationContract } from '@openapi-flow/core';
+import type { N8nNativeCapability } from './native-capability.js';
+import type { N8nNodeFragment, N8nSdkNode } from './node-fragment.js';
+export interface CompileReviewableN8nWorkflowInput {
+    id: string;
+    name: string;
+    plan: ReviewableWorkflowGraphPlan;
+    materials: ReviewableWorkflowApiMaterial[];
+    apiNodes: N8nNodeFragment[];
+    capabilities: N8nNativeCapability[];
+}
+export interface CreateGapNodeInput {
+    nodeId: string;
+    gaps: WorkflowReviewGap[];
+    position: [number, number];
+    operation?: ApiOperationContract;
+}
+export interface GapReviewRegionLayout {
+    nodePosition: [number, number];
+    notePosition: [number, number];
+    width: number;
+    height: number;
+}
+export interface GapReviewRegion {
+    fragment: N8nNodeFragment;
+    annotation: N8nSdkNode;
+}

package/dist/types/reviewable-workflow.js

@@ -0,0 +1 @@
+export {};

package/dist/types/schema-compilation.d.ts

@@ -0,0 +1,5 @@
+import type { BindingSchema } from '@openapi-flow/core';
+export interface CompileStandaloneValidatorInput {
+    schema: BindingSchema;
+    globalName: string;
+}

package/dist/types/schema-compilation.js

@@ -0,0 +1 @@
+export {};

package/dist/types/serialized-http-request.d.ts

@@ -0,0 +1,4 @@
+import type { HttpRequestNodeInput } from './legacy/request-node.js';
+export interface SerializedHttpRequestNodeInput extends HttpRequestNodeInput {
+    bodySource: 'literal' | 'materialized';
+}

package/dist/types/serialized-http-request.js

@@ -0,0 +1 @@
+export {};

package/dist/types/workflow-compilation.d.ts

@@ -0,0 +1,36 @@
+import type { WorkflowJSON } from '@n8n/workflow-sdk';
+import type { N8nNodeFragment } from './node-fragment.js';
+import type { N8nSdkNode } from './node-fragment.js';
+import type { WorkflowReviewGap } from '@openapi-flow/core';
+import type { N8nBatchExecutionScope } from './batch-execution.js';
+export interface N8nGraphEdge {
+    from: string;
+    output: string;
+    to: string;
+    input: string;
+}
+export interface AssembleN8nWorkflowInput {
+    id: string;
+    name: string;
+    nodes: N8nNodeFragment[];
+    edges: N8nGraphEdge[];
+    starts: string[];
+}
+export interface N8nCompileResult {
+    status: 'complete';
+    workflow: WorkflowJSON;
+}
+export interface BuildN8nWorkflowInput extends AssembleN8nWorkflowInput {
+    triggerConnections: 'connected' | 'detached';
+    annotations: N8nSdkNode[];
+    batchScopes?: N8nBatchExecutionScope[];
+}
+export interface N8nWorkflowJSON extends WorkflowJSON {
+    active?: false;
+}
+export interface N8nNeedsReviewResult {
+    status: 'needs-review';
+    workflow: N8nWorkflowJSON;
+    diagnostics: WorkflowReviewGap[];
+}
+export type N8nWorkflowResult = N8nCompileResult | N8nNeedsReviewResult;

package/dist/types/workflow-compilation.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/bundled-license-banner.d.ts

@@ -0,0 +1,3 @@
+import type { Metafile } from 'esbuild';
+/** Preserve bundled dependencies' license notices in generated workflow code. */
+export declare function bundledLicenseBanner(metadata: Metafile, generatedFrom: string[]): string;

package/dist/utils/bundled-license-banner.js

@@ -0,0 +1,32 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+/** Preserve bundled dependencies' license notices in generated workflow code. */
+export function bundledLicenseBanner(metadata, generatedFrom) {
+    const packages = new Set(generatedFrom);
+    const notices = [];
+    for (const input of Object.keys(metadata.inputs)) {
+        if (input === '<stdin>')
+            continue;
+        let directory = dirname(resolve(input));
+        while (!existsSync(join(directory, 'package.json'))) {
+            const parent = dirname(directory);
+            if (parent === directory)
+                throw new Error(`Bundled input ${input} has no owning package`);
+            directory = parent;
+        }
+        packages.add(directory);
+    }
+    for (const directory of packages) {
+        const file = ['LICENSE', 'LICENSE.md', 'LICENSE.txt']
+            .map((name) => join(directory, name))
+            .find(existsSync);
+        if (!file)
+            throw new Error(`Bundled package ${directory} has no license notice`);
+        notices.push(readFileSync(file, 'utf8'));
+    }
+    return notices.length
+        ? '/*! Bundled dependency licenses\n' +
+            notices.join('\n\n').replaceAll('*/', '* /') +
+            '\n*/\n'
+        : '';
+}

package/dist/utils/javascript-json-literal.d.ts

@@ -0,0 +1,2 @@
+/** Encode data as a JS string, avoiding n8n's delimiter scan even inside strings. */
+export declare function javascriptJsonLiteral(value: unknown): string;

package/dist/utils/javascript-json-literal.js

@@ -0,0 +1,10 @@
+/** Encode data as a JS string, avoiding n8n's delimiter scan even inside strings. */
+export function javascriptJsonLiteral(value) {
+    const json = JSON.stringify(value);
+    if (json === undefined)
+        throw new Error('Runtime data must be JSON-serializable');
+    const literal = JSON.stringify(json)
+        .replaceAll('{', '\\u007b')
+        .replaceAll('}', '\\u007d');
+    return `JSON.parse(${literal})`;
+}

package/dist/utils/json-values-equal.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/** JSON Schema equality is structural; JavaScript prototypes are not JSON data. */
+function jsonValuesEqual(left, right) {
+    if (left === right)
+        return true;
+    if (left === null ||
+        right === null ||
+        typeof left !== 'object' ||
+        typeof right !== 'object')
+        return false;
+    if (Array.isArray(left) !== Array.isArray(right))
+        return false;
+    if (Array.isArray(left) &&
+        Array.isArray(right) &&
+        left.length !== right.length)
+        return false;
+    const keys = Object.keys(left);
+    return (keys.length === Object.keys(right).length &&
+        keys.every((key) => Object.hasOwn(right, key) &&
+            jsonValuesEqual(Reflect.get(left, key), Reflect.get(right, key))));
+}
+// Ajv standalone requires a CommonJS module's plain default field.
+module.exports = { default: jsonValuesEqual };

package/dist/utils/json-values-equal.d.cts

@@ -0,0 +1 @@
+export {};

package/dist/workflow/assemble-n8n-workflow.d.ts

@@ -0,0 +1,2 @@
+import type { AssembleN8nWorkflowInput, N8nCompileResult } from '../types/workflow-compilation.js';
+export declare function assembleN8nWorkflow(input: AssembleN8nWorkflowInput): N8nCompileResult;

package/dist/workflow/assemble-n8n-workflow.js

@@ -0,0 +1,11 @@
+import { buildN8nWorkflow } from './build-n8n-workflow.js';
+export function assembleN8nWorkflow(input) {
+    return {
+        status: 'complete',
+        workflow: buildN8nWorkflow({
+            ...input,
+            triggerConnections: 'connected',
+            annotations: [],
+        }),
+    };
+}

package/dist/workflow/batch/compile-batched-n8n-workflow.d.ts

@@ -0,0 +1,3 @@
+import type { CompileBatchedN8nWorkflowInput } from '../../types/batch-execution.js';
+import type { N8nCompileResult } from '../../types/workflow-compilation.js';
+export declare function compileBatchedN8nWorkflow(input: CompileBatchedN8nWorkflowInput): N8nCompileResult;

package/dist/workflow/batch/compile-batched-n8n-workflow.js

@@ -0,0 +1,18 @@
+import { batchExecutionScopesSchema } from '../../schemas/batch-execution-schema.js';
+import { compileValidatedWorkflowFragments } from '../compile-validated-workflow-fragments.js';
+import { buildN8nWorkflow } from '../build-n8n-workflow.js';
+export function compileBatchedN8nWorkflow(input) {
+    const batchScopes = batchExecutionScopesSchema.parse(input.batchScopes);
+    const workflow = buildN8nWorkflow({
+        id: input.id,
+        name: input.name,
+        nodes: compileValidatedWorkflowFragments(input),
+        edges: input.plan.edges,
+        starts: input.plan.starts,
+        triggerConnections: 'connected',
+        annotations: [],
+        batchScopes,
+    });
+    workflow.settings = { ...workflow.settings, executionOrder: 'v1' };
+    return { status: 'complete', workflow };
+}

package/dist/workflow/batch/create-batch-execution-scopes.d.ts

@@ -0,0 +1,3 @@
+import type { CreateBatchExecutionScopesInput, CompiledN8nBatchExecutionScope } from '../../types/batch-execution.js';
+/** Lower explicitly bounded, cardinality-preserving paths; never allow arbitrary cycles. */
+export declare function createBatchExecutionScopes(input: CreateBatchExecutionScopesInput): CompiledN8nBatchExecutionScope[];

package/dist/workflow/batch/create-batch-execution-scopes.js

@@ -0,0 +1,59 @@
+import { node } from '@n8n/workflow-sdk';
+import { batchExecutionScopesSchema } from '../../schemas/batch-execution-schema.js';
+import { validateBatchItemFlow } from './validate-batch-item-flow.js';
+/** Lower explicitly bounded, cardinality-preserving paths; never allow arbitrary cycles. */
+export function createBatchExecutionScopes(input) {
+    const scopes = batchExecutionScopesSchema.parse(input.batchScopes);
+    const fragments = new Map(input.nodes.map((fragment) => [fragment.nodeId, fragment]));
+    const owners = new Set();
+    const ids = new Set();
+    return scopes.map((scope) => {
+        const members = new Set(scope.nodeIds);
+        if (ids.has(scope.id) ||
+            members.size !== scope.nodeIds.length ||
+            !members.has(scope.entryNodeId) ||
+            !members.has(scope.exitNodeId))
+            throw new Error(`batch ${scope.id}: duplicate scope/member identity or missing entry/exit member`);
+        ids.add(scope.id);
+        for (const id of members) {
+            const fragment = fragments.get(id);
+            if (!fragment || owners.has(id))
+                throw new Error(`batch ${scope.id}: missing or overlapping member ${id}`);
+            owners.add(id);
+            const incoming = input.edges.filter((edge) => edge.to === id);
+            const outgoing = input.edges.filter((edge) => edge.from === id);
+            if (incoming.some((edge) => !members.has(edge.from) && id !== scope.entryNodeId) ||
+                outgoing.some((edge) => !members.has(edge.to) && id !== scope.exitNodeId))
+                throw new Error(`batch ${scope.id}: member ${id} crosses the entry/exit boundary`);
+            if (id !== scope.entryNodeId && input.starts.includes(id))
+                throw new Error(`batch ${scope.id}: only its entry may be a workflow start`);
+        }
+        validateBatchItemFlow({
+            scope,
+            fragments,
+            edges: input.edges,
+            otherBatchNodeIds: new Set(scopes
+                .filter((other) => other.id !== scope.id)
+                .flatMap((other) => other.nodeIds)),
+        });
+        const entry = fragments.get(scope.entryNodeId);
+        const position = entry.entry.config.position;
+        if (!Array.isArray(position) ||
+            position.length !== 2 ||
+            position.some((coordinate) => typeof coordinate !== 'number' || !Number.isFinite(coordinate)))
+            throw new Error(`batch ${scope.id}: entry ${scope.entryNodeId} requires config.position with two finite coordinates`);
+        return {
+            scope,
+            controller: node({
+                type: 'n8n-nodes-base.splitInBatches',
+                version: 3,
+                config: {
+                    id: scope.id,
+                    name: scope.id,
+                    position: [position[0] - 220, position[1]],
+                    parameters: { batchSize: scope.batchSize, options: { reset: false } },
+                },
+            }),
+        };
+    });
+}

package/dist/workflow/batch/validate-batch-exclusive-rejoin.d.ts

@@ -0,0 +1,3 @@
+import type { ValidateBatchItemFlowInput } from '../../types/batch-execution.js';
+/** Verify complete one-to-one paths, rather than interpreting item values or IDs. */
+export declare function validateBatchExclusiveRejoin(input: ValidateBatchItemFlowInput, nodeId: string): void;

package/dist/workflow/batch/validate-batch-exclusive-rejoin.js

@@ -0,0 +1,49 @@
+/** Verify complete one-to-one paths, rather than interpreting item values or IDs. */
+export function validateBatchExclusiveRejoin(input, nodeId) {
+    const { scope, fragments, edges } = input;
+    const sourceId = fragments.get(nodeId).rejoinsExclusiveOutputs;
+    const source = fragments.get(sourceId);
+    const target = fragments.get(nodeId);
+    const incoming = edges.filter((edge) => edge.to === nodeId);
+    if (!scope.nodeIds.includes(sourceId) ||
+        !source?.partitionsInputItems ||
+        target.preservesInputItems ||
+        target.joinsInputItemsByAncestry ||
+        Object.keys(target.outputPorts).join() !== 'main' ||
+        target.inputEndpoints ||
+        incoming.length !== Object.keys(target.inputPorts).length)
+        throw new Error(`batch ${scope.id}: rejoin ${nodeId} requires a complete partition in the same scope`);
+    const covered = new Set();
+    for (const port of Object.keys(target.inputPorts)) {
+        const paths = incoming.filter((edge) => edge.input === port);
+        if (paths.length !== 1)
+            throw new Error(`batch ${scope.id}: rejoin ${nodeId} requires exactly one path per input`);
+        let edge = paths[0];
+        const visited = new Set();
+        while (edge.from !== sourceId) {
+            const step = fragments.get(edge.from);
+            const predecessors = edges.filter((item) => item.to === edge.from);
+            if (!scope.nodeIds.includes(edge.from) ||
+                visited.has(edge.from) ||
+                !step ||
+                step.preservesInputItems !== true ||
+                step.joinsInputItemsByAncestry ||
+                step.partitionsInputItems ||
+                step.rejoinsExclusiveOutputs ||
+                step.inputEndpoints ||
+                Object.keys(step.inputPorts).join() !== 'main' ||
+                Object.keys(step.outputPorts).join() !== 'main' ||
+                predecessors.length !== 1 ||
+                edges.filter((item) => item.from === edge.from).length !== 1)
+                throw new Error(`batch ${scope.id}: rejoin ${nodeId} requires item-preserving paths from ${sourceId}`);
+            visited.add(edge.from);
+            edge = predecessors[0];
+        }
+        if (!Object.hasOwn(source.outputPorts, edge.output) ||
+            covered.has(edge.output))
+            throw new Error(`batch ${scope.id}: rejoin ${nodeId} repeats or omits an alternative of ${sourceId}`);
+        covered.add(edge.output);
+    }
+    if (covered.size !== Object.keys(source.outputPorts).length)
+        throw new Error(`batch ${scope.id}: rejoin ${nodeId} must return every alternative of ${sourceId}`);
+}

package/dist/workflow/batch/validate-batch-item-flow.d.ts

@@ -0,0 +1,3 @@
+import type { ValidateBatchItemFlowInput } from '../../types/batch-execution.js';
+/** Prove one result per entry item through declared preservation and ancestry joins. */
+export declare function validateBatchItemFlow({ scope, fragments, edges, otherBatchNodeIds, }: ValidateBatchItemFlowInput): void;

package/dist/workflow/batch/validate-batch-item-flow.js

@@ -0,0 +1,98 @@
+import { validateBatchExclusiveRejoin } from './validate-batch-exclusive-rejoin.js';
+/** Prove one result per entry item through declared preservation and ancestry joins. */
+export function validateBatchItemFlow({ scope, fragments, edges, otherBatchNodeIds, }) {
+    const members = new Set(scope.nodeIds);
+    const incoming = (id) => edges.filter((edge) => edge.to === id);
+    const outgoing = (id) => edges.filter((edge) => edge.from === id);
+    const upstream = incoming(scope.entryNodeId).filter((edge) => !members.has(edge.from));
+    if (upstream.length > 1)
+        throw new Error(`batch ${scope.id}: entry requires one upstream stream`);
+    const entryAncestors = new Set();
+    let preceding = upstream.map((edge) => edge.from);
+    while (preceding.length) {
+        const id = preceding.pop();
+        if (otherBatchNodeIds.has(id))
+            break;
+        if (entryAncestors.has(id))
+            throw new Error(`batch ${scope.id}: upstream item flow has a cycle`);
+        entryAncestors.add(id);
+        const fragment = fragments.get(id);
+        const sources = incoming(id);
+        if (fragment.preservesInputItems === true &&
+            !fragment.joinsInputItemsByAncestry &&
+            Object.keys(fragment.inputPorts).join() === 'main' &&
+            Object.keys(fragment.outputPorts).join() === 'main' &&
+            !fragment.inputEndpoints &&
+            sources.length === 1)
+            preceding = [sources[0].from];
+    }
+    const ancestors = new Map();
+    const pending = [...members];
+    while (pending.length) {
+        const index = pending.findIndex((id) => incoming(id)
+            .filter((edge) => members.has(edge.from))
+            .every((edge) => ancestors.has(edge.from)));
+        if (index === -1)
+            throw new Error(`batch ${scope.id}: item flow has a cycle`);
+        const id = pending.splice(index, 1)[0];
+        const fragment = fragments.get(id);
+        const innerIncoming = incoming(id).filter((edge) => members.has(edge.from));
+        const innerOutgoing = outgoing(id).filter((edge) => members.has(edge.to));
+        if ((id === scope.entryNodeId
+            ? innerIncoming.length !== 0
+            : innerIncoming.length === 0) ||
+            (id === scope.exitNodeId
+                ? innerOutgoing.length !== 0
+                : innerOutgoing.length === 0))
+            throw new Error(`batch ${scope.id}: every member must lie between its entry and exit`);
+        const join = fragment.joinsInputItemsByAncestry;
+        const rejoin = fragment.rejoinsExclusiveOutputs;
+        const partition = fragment.partitionsInputItems;
+        if (partition &&
+            (fragment.preservesInputItems ||
+                join ||
+                rejoin ||
+                Object.keys(fragment.inputPorts).join() !== 'main' ||
+                fragment.inputEndpoints ||
+                Object.keys(fragment.outputPorts).length < 2 ||
+                Object.keys(fragment.outputPorts).some((port) => innerOutgoing.filter((edge) => edge.output === port).length !== 1)))
+            throw new Error(`batch ${scope.id}: item-preserving main path contract requires every partition output of ${id} to return exactly once`);
+        if ((!partition && Object.keys(fragment.outputPorts).join() !== 'main') ||
+            (!join &&
+                !partition &&
+                !rejoin &&
+                (fragment.preservesInputItems !== true ||
+                    Object.keys(fragment.inputPorts).join() !== 'main' ||
+                    fragment.inputEndpoints)) ||
+            (join && fragment.preservesInputItems === true))
+            throw new Error(`batch ${scope.id}: member ${id} requires an item-preserving main path contract or an explicit ancestry join`);
+        let inherited;
+        if (rejoin) {
+            validateBatchExclusiveRejoin({ scope, fragments, edges, otherBatchNodeIds }, id);
+            const branches = innerIncoming.map((edge) => ancestors.get(edge.from));
+            inherited = new Set([...branches[0]].filter((ancestor) => branches.every((branch) => branch.has(ancestor))));
+        }
+        else if (join) {
+            const ports = Object.keys(fragment.inputPorts);
+            if (id === scope.entryNodeId ||
+                ports.length < 2 ||
+                ports.some((port) => innerIncoming.filter((edge) => edge.input === port).length !== 1) ||
+                innerIncoming.length !== ports.length)
+                throw new Error(`batch ${scope.id}: join ${id} requires exactly one branch per declared input`);
+            const branchAncestors = innerIncoming.map((edge) => ancestors.get(edge.from));
+            if (!fragment.bindingSources?.some((source) => source.kind === 'native-json' && source.nodeId === join.scopeNodeId) ||
+                branchAncestors.some((branch) => !branch.has(join.scopeNodeId)))
+                throw new Error(`batch ${scope.id}: join ${id} scope ${join.scopeNodeId} must identify each entry item on every branch`);
+            inherited = new Set([...branchAncestors[0]].filter((ancestor) => branchAncestors.every((branch) => branch.has(ancestor))));
+        }
+        else {
+            if (id !== scope.entryNodeId && innerIncoming.length !== 1)
+                throw new Error(`batch ${scope.id}: member ${id} requires one incoming item stream; use an explicit ancestry join for branches`);
+            inherited =
+                id === scope.entryNodeId
+                    ? entryAncestors
+                    : ancestors.get(innerIncoming[0].from);
+        }
+        ancestors.set(id, new Set([...inherited, id]));
+    }
+}

package/dist/workflow/build-n8n-workflow.d.ts

@@ -0,0 +1,2 @@
+import type { BuildN8nWorkflowInput, N8nWorkflowJSON } from '../types/workflow-compilation.js';
+export declare function buildN8nWorkflow({ id, name, nodes, edges, starts, triggerConnections, annotations, batchScopes, }: BuildN8nWorkflowInput): N8nWorkflowJSON;