@openapi-flow/n8n 0.0.0-stage → 0.3.0

package/dist/types/native-feature-registry.d.ts

@@ -0,0 +1,70 @@
+import type { ApiBindingMaterial } from '@openapi-flow/core';
+import type { CreateJsonOutputCapabilityInput, N8nNativeCapability, NativeItemExecutionOptions } from './native-capability.js';
+import type { N8nNativeOutputSource } from './output-binding-source.js';
+/** Supported OSS feature families, not every built-in node in n8n. */
+export declare const N8nNativeFeature: 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 type N8nNativeFeature = (typeof N8nNativeFeature)[keyof typeof N8nNativeFeature];
+export interface N8nNativeFeatureContext extends NativeItemExecutionOptions {
+    apiMaterials?: ApiBindingMaterial[];
+    nativeOutputSources?: N8nNativeOutputSource[];
+    /** The host owns the literal producer's name and original typed input contract. */
+    jsonOutput?: CreateJsonOutputCapabilityInput;
+}
+export interface ResolveN8nNativeFeaturesInput extends N8nNativeFeatureContext {
+    /** Omitted permits every registered family; [] permits none. */
+    features?: N8nNativeFeature[];
+    /** Explicit host implementations are retained, never inferred or replaced. */
+    extensions?: N8nNativeCapability[];
+}
+export interface ReadyN8nNativeFeature {
+    feature: N8nNativeFeature;
+    status: 'ready';
+    capability: N8nNativeCapability;
+}
+export interface PendingN8nNativeFeature {
+    feature: N8nNativeFeature;
+    status: 'requires-context';
+    missingContext: N8nNativeFeatureContextRequirement[];
+}
+export interface N8nNativeArrayContextRequirement {
+    field: 'apiMaterials' | 'nativeOutputSources';
+    minimumItems: number;
+}
+export interface N8nNativeJsonOutputContextRequirement {
+    field: 'jsonOutput';
+}
+export type N8nNativeFeatureContextRequirement = N8nNativeArrayContextRequirement | N8nNativeJsonOutputContextRequirement;
+export type N8nNativeFeatureRegistration = ReadyN8nNativeFeature | PendingN8nNativeFeature;
+export interface N8nNativeFeatureRegistry {
+    registrations: N8nNativeFeatureRegistration[];
+    /** Only ready registrations and explicitly supplied extensions. */
+    capabilities: N8nNativeCapability[];
+}
+export interface N8nNativePlanningFeatureRegistry extends N8nNativeFeatureRegistry {
+    /** Registered family provenance, separate from arbitrary explicit extensions. */
+    planningRegistrations: N8nNativeFeaturePlanningDefinition[];
+    /** Stable definitions are selectable, but their outputs/ports still require actual contracts. */
+    planningCapabilities: N8nNativeCapability[];
+}
+export interface N8nNativeFeaturePlanningDefinition {
+    feature: N8nNativeFeature;
+    capability: N8nNativeCapability;
+}
+export type N8nNativeFeatureResolutionMode = 'materials' | 'planning';
+export interface N8nNativeFeatureDefinition {
+    requirements: N8nNativeFeatureContextRequirement[];
+    create: (context: N8nNativeFeatureContext) => N8nNativeCapability;
+    createPlanning?: (context: NativeItemExecutionOptions) => N8nNativeCapability;
+}

package/dist/types/native-feature-registry.js

@@ -0,0 +1,14 @@
+/** Supported OSS feature families, not every built-in node in n8n. */
+export const N8nNativeFeature = Object.freeze({
+    If: 'if',
+    MergeAppend: 'merge-append',
+    AssertResponses: 'assert-responses',
+    StopAndError: 'stop-and-error',
+    PassThrough: 'pass-through',
+    RejoinExclusiveBranches: 'rejoin-exclusive-branches',
+    JsonOutput: 'json-output',
+    SplitApiResponseArray: 'split-api-response-array',
+    CollectApiResponses: 'collect-api-responses',
+    SplitNativeOutputArray: 'split-native-output-array',
+    JoinApiItems: 'join-api-items',
+});

package/dist/types/native-material-binding.d.ts

@@ -0,0 +1,56 @@
+import type { NativeOutputContract, ApiBindingMaterial, PlannedNativeNode, WorkflowNativeMaterialSources } from '@openapi-flow/core';
+import type { N8nNativeOutputSource } from './output-binding-source.js';
+import type { NativeItemExecutionOptions } from './native-capability.js';
+import type { N8nNativeCapability } from './native-capability.js';
+import type { N8nNodeFragment } from './node-fragment.js';
+export type NativeRuntimeSourceBinding = {
+    kind: 'provided';
+    sources: N8nNativeOutputSource[];
+} | {
+    kind: 'compiled';
+};
+export interface ResolveNativeRuntimeSourceInput {
+    binding: NativeRuntimeSourceBinding;
+    contract: NativeOutputContract;
+    compiledSources?: N8nNativeOutputSource[];
+    consumerId: string;
+}
+export interface BoundNativeArrayCapabilityInput extends NativeItemExecutionOptions {
+    sources: NativeOutputContract[];
+    runtime: NativeRuntimeSourceBinding;
+}
+export interface BoundItemJoinCapabilityInput {
+    materials: ApiBindingMaterial[];
+    scopes: NativeOutputContract[];
+    runtime: NativeRuntimeSourceBinding;
+}
+export interface ResolveN8nNativeMaterialsInput {
+    apiMaterials: ApiBindingMaterial[];
+    nativeOutputs: NativeOutputContract[];
+    nativeNodes: PlannedNativeNode[];
+    capabilities: N8nNativeCapability[];
+}
+export interface ResolvedN8nNativeMaterials {
+    capabilities: N8nNativeCapability[];
+    outputs: NativeOutputContract[];
+}
+export interface CompileNativeMaterialFragmentsInput {
+    nativeNodes: PlannedNativeNode[];
+    materials: ResolvedN8nNativeMaterials;
+    apiMaterials: ApiBindingMaterial[];
+    apiNodeNames: Record<string, string>;
+    singletonApiResponseIds?: string[];
+    externalNativeOutputSources: N8nNativeOutputSource[];
+    nodeIds: string[];
+}
+export interface CompiledNativeMaterialFragments {
+    fragments: N8nNodeFragment[];
+    outputSources: N8nNativeOutputSource[];
+}
+export interface MaterialBindableN8nCapability extends N8nNativeCapability {
+    bindMaterialContracts: NonNullable<N8nNativeCapability['bindMaterialContracts']>;
+}
+export interface MaterialBoundN8nCapability extends MaterialBindableN8nCapability {
+    materialSources: WorkflowNativeMaterialSources;
+}
+export type NativeMaterialFeatureDefinition = Pick<N8nNativeCapability, 'name' | 'description' | 'parametersSchema' | 'parameterReferenceSources' | 'referenceStructureSchema' | 'parameterReferenceBindings' | 'waitsForAllInputs' | 'exclusiveOutputPorts' | 'materialRequirements' | 'inputPorts' | 'outputPorts'>;

package/dist/types/native-material-binding.js

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

package/dist/types/native-runtime-parameters.d.ts

@@ -0,0 +1,55 @@
+import type { NativeRuntimeParameterMaterialization, NativeRuntimeInputSlot, NativeRuntimeInputValues, PlannedNativeNode, ApiBindingMaterial, NativeOutputContract } from '@openapi-flow/core';
+import type { N8nTemplateInputSlotMapping } from './workflow-template.js';
+import type { BuildN8nWorkflowInput, N8nWorkflowJSON } from './workflow-compilation.js';
+import type { CompileNativeNodeInput, N8nNativeCapability } from './native-capability.js';
+import type { N8nNodeFragment } from './node-fragment.js';
+export interface N8nNativeRuntimeInput {
+    materialization: NativeRuntimeParameterMaterialization;
+    revision: number;
+    inputNodeName: string;
+}
+export interface PrependNativeParameterGuardInput {
+    input: CompileNativeNodeInput;
+    capability: N8nNativeCapability;
+    fragment: N8nNodeFragment;
+}
+export interface N8nNativeInputConfiguration {
+    revision: number;
+    /** Omission leaves actual execution values absent; no dummy values are generated. */
+    inputValues?: NativeRuntimeInputValues;
+}
+export type N8nNativeInputSlot = NativeRuntimeInputSlot & N8nTemplateInputSlotMapping;
+export interface N8nNativeInputTemplate {
+    revision: number;
+    inputsReady: boolean;
+    inputSlots: N8nNativeInputSlot[];
+    guide: string;
+}
+export interface PrepareNativeRuntimeInputsInput {
+    nativeNodes: PlannedNativeNode[];
+    capabilities: N8nNativeCapability[];
+    apiMaterials: ApiBindingMaterial[];
+    nativeOutputs: NativeOutputContract[];
+    nativeInputs?: N8nNativeInputConfiguration;
+}
+export interface PreparedNativeRuntimeInputs {
+    revision: number;
+    inputValues: NativeRuntimeInputValues;
+    inputsReady: boolean;
+    slots: NativeRuntimeInputSlot[];
+    nativeParameters: NativeRuntimeParameterMaterialization[];
+    capabilities: N8nNativeCapability[];
+}
+export interface CreateRuntimeInputNativeCapabilitiesInput {
+    capabilities: N8nNativeCapability[];
+    slots: NativeRuntimeInputSlot[];
+    revision: number;
+    inputNodeName: string;
+}
+export interface AssembleNativeRuntimeInputsInput extends BuildN8nWorkflowInput {
+    nativeInputs: PreparedNativeRuntimeInputs;
+}
+export interface N8nNativeInputCompilationResult {
+    workflow: N8nWorkflowJSON;
+    nativeInputTemplate: N8nNativeInputTemplate;
+}

package/dist/types/native-runtime-parameters.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,27 @@
+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';
+import type { N8nNativeInputConfiguration } from './native-runtime-parameters.js';
+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>;
+    apiResponseContracts?: Record<string, ApiOperationContract>;
+    /** Actual SDK output sources outside this explicitly supplied native subset. */
+    externalNativeOutputSources?: N8nNativeOutputSource[];
+    nativeInputs?: N8nNativeInputConfiguration;
+}

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

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

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,30 @@
+import type { ApiCallArguments, ApiOperationContract, JsonValue } from '@openapi-flow/core';
+import type { Operation } from '@openapi-flow/core/internal';
+import type { DeferredApiInputSlot } from '@openapi-flow/core';
+import type { PreparedRequestBody, RequestHeader } from './legacy/request-node.js';
+export interface RequestMaterializationConfig {
+    contract: ApiOperationContract;
+    operation: Operation;
+    arguments: RequestMaterializationArguments;
+    templateUrl: string;
+    deferredInputs?: DeferredRequestRuntimeInputs;
+}
+export type RequestMaterializationArguments = Pick<ApiCallArguments, 'callId' | 'values' | 'bindings' | 'unresolvedInputs' | 'requestMediaType' | 'requestedInputs'>;
+export interface DeferredRequestRuntimeInputs {
+    revision: number;
+    inputNodeName: string;
+    slots: DeferredApiInputSlot[];
+}
+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/request-node-configuration.d.ts

@@ -0,0 +1,13 @@
+import type { CreateBoundHttpRequestNodeInput, N8nNodeFragment } from './node-fragment.js';
+import type { RequestMaterializationConfig } from './request-materialization.js';
+import type { ResolvedHttpRequestDeployment } from './request-deployment.js';
+export interface ResolveHttpRequestNodeConfigurationResult {
+    input: CreateBoundHttpRequestNodeInput;
+    config: RequestMaterializationConfig;
+}
+export interface FinalizeHttpRequestFragmentInput {
+    fragment: N8nNodeFragment;
+    method: string;
+    documentId: string;
+    deployment: ResolvedHttpRequestDeployment;
+}

package/dist/types/request-node-configuration.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' | 'singletonApiResponseIds'> {
+    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,29 @@
+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';
+import type { N8nNativeInputConfiguration } from './native-runtime-parameters.js';
+export interface CompileReviewableN8nWorkflowInput {
+    id: string;
+    name: string;
+    plan: ReviewableWorkflowGraphPlan;
+    materials: ReviewableWorkflowApiMaterial[];
+    apiNodes: N8nNodeFragment[];
+    capabilities: N8nNativeCapability[];
+    nativeInputs?: N8nNativeInputConfiguration;
+}
+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,39 @@
+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';
+import type { N8nNativeInputTemplate } from './native-runtime-parameters.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;
+    nativeInputTemplate?: N8nNativeInputTemplate;
+}
+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[];
+    nativeInputTemplate?: N8nNativeInputTemplate;
+}
+export type N8nWorkflowResult = N8nCompileResult | N8nNeedsReviewResult;

package/dist/types/workflow-compilation.js

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

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

@@ -0,0 +1,121 @@
+import type { WorkflowDraft, WorkflowDraftContext, WorkflowDraftReadiness, DeferredApiInputSlot, DeferredApiInputValues, WorkflowApiMaterial, WorkflowGraphPlan, ApiOperationContract, NativeRuntimeInputSlot, WorkflowRuntimeInputSlot, NativeRuntimeParameterMaterialization, WorkflowDraftCapabilityGap } from '@openapi-flow/core';
+import type { N8nNativeCapability } from './native-capability.js';
+import type { N8nNodeFragment } from './node-fragment.js';
+import type { HttpRequestDeploymentOptions } from './request-deployment.js';
+import type { RequestMaterializationConfig } from './request-materialization.js';
+import type { N8nWorkflowJSON } from './workflow-compilation.js';
+export interface N8nTemplateDeployment extends HttpRequestDeploymentOptions {
+    documentId: string;
+}
+export interface SelectN8nTemplateDeploymentsInput {
+    deployments: N8nTemplateDeployment[];
+    availableDocumentIds: string[];
+    selectedDocumentIds: string[];
+}
+export interface N8nTemplateContext extends Omit<WorkflowDraftContext, 'capabilities'> {
+    capabilities: N8nNativeCapability[];
+}
+export interface CompileN8nWorkflowTemplateInput {
+    draft: WorkflowDraft;
+    context: N8nTemplateContext;
+    name: string;
+    /** Resolve each request's declared references by actual n8n item ancestry. */
+    itemMode?: 'linked';
+    deployments?: N8nTemplateDeployment[];
+    /** Only explicit actual values; omission means no supplied runtime values. */
+    inputValues?: DeferredApiInputValues;
+}
+export interface N8nTemplateNodeMappingBase {
+    nodeId: string;
+    sdkNodeIds: string[];
+    entryNodeName: string;
+    exitNodeName: string;
+}
+export interface N8nTemplateApiNodeMapping extends N8nTemplateNodeMappingBase {
+    kind: 'api';
+    operation: N8nTemplateOperationMapping;
+}
+export interface N8nTemplateOperationMapping extends Pick<ApiOperationContract, 'key' | 'method' | 'path'> {
+    summary?: string;
+}
+export interface N8nTemplateNativeNodeMapping extends N8nTemplateNodeMappingBase {
+    kind: 'native';
+    capability: string;
+}
+export type N8nTemplateNodeMapping = N8nTemplateApiNodeMapping | N8nTemplateNativeNodeMapping | N8nTemplateGapNodeMapping;
+export interface N8nTemplateGapNodeMapping extends N8nTemplateNodeMappingBase {
+    kind: 'capability-gap';
+    gap: WorkflowDraftCapabilityGap;
+    inventoryCurrent: boolean;
+}
+export interface N8nTemplateInputSlotMapping {
+    editNodeId: string;
+    editNodeName: string;
+    editParameter: 'jsCode';
+    materializerNodeName: string;
+}
+export type N8nTemplateInputSlot = WorkflowRuntimeInputSlot & N8nTemplateInputSlotMapping;
+export interface N8nTemplateDeploymentRequirement {
+    callId: string;
+    documentId: string;
+    fields: string[];
+    materializerNodeName: string;
+    requestNodeName: string;
+}
+export interface N8nWorkflowTemplateResult {
+    revision: number;
+    workflow: N8nWorkflowJSON;
+    /** Canonical draft state, separate from supplied execution-time values. */
+    draftReadiness: WorkflowDraftReadiness;
+    requestInputsReady: boolean;
+    nativeInputsReady: boolean;
+    runtimeInputsReady: boolean;
+    /** References supplied, not proof of access to the user's n8n credentials. */
+    deploymentConfigured: boolean;
+    triggerConnected: boolean;
+    inputSlots: N8nTemplateInputSlot[];
+    deploymentRequirements: N8nTemplateDeploymentRequirement[];
+    nodeMappings: N8nTemplateNodeMapping[];
+    guide: string;
+}
+export interface CreateTemplateInputNodesInput {
+    revision: number;
+    slots: WorkflowRuntimeInputSlot[];
+    inputValues: DeferredApiInputValues;
+    requests: RequestMaterializationConfig[];
+    nativeParameters: NativeRuntimeParameterMaterialization[];
+}
+export interface CreateTemplateGuideInput {
+    draft: WorkflowDraft;
+    readiness: WorkflowDraftReadiness;
+    slots: N8nTemplateInputSlot[];
+    mappings: N8nTemplateNodeMapping[];
+    deploymentRequirements: N8nTemplateDeploymentRequirement[];
+    requestInputsReady: boolean;
+    nativeInputsReady: boolean;
+    triggerConnected: boolean;
+}
+export interface PrepareTemplateApiFragmentsInput {
+    template: CompileN8nWorkflowTemplateInput;
+    /** Runtime-bound compilers, separate from original planning/evidence context. */
+    capabilities: N8nNativeCapability[];
+    materials: WorkflowApiMaterial[];
+    slots: DeferredApiInputSlot[];
+    plan: WorkflowGraphPlan;
+}
+export interface PreparedTemplateApiFragments {
+    apiNodes: N8nNodeFragment[];
+    requests: RequestMaterializationConfig[];
+    deploymentRequirements: N8nTemplateDeploymentRequirement[];
+}
+export interface CreateTemplateArtifactMappingInput {
+    context: WorkflowDraftContext;
+    draft: WorkflowDraft;
+    materials: WorkflowApiMaterial[];
+    fragments: N8nNodeFragment[];
+    slots: (DeferredApiInputSlot | NativeRuntimeInputSlot)[];
+}
+export interface TemplateArtifactMapping {
+    mappings: N8nTemplateNodeMapping[];
+    inputSlots: N8nTemplateInputSlot[];
+}

package/dist/types/workflow-template.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;