@openapi-flow/n8n 0.0.0-stage → 0.3.0

package/dist/schemas/native-feature-registry-schema.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const n8nNativeFeatureSelectionSchema: z.ZodArray<z.ZodEnum<Readonly<{
+    readonly If: "if";
+    readonly MergeAppend: "merge-append";
+    readonly AssertResponses: "assert-responses";
+    readonly StopAndError: "stop-and-error";
+    readonly PassThrough: "pass-through";
+    readonly RejoinExclusiveBranches: "rejoin-exclusive-branches";
+    readonly JsonOutput: "json-output";
+    readonly SplitApiResponseArray: "split-api-response-array";
+    readonly CollectApiResponses: "collect-api-responses";
+    readonly SplitNativeOutputArray: "split-native-output-array";
+    readonly JoinApiItems: "join-api-items";
+}>>>;
+export declare const nativeItemExecutionOptionsSchema: z.ZodObject<{
+    itemMode: z.ZodOptional<z.ZodLiteral<"linked">>;
+}, z.core.$strict>;

package/dist/schemas/native-feature-registry-schema.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { N8nNativeFeature } from '../types/native-feature-registry.js';
+export const n8nNativeFeatureSelectionSchema = z
+    .array(z.enum(N8nNativeFeature))
+    .refine((features) => new Set(features).size === features.length, 'features must be unique');
+export const nativeItemExecutionOptionsSchema = z.strictObject({
+    itemMode: z.literal('linked').optional(),
+});

package/dist/schemas/native-runtime-input-schema.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+export declare const n8nNativeInputConfigurationSchema: z.ZodObject<{
+    revision: z.ZodNumber;
+    inputValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+}, z.core.$strict>;

package/dist/schemas/native-runtime-input-schema.js

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+export const n8nNativeInputConfigurationSchema = z.strictObject({
+    revision: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+    inputValues: z.record(z.string(), z.json()).optional(),
+});

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/schemas/template-deployment-selection-schema.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import type { SelectN8nTemplateDeploymentsInput } from '../types/workflow-template.js';
+export declare const templateDeploymentSelectionSchema: z.ZodType<SelectN8nTemplateDeploymentsInput>;

package/dist/schemas/template-deployment-selection-schema.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { n8nTemplateDeploymentsSchema } from './workflow-template-schema.js';
+const documentIds = z
+    .array(z.string().refine((id) => id.trim().length > 0))
+    .refine((ids) => new Set(ids).size === ids.length);
+export const templateDeploymentSelectionSchema = z.strictObject({
+    deployments: n8nTemplateDeploymentsSchema,
+    availableDocumentIds: documentIds,
+    selectedDocumentIds: documentIds,
+});

package/dist/schemas/workflow-input-value-map-schema.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+/** Only the map envelope; each source contract is compiled in its own resource scope. */
+export declare function createWorkflowInputValueMapSchema(slotIds: string[]): z.ZodObject<{
+    [x: string]: z.ZodJSONSchema;
+}, z.core.$strict>;

package/dist/schemas/workflow-input-value-map-schema.js

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+/** Only the map envelope; each source contract is compiled in its own resource scope. */
+export function createWorkflowInputValueMapSchema(slotIds) {
+    return z.strictObject(Object.fromEntries(slotIds.map((id) => [id, z.json()])));
+}

package/dist/schemas/workflow-template-schema.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export declare const n8nTemplateDeploymentsSchema: z.ZodArray<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>;
+    documentId: z.ZodString;
+}, z.core.$strict>>;
+export declare const n8nTemplateInputValuesSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;

package/dist/schemas/workflow-template-schema.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { httpRequestDeploymentOptionsSchema } from './request-deployment-schema.js';
+export const n8nTemplateDeploymentsSchema = z
+    .array(httpRequestDeploymentOptionsSchema.extend({
+    documentId: z.string().refine((value) => value.trim().length > 0),
+}))
+    .refine((items) => new Set(items.map((item) => item.documentId)).size === items.length, {
+    message: 'template.deployments must contain distinct documentIds',
+});
+export const n8nTemplateInputValuesSchema = z.record(z.string(), z.json());

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,46 @@
+import type { z } from 'zod';
+import type { PlannedNativeNode, WorkflowCapability, WorkflowGraphPlan, WorkflowApiMaterial, ApiOperationContract, WorkflowNativeMaterialSources } from '@openapi-flow/core';
+import type { N8nNodeFragment } from './node-fragment.js';
+import type { N8nNativeRuntimeInput, N8nNativeInputConfiguration } from './native-runtime-parameters.js';
+import type { N8nNativeOutputSource } from './output-binding-source.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>;
+    /** Compiler proof from a single Manual Trigger item and item-preserving API paths. Missing/unknown proofs retain ancestry reads. */
+    singletonApiResponseIds?: string[];
+    runtimeInput?: N8nNativeRuntimeInput;
+    /** Names/schemas of actual already-compiled native producers, never guessed from IDs. */
+    nativeOutputSources?: N8nNativeOutputSource[];
+}
+export interface N8nNativeCapability extends WorkflowCapability {
+    bindMaterialContracts?: (sources: WorkflowNativeMaterialSources) => N8nNativeCapability;
+    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[];
+    nativeInputs?: N8nNativeInputConfiguration;
+}
+export type CompileNativeWorkflowNodesInput = Pick<CompilePlannedN8nWorkflowInput, 'plan' | 'apiNodes' | 'capabilities' | 'materials'>;

package/dist/types/native-capability.js

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