@openapi-flow/n8n 0.0.0-stage → 0.2.0

package/dist/schemas/native-capability-schemas.js

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+// Disjoint source literals retain the same validation contract with anyOf.
+// OpenAI-compatible strict tools reject the oneOf emitted by discriminatedUnion.
+export const nativeOperandSchema = z.union([
+    z.strictObject({
+        source: z.literal('response'),
+        nodeId: z
+            .string()
+            .min(1)
+            .describe('API callId whose response is guaranteed to have executed.'),
+        pointer: z
+            .string()
+            .describe('RFC 6901 pointer into the response body. Empty string means the whole body.'),
+    }),
+    z.strictObject({
+        source: z.literal('literal'),
+        value: z
+            .union([z.string(), z.number(), z.boolean(), z.null()])
+            .describe('An explicitly requested scalar comparison value; no expressions or code.'),
+    }),
+]);
+export const nativeCheckSchema = z.strictObject({
+    left: nativeOperandSchema,
+    operator: z
+        .enum(['equals', 'notEquals', 'greaterThan', 'lessThan', 'keysEqual'])
+        .describe('equals is deep, type-strict JSON equality. keysEqual compares object key sets. Numeric operators require numbers.'),
+    right: nativeOperandSchema,
+});
+export const ifParametersSchema = z.strictObject({
+    combinator: z
+        .enum(['and', 'or'])
+        .describe('Combine all conditions. Outputs: true, false; input: main.'),
+    conditions: z
+        .array(nativeCheckSchema)
+        .min(1)
+        .describe('Only conditions required by the scenario, with OAS-derived response pointers.'),
+});
+export const mergeParametersSchema = z.strictObject({
+    numberInputs: z
+        .number()
+        .int()
+        .min(2)
+        .describe('Append waits for ALL inputs named input1..inputN. Output: main. Never join mutually exclusive branches.'),
+});
+export const assertionParametersSchema = z.strictObject({
+    checks: z
+        .array(nativeCheckSchema.extend({
+        message: z
+            .string()
+            .min(1)
+            .describe('Actionable failure message for this scenario assertion.'),
+    }))
+        .min(1)
+        .describe('Declarative assertions over API responses; compiled to Code by the library, never model-written JavaScript. Input/output: main.'),
+});
+export const stopParametersSchema = z.strictObject({
+    message: z
+        .string()
+        .min(1)
+        .describe('StopAndError message when this branch executes. Input: main; no output.'),
+});
+export const passThroughParametersSchema = z.strictObject({});

package/dist/schemas/request-deployment-schema.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const httpRequestDeploymentOptionsSchema: z.ZodObject<{
+    baseUrl: z.ZodOptional<z.ZodString>;
+    credentialBindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>>;
+    securityRequirementIndex: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;

package/dist/schemas/request-deployment-schema.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { originFrom } from '../legacy/workflow/request/base-url.js';
+export const httpRequestDeploymentOptionsSchema = z.strictObject({
+    baseUrl: z
+        .string()
+        .superRefine((value, context) => {
+        try {
+            originFrom(value);
+        }
+        catch (error) {
+            if (!(error instanceof Error))
+                throw error;
+            context.addIssue({
+                code: 'custom',
+                message: error.message,
+            });
+        }
+    })
+        .optional(),
+    credentialBindings: z
+        .record(z.string().min(1), z.strictObject({
+        id: z.string().refine((value) => value.trim().length > 0),
+        name: z.string().refine((value) => value.trim().length > 0),
+    }))
+        .optional(),
+    securityRequirementIndex: z.number().int().nonnegative().optional(),
+});

package/dist/schemas/response-array-schema.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export declare const responseArrayParametersSchema: z.ZodObject<{
+    sourceNodeId: z.ZodString;
+    pointer: z.ZodString;
+}, z.core.$strict>;
+export declare function createResponseArrayParametersSchema(callIds: string[]): z.ZodObject<{
+    pointer: z.ZodString;
+    sourceNodeId: z.ZodEnum<{
+        [x: string]: string;
+    }>;
+}, z.core.$strict>;

package/dist/schemas/response-array-schema.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export const responseArrayParametersSchema = z.strictObject({
+    sourceNodeId: z
+        .string()
+        .min(1)
+        .describe('Existing API callId whose declared OAS response contains the scenario-required array.'),
+    pointer: z
+        .string()
+        .describe('RFC 6901 pointer into that response body selecting the array. Empty string selects an array body. Never select a first element instead of iterating.'),
+});
+export function createResponseArrayParametersSchema(callIds) {
+    if (!callIds.length)
+        throw new Error('array parameters require API callIds');
+    return responseArrayParametersSchema.extend({
+        sourceNodeId: z
+            .enum(callIds)
+            .describe('Only a supplied API callId; code derives and validates the response array contract.'),
+    });
+}

package/dist/schemas/response-collection-schema.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export declare const responseCollectionParametersSchema: z.ZodObject<{
+    sourceNodeId: z.ZodString;
+    pointer: z.ZodString;
+}, z.core.$strict>;
+export declare function createResponseCollectionParametersSchema(callIds: string[]): z.ZodObject<{
+    pointer: z.ZodString;
+    sourceNodeId: z.ZodEnum<{
+        [x: string]: string;
+    }>;
+}, z.core.$strict>;

package/dist/schemas/response-collection-schema.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export const responseCollectionParametersSchema = z.strictObject({
+    sourceNodeId: z
+        .string()
+        .min(1)
+        .describe('An existing API callId whose item-linked responses must be collected.'),
+    pointer: z
+        .string()
+        .describe('RFC 6901 pointer into each API response body. Empty string collects the entire unchanged body.'),
+});
+export function createResponseCollectionParametersSchema(callIds) {
+    if (!callIds.length)
+        throw new Error('collection parameters require API callIds');
+    return responseCollectionParametersSchema.extend({
+        sourceNodeId: z
+            .enum(callIds)
+            .describe('Only a supplied API callId. Code derives response schemas and validates each source.'),
+    });
+}

package/dist/types/array-iteration.d.ts

@@ -0,0 +1,8 @@
+import type { ApiBindingMaterial } from '@openapi-flow/core';
+import type { z } from 'zod';
+import type { responseArrayParametersSchema } from '../schemas/response-array-schema.js';
+import type { NativeItemExecutionOptions } from './native-capability.js';
+export type ResponseArrayParameters = z.infer<typeof responseArrayParametersSchema>;
+export interface CreateResponseArrayCapabilityInput extends NativeItemExecutionOptions {
+    materials: ApiBindingMaterial[];
+}

package/dist/types/array-iteration.js

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

package/dist/types/array-split.d.ts

@@ -0,0 +1,13 @@
+import type { PlannedNativeNode } from '@openapi-flow/core';
+import type { N8nOutputBindingSource } from './output-binding-source.js';
+export interface ArraySplitParameters {
+    sourceNodeId: string;
+    pointer: string;
+}
+export interface CreateArrayNodeFragmentInput {
+    planned: PlannedNativeNode;
+    position: [number, number];
+    source: N8nOutputBindingSource;
+    parameters: ArraySplitParameters;
+    linked: boolean;
+}

package/dist/types/array-split.js

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

package/dist/types/authentication.d.ts

@@ -0,0 +1,14 @@
+import type { ApiOperationContract } from '@openapi-flow/core';
+export type HttpRequestCredentialType = 'httpBearerAuth' | 'httpBasicAuth' | 'httpDigestAuth' | 'httpHeaderAuth' | 'httpQueryAuth' | 'oAuth2Api';
+export interface HttpRequestAuthenticationMapping {
+    schemeName: string;
+    credentialType: HttpRequestCredentialType;
+    credentialRequirements?: string;
+}
+export interface ResolveHttpRequestAuthenticationInput {
+    operation: ApiOperationContract;
+    securityRequirementIndex?: number;
+}
+export interface CredentialBindingRequest {
+    authentication?: HttpRequestAuthenticationMapping;
+}

package/dist/types/authentication.js

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

package/dist/types/batch-execution.d.ts

@@ -0,0 +1,23 @@
+import type { z } from 'zod';
+import type { batchExecutionScopeSchema } from '../schemas/batch-execution-schema.js';
+import type { CompilePlannedN8nWorkflowInput } from './native-capability.js';
+import type { N8nSdkNode, N8nNodeFragment } from './node-fragment.js';
+import type { AssembleN8nWorkflowInput } from './workflow-compilation.js';
+export type N8nBatchExecutionScope = z.infer<typeof batchExecutionScopeSchema>;
+export interface CompileBatchedN8nWorkflowInput extends CompilePlannedN8nWorkflowInput {
+    batchScopes: N8nBatchExecutionScope[];
+}
+export interface CreateBatchExecutionScopesInput extends AssembleN8nWorkflowInput {
+    batchScopes: N8nBatchExecutionScope[];
+}
+export interface CompiledN8nBatchExecutionScope {
+    scope: N8nBatchExecutionScope;
+    controller: N8nSdkNode;
+}
+export interface ValidateBatchItemFlowInput {
+    scope: N8nBatchExecutionScope;
+    fragments: Map<string, N8nNodeFragment>;
+    edges: AssembleN8nWorkflowInput['edges'];
+    /** A completed earlier batch is not the original exit node's latest run. */
+    otherBatchNodeIds: Set<string>;
+}

package/dist/types/batch-execution.js

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

package/dist/types/http-response-decoding.d.ts

@@ -0,0 +1,16 @@
+import type { ApiResponseEnvelope } from '@openapi-flow/core';
+import type { N8nNodeFragment } from './node-fragment.js';
+export interface HttpResponseDecodeInput {
+    response: ApiResponseEnvelope;
+    bytes: Uint8Array;
+    method: string;
+    sourceNodeId: string;
+}
+export interface DecodedHttpResponse {
+    response: ApiResponseEnvelope;
+    kind: 'json' | 'text' | 'binary' | 'empty';
+}
+export interface CreateHttpResponseDecoderInput {
+    fragment: N8nNodeFragment;
+    method: string;
+}

package/dist/types/http-response-decoding.js

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

package/dist/types/item-join.d.ts

@@ -0,0 +1,40 @@
+import type { z } from 'zod';
+import type { ApiBindingMaterial, JsonValue } from '@openapi-flow/core';
+import type { N8nNativeOutputSource, N8nOutputBindingSource } from './output-binding-source.js';
+import type { itemJoinParametersSchema } from '../schemas/item-join-schema.js';
+export type ItemJoinParameters = z.infer<typeof itemJoinParametersSchema>;
+export interface CreateItemJoinCapabilityInput {
+    materials: ApiBindingMaterial[];
+    scopes: N8nNativeOutputSource[];
+}
+export interface CreateItemJoinReaderCodeInput {
+    scope: N8nNativeOutputSource;
+    sourceCallId: string;
+    sources: N8nOutputBindingSource[];
+}
+export interface ItemJoinRow {
+    scopeIndex: number;
+    sourceCallId: string;
+    response: JsonValue;
+}
+export interface ItemJoinInputItem {
+    json: ItemJoinRow;
+}
+export interface JoinApiItemsInput {
+    items: ItemJoinInputItem[];
+    sourceCallIds: string[];
+}
+export interface ItemJoinValues {
+    responses: Record<string, JsonValue>;
+}
+export interface ItemJoinOutputItem {
+    json: ItemJoinValues;
+    pairedItem: ItemJoinPair[];
+}
+export interface ItemJoinPair {
+    item: number;
+}
+export interface ItemJoinGroup {
+    values: Map<string, JsonValue>;
+    inputIndexes: number[];
+}

package/dist/types/item-join.js

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

package/dist/types/legacy/catalog-workflow.d.ts

@@ -0,0 +1,37 @@
+import type { WorkflowJSON } from '@n8n/workflow-sdk';
+import type { CatalogSource, CatalogSequencePlan, CatalogDiagnostic } from '@openapi-flow/core/internal';
+import type { Operation } from '@openapi-flow/core/internal';
+import type { CredentialBindings, EffectPolicy } from '@openapi-flow/n8n/legacy';
+import type { SequenceEvidence, SequencePlan, SequenceStep } from '@openapi-flow/n8n/legacy';
+import type { CompileRequest } from '@openapi-flow/n8n/legacy';
+export interface ResolvedSequenceStep {
+    operation: Operation;
+    origin: URL;
+    effectPolicy: EffectPolicy;
+    credentialBindings: CredentialBindings;
+}
+export interface PrepareStepsInput {
+    profile: CompileRequest['profile'];
+    plan: SequencePlan;
+    resolveStep: (step: SequenceStep) => ResolvedSequenceStep;
+}
+export interface N8nCatalogSource extends CatalogSource {
+    baseUrl: string;
+    effectPolicy: EffectPolicy;
+    credentialBindings: CredentialBindings;
+}
+export interface CatalogSequenceRequest {
+    sources: N8nCatalogSource[];
+    profile: CompileRequest['profile'];
+    plan: CatalogSequencePlan;
+}
+export interface CatalogSequenceEvidence extends SequenceEvidence {
+    documentId: string;
+}
+export interface CatalogSequenceResult {
+    status: 'complete' | 'needs_capability' | 'needs_input' | 'blocked';
+    plan: CatalogSequencePlan;
+    evidence: CatalogSequenceEvidence[];
+    diagnostics: CatalogDiagnostic[];
+    workflow?: WorkflowJSON;
+}

package/dist/types/legacy/catalog-workflow.js

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

package/dist/types/legacy/inbound-workflow.d.ts

@@ -0,0 +1,27 @@
+import type { WorkflowJSON } from '@n8n/workflow-sdk';
+import type { OpenApiDocument, ParsedDocument } from '@openapi-flow/core/internal';
+import type { InboundOperationCandidate, InboundOperationSource } from '@openapi-flow/core/internal';
+export interface InboundPlan {
+    version: '1';
+    goal: string;
+    operationRef: string;
+    webhookPath: string;
+    responseStatus: number;
+    responseMediaType?: string;
+    responseBody?: unknown;
+}
+export interface InboundRequest {
+    spec: OpenApiDocument;
+    plan: InboundPlan;
+}
+export interface InboundWorkflowContext {
+    document: ParsedDocument;
+    selected: InboundOperationSource;
+    plan: InboundPlan;
+}
+export interface InboundResult {
+    status: 'complete';
+    plan: InboundPlan;
+    evidence: InboundOperationCandidate;
+    workflow: WorkflowJSON;
+}

package/dist/types/legacy/inbound-workflow.js

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

package/dist/types/legacy/request-node.d.ts

@@ -0,0 +1,23 @@
+import type { NodeConfig } from '@n8n/workflow-sdk';
+import type { Operation } from '@openapi-flow/core/internal';
+export type RequiredFields = Record<string, string>;
+export type ResolvedAuthentication = Required<Pick<NodeConfig, 'parameters' | 'credentials'>>;
+export interface RequestHeader {
+    name: string;
+    value: string;
+}
+export interface PreparedRequestBody {
+    contentType: 'json' | 'form-urlencoded';
+    value: string;
+}
+export interface HttpRequestNodeInput {
+    operation: Operation;
+    id: string;
+    name: string;
+    position: [number, number];
+    url: string;
+    body?: PreparedRequestBody;
+    headers: RequestHeader[];
+    authentication?: ResolvedAuthentication;
+    shouldAssert: boolean;
+}

package/dist/types/legacy/request-node.js

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

package/dist/types/legacy/request-workflow.d.ts

@@ -0,0 +1,43 @@
+import type { ExpectedBody, WorkflowPlan } from '@openapi-flow/core/internal';
+export type { ExpectedBody, WorkflowInputs, InputValues, WorkflowPlan, } from '@openapi-flow/core/internal';
+import type { WorkflowJSON } from '@n8n/workflow-sdk';
+import type { OpenApiDocument } from '@openapi-flow/core/internal';
+import type { Operation } from '@openapi-flow/core/internal';
+import type { PreparedRequestBody, RequestHeader, ResolvedAuthentication } from './request-node.js';
+export type CompileStatus = 'complete' | 'needs_input' | 'blocked';
+export type OperationEffect = 'read' | 'write' | 'unknown';
+export type EffectPolicy = Record<string, 'read' | 'write'>;
+export interface CredentialBinding {
+    id: string;
+    name: string;
+}
+export type CredentialBindings = Record<string, CredentialBinding>;
+export interface OperationEvidence extends Pick<Operation, 'operationRef' | 'operationId' | 'method' | 'path'> {
+    effect: OperationEffect;
+}
+export interface CompileRequest {
+    spec: OpenApiDocument;
+    baseUrl: string;
+    profile: 'read-only' | 'test';
+    effectPolicy: EffectPolicy;
+    credentialBindings: CredentialBindings;
+    plan: WorkflowPlan;
+}
+export type CompileOperationRequest = Pick<CompileRequest, 'baseUrl' | 'profile' | 'effectPolicy' | 'credentialBindings' | 'plan'>;
+export interface CompileResult {
+    status: CompileStatus;
+    plan: WorkflowPlan;
+    evidence: OperationEvidence;
+    missingInputs: string[];
+    workflow?: WorkflowJSON;
+}
+export interface BuildRequestWorkflowInput {
+    baseUrl: string;
+    plan: WorkflowPlan;
+    operation: Operation;
+    url: string;
+    body?: PreparedRequestBody;
+    headers: RequestHeader[];
+    authentication?: ResolvedAuthentication;
+    expectedBody: ExpectedBody;
+}

package/dist/types/legacy/request-workflow.js

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

package/dist/types/legacy/sequence-workflow.d.ts

@@ -0,0 +1,57 @@
+import type { SequencePlan } from '@openapi-flow/core/internal';
+export type { ResponseReference, SequenceStep, SequencePlan, } from '@openapi-flow/core/internal';
+import type { WorkflowJSON } from '@n8n/workflow-sdk';
+import type { OpenApiDocument, ParsedDocument } from '@openapi-flow/core/internal';
+import type { Operation } from '@openapi-flow/core/internal';
+import type { PreparedRequestBody, RequestHeader, ResolvedAuthentication } from './request-node.js';
+import type { CompileRequest, CompileStatus, CredentialBindings, EffectPolicy, ExpectedBody, OperationEvidence } from './request-workflow.js';
+export type PreviousOperations = Map<string, Operation>;
+export type RequiredOutputs = Map<string, Set<string>>;
+export interface SequenceRequest {
+    spec: OpenApiDocument;
+    baseUrl: string;
+    profile: CompileRequest['profile'];
+    effectPolicy: EffectPolicy;
+    credentialBindings: CredentialBindings;
+    plan: SequencePlan;
+}
+export interface SequenceEvidence extends OperationEvidence {
+    stepId: string;
+}
+export interface SequenceResult {
+    status: CompileStatus;
+    plan: SequencePlan;
+    evidence: SequenceEvidence[];
+    missingInputs: string[];
+    workflow?: WorkflowJSON;
+}
+export interface PreparedSequenceNode {
+    operation: Operation;
+    id: string;
+    url: string;
+    body?: PreparedRequestBody;
+    headers: RequestHeader[];
+    expectedBody: ExpectedBody;
+    authentication?: ResolvedAuthentication;
+}
+export interface PrepareSequenceInput {
+    document: ParsedDocument;
+    origin: URL;
+    profile: SequenceRequest['profile'];
+    effectPolicy: EffectPolicy;
+    credentialBindings: CredentialBindings;
+    plan: SequencePlan;
+}
+export interface PreparedSequence {
+    evidence: SequenceEvidence[];
+    missingInputs: string[];
+    nodes: PreparedSequenceNode[];
+    requiredOutputs: RequiredOutputs;
+    blocked: boolean;
+}
+export interface BuildSequenceWorkflowInput {
+    baseUrl: string;
+    plan: SequencePlan;
+    nodes: PreparedSequenceNode[];
+    requiredOutputs: RequiredOutputs;
+}

package/dist/types/legacy/sequence-workflow.js

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

package/dist/types/native-array.d.ts

@@ -0,0 +1,8 @@
+import type { z } from 'zod';
+import type { nativeArrayParametersSchema } from '../schemas/native-array-schema.js';
+import type { N8nNativeOutputSource } from './output-binding-source.js';
+import type { NativeItemExecutionOptions } from './native-capability.js';
+export type NativeArrayParameters = z.infer<typeof nativeArrayParametersSchema>;
+export interface CreateNativeArrayCapabilityInput extends NativeItemExecutionOptions {
+    sources: N8nNativeOutputSource[];
+}

package/dist/types/native-array.js

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

package/dist/types/native-capability.d.ts

@@ -0,0 +1,37 @@
+import type { z } from 'zod';
+import type { PlannedNativeNode, WorkflowCapability, WorkflowGraphPlan, WorkflowApiMaterial, ApiOperationContract } from '@openapi-flow/core';
+import type { N8nNodeFragment } from './node-fragment.js';
+import type { nativeOperandSchema, nativeCheckSchema, ifParametersSchema, mergeParametersSchema, assertionParametersSchema, stopParametersSchema } from '../schemas/native-capability-schemas.js';
+export type NativeOperand = z.infer<typeof nativeOperandSchema>;
+export type NativeCheck = z.infer<typeof nativeCheckSchema>;
+export type IfParameters = z.infer<typeof ifParametersSchema>;
+export type MergeParameters = z.infer<typeof mergeParametersSchema>;
+export type AssertionParameters = z.infer<typeof assertionParametersSchema>;
+export type StopParameters = z.infer<typeof stopParametersSchema>;
+export interface NativeItemExecutionOptions {
+    itemMode?: 'linked';
+}
+export interface CompileNativeNodeInput {
+    planned: PlannedNativeNode;
+    apiNodeNames: Record<string, string>;
+    position: [number, number];
+    /** Original OAS contracts are required by compilers that read API responses. */
+    apiResponseContracts?: Record<string, ApiOperationContract>;
+}
+export interface N8nNativeCapability extends WorkflowCapability {
+    compile: (input: CompileNativeNodeInput) => N8nNodeFragment;
+}
+export interface CreateJsonOutputCapabilityInput {
+    name: string;
+    description: string;
+    parametersSchema: WorkflowCapability['parametersSchema'];
+}
+export interface CompilePlannedN8nWorkflowInput {
+    id: string;
+    name: string;
+    plan: WorkflowGraphPlan;
+    materials: WorkflowApiMaterial[];
+    apiNodes: N8nNodeFragment[];
+    capabilities: N8nNativeCapability[];
+}
+export type CompileNativeWorkflowNodesInput = Pick<CompilePlannedN8nWorkflowInput, 'plan' | 'apiNodes' | 'capabilities' | 'materials'>;

package/dist/types/native-capability.js

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

package/dist/types/node-fragment.d.ts

@@ -0,0 +1,51 @@
+import type { NodeInstance } from '@n8n/workflow-sdk';
+import type { ApiOperationContract, ApiCallArguments } from '@openapi-flow/core';
+import type { HttpRequestDeploymentOptions, ResolvedHttpRequestDeployment } from './request-deployment.js';
+import type { N8nNativeOutputSource, N8nOutputBindingSource } from './output-binding-source.js';
+export type N8nSdkNode = NodeInstance<string, string, unknown>;
+export interface N8nFragmentEdge {
+    from: string;
+    output: number;
+    to: string;
+    input: number;
+}
+export interface N8nFragmentInputEndpoint {
+    nodeId: string;
+    input: number;
+}
+export interface N8nItemAncestryJoin {
+    /** One output per shared scope ancestor, retaining every contributing link. */
+    scopeNodeId: string;
+}
+export interface N8nNodeFragment {
+    nodeId: string;
+    /** Compiler-owned contract: one linked output per input, or an execution error. */
+    preservesInputItems?: boolean;
+    /** Compiler-owned reduction of complete branches, not a positional or value join. */
+    joinsInputItemsByAncestry?: N8nItemAncestryJoin;
+    /** Exactly one linked item across the declared mutually exclusive output ports. */
+    partitionsInputItems?: boolean;
+    /** Append complete alternatives from the named partition producer. */
+    rejoinsExclusiveOutputs?: string;
+    nodes: N8nSdkNode[];
+    entry: N8nSdkNode;
+    exit: N8nSdkNode;
+    inputPorts: Record<string, number>;
+    /** Explicit per-port SDK entry nodes for fragments with independent input readers. */
+    inputEndpoints?: Record<string, N8nFragmentInputEndpoint>;
+    outputPorts: Record<string, number>;
+    internalEdges?: N8nFragmentEdge[];
+    bindingSources?: N8nOutputBindingSource[];
+}
+export interface CreateHttpRequestNodeInput extends HttpRequestDeploymentOptions {
+    operation: ApiOperationContract;
+    arguments: ApiCallArguments;
+    position: [number, number];
+    apiNodeNames?: Record<string, string>;
+    nativeOutputSources?: N8nNativeOutputSource[];
+    /** Linked mode uses n8n ancestry, never index-zipping independent source arrays. */
+    itemMode?: 'linked';
+    /** When supplied, every referenced API must have its original response contract. */
+    apiResponseContracts?: Record<string, ApiOperationContract>;
+}
+export type CreateBoundHttpRequestNodeInput = CreateHttpRequestNodeInput & ResolvedHttpRequestDeployment;

package/dist/types/node-fragment.js

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

package/dist/types/output-binding-source.d.ts

@@ -0,0 +1,22 @@
+import type { NativeOutputContract } from '@openapi-flow/core';
+import type { PlannedNativeNode } from '@openapi-flow/core';
+import type { N8nNativeCapability } from './native-capability.js';
+import type { ApiOperationContract } from '@openapi-flow/core';
+export interface N8nNativeOutputSource extends NativeOutputContract {
+    nodeName: string;
+}
+export interface N8nApiResponseSource {
+    kind: 'api-response';
+    nodeId: string;
+    nodeName: string;
+    operation?: ApiOperationContract;
+}
+export interface N8nNativeJsonSource extends N8nNativeOutputSource {
+    kind: 'native-json';
+}
+export type N8nOutputBindingSource = N8nApiResponseSource | N8nNativeJsonSource;
+export interface CreateN8nNativeOutputSourcesInput {
+    nativeNodes: PlannedNativeNode[];
+    capabilities: N8nNativeCapability[];
+    apiNodeNames: Record<string, string>;
+}

package/dist/types/output-binding-source.js

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