@fluidgrids/workflows 0.0.0-stage → 2026.1027.0

package/dist/assemble-BJo9TECS.d.cts

@@ -0,0 +1,569 @@
+import { J as Json, a as JsonObject, m as WorkflowNode, l as WorkflowEdge, d as ConnectionRef, L as LegacyCredentialRef, R as RetryConfig, g as NodeTimeout, f as NodeErrorConfig, e as ExecutionSettings, k as WorkflowConfig, b as WorkflowInterface, j as WorkflowCode, P as Position, i as WorkflowAuthoring, W as WorkflowDefinition } from './types-Dr2Fn1Ax.cjs';
+
+/**
+ * Node operation descriptors: what a builder call needs to know about the node
+ * it emits. Generated clients (`.fluidgrids/nodes.ts`) are lists of these;
+ * the built-in internal nodes and triggers ship here so `nodes.internal.*` and
+ * `triggers.*` work without a registry.
+ */
+
+/** A file reference in node inputs and outputs. */
+interface FileRef {
+    fileId: string;
+    name?: string;
+    mimeType?: string;
+    size?: number;
+}
+declare const OPERATION_TYPES: unique symbol;
+/** One node operation. `In` and `Out` type the arguments and the output. */
+interface Operation<In = Record<string, Json>, Out = Json> {
+    readonly kind: 'operation';
+    readonly nodeType: string;
+    /** Written as the node's `version` unless the call overrides it. */
+    readonly version?: string;
+    /** Written as the node's `operation_name` unless the call overrides it. */
+    readonly operation?: string;
+    readonly role?: 'trigger';
+    /** Type-level only; never present at run time. */
+    readonly [OPERATION_TYPES]?: {
+        input: In;
+        output: Out;
+    };
+}
+/** A trigger operation. */
+type TriggerOperation<In = Record<string, Json>, Out = Json> = Operation<In, Out> & {
+    readonly role: 'trigger';
+};
+/** Describe a node operation (generated clients call this). */
+declare function op<In = Record<string, Json>, Out = Json>(nodeType: string, version?: string, operation?: string): Operation<In, Out>;
+/** Describe a trigger operation (generated clients call this). */
+declare function trigger<In = Record<string, Json>, Out = Json>(nodeType: string, version?: string, operation?: string): TriggerOperation<In, Out>;
+/** True for a value made by {@link op} or {@link trigger}. */
+declare function isOperation(value: unknown): value is Operation<unknown, unknown>;
+/** Built-in trigger nodes (`wspace-workflow-svc` `triggers/manifests`). */
+declare const triggers: {
+    readonly api: TriggerOperation<Record<string, Json>, Json>;
+    readonly manual: TriggerOperation<Record<string, Json>, Json>;
+    readonly schedule: TriggerOperation<Record<string, Json>, Json>;
+    readonly webhook: TriggerOperation<Record<string, Json>, Json>;
+    readonly form: TriggerOperation<Record<string, Json>, Json>;
+    readonly errorTrigger: TriggerOperation<Record<string, Json>, Json>;
+    readonly workflowCall: TriggerOperation<Record<string, Json>, Json>;
+    readonly rssFeed: TriggerOperation<Record<string, Json>, Json>;
+    readonly httpPoll: TriggerOperation<Record<string, Json>, Json>;
+    readonly databasePoll: TriggerOperation<Record<string, Json>, Json>;
+    readonly emailImap: TriggerOperation<Record<string, Json>, Json>;
+    readonly fileUpload: TriggerOperation<Record<string, Json>, Json>;
+    readonly recordChange: TriggerOperation<Record<string, Json>, Json>;
+    readonly stateChange: TriggerOperation<Record<string, Json>, Json>;
+};
+/** Built-in internal nodes (`wspace-workflow-svc` `internalnodes/manifests`, plus the two IR v2 nodes). */
+declare const internalNodes: {
+    readonly merge: Operation<Record<string, Json>, Json>;
+    readonly if: Operation<Record<string, Json>, Json>;
+    readonly switch: Operation<Record<string, Json>, Json>;
+    readonly loop: Operation<Record<string, Json>, Json>;
+    readonly set: Operation<Record<string, Json>, Json>;
+    readonly filter: Operation<Record<string, Json>, Json>;
+    readonly aggregate: Operation<Record<string, Json>, Json>;
+    readonly wait: Operation<Record<string, Json>, Json>;
+    readonly noop: Operation<Record<string, Json>, Json>;
+    readonly code: Operation<Record<string, Json>, Json>;
+    readonly http: Operation<Record<string, Json>, Json>;
+    readonly transform: Operation<Record<string, Json>, Json>;
+    readonly validate: Operation<Record<string, Json>, Json>;
+    readonly log: Operation<Record<string, Json>, Json>;
+    readonly error: Operation<Record<string, Json>, Json>;
+    readonly subworkflow: Operation<Record<string, Json>, Json>;
+    readonly compareDatasets: Operation<Record<string, Json>, Json>;
+    readonly splitOut: Operation<Record<string, Json>, Json>;
+    readonly limit: Operation<Record<string, Json>, Json>;
+    readonly dedupe: Operation<Record<string, Json>, Json>;
+    readonly sort: Operation<Record<string, Json>, Json>;
+    readonly dataTable: Operation<Record<string, Json>, Json>;
+    readonly respondToWebhook: Operation<Record<string, Json>, Json>;
+    readonly sendAndWait: Operation<Record<string, Json>, Json>;
+    readonly codeWorkflow: Operation<Record<string, Json>, Json>;
+    readonly waitForSignal: Operation<Record<string, Json>, Json>;
+};
+/** Node clients that need no registry: the internal nodes and `custom()`. */
+declare const nodes: {
+    readonly internal: {
+        readonly merge: Operation<Record<string, Json>, Json>;
+        readonly if: Operation<Record<string, Json>, Json>;
+        readonly switch: Operation<Record<string, Json>, Json>;
+        readonly loop: Operation<Record<string, Json>, Json>;
+        readonly set: Operation<Record<string, Json>, Json>;
+        readonly filter: Operation<Record<string, Json>, Json>;
+        readonly aggregate: Operation<Record<string, Json>, Json>;
+        readonly wait: Operation<Record<string, Json>, Json>;
+        readonly noop: Operation<Record<string, Json>, Json>;
+        readonly code: Operation<Record<string, Json>, Json>;
+        readonly http: Operation<Record<string, Json>, Json>;
+        readonly transform: Operation<Record<string, Json>, Json>;
+        readonly validate: Operation<Record<string, Json>, Json>;
+        readonly log: Operation<Record<string, Json>, Json>;
+        readonly error: Operation<Record<string, Json>, Json>;
+        readonly subworkflow: Operation<Record<string, Json>, Json>;
+        readonly compareDatasets: Operation<Record<string, Json>, Json>;
+        readonly splitOut: Operation<Record<string, Json>, Json>;
+        readonly limit: Operation<Record<string, Json>, Json>;
+        readonly dedupe: Operation<Record<string, Json>, Json>;
+        readonly sort: Operation<Record<string, Json>, Json>;
+        readonly dataTable: Operation<Record<string, Json>, Json>;
+        readonly respondToWebhook: Operation<Record<string, Json>, Json>;
+        readonly sendAndWait: Operation<Record<string, Json>, Json>;
+        readonly codeWorkflow: Operation<Record<string, Json>, Json>;
+        readonly waitForSignal: Operation<Record<string, Json>, Json>;
+    };
+    /**
+     * Any node type, including ones the registry snapshot does not know. Typed
+     * as JSON in and out.
+     */
+    readonly custom: (nodeType: string, operation?: string, version?: string) => Operation<Record<string, Json>, Json>;
+};
+
+/**
+ * Typed references and predicates for the tier-1 builder (spec 02 §3).
+ *
+ * A reference is a proxy that records a path. Reading a property extends the
+ * path; using the reference as an argument value lowers it to
+ * `{{ $node["<id>"].item.<path> }}` (or `$json`, `$vars`, `$now`,
+ * `$execution`). Calling one of the comparison methods (`gte`, `eq`, …) turns
+ * the path before the method name into a condition rule for `internal:if`.
+ */
+
+declare const PREDICATE: unique symbol;
+/** A literal a condition rule can compare against. */
+type RuleValue = string | number | boolean | null;
+/** One rule of a condition tree, as `internal:if` evaluates it. */
+interface ConditionRule {
+    type: 'rule';
+    field: string;
+    operator: string;
+    value?: RuleValue;
+}
+/** A group of rules. */
+interface ConditionGroup {
+    type: 'group';
+    combinator: 'AND' | 'OR';
+    children: Array<ConditionRule | ConditionGroup>;
+}
+/** A typed condition: one rule or a group built with {@link and} / {@link or}. */
+interface Predicate {
+    readonly [PREDICATE]: ConditionRule | ConditionGroup;
+}
+/** The comparison methods every reference has. */
+interface PredicateMethods {
+    eq(value: RuleValue): Predicate;
+    neq(value: RuleValue): Predicate;
+    gt(value: RuleValue): Predicate;
+    gte(value: RuleValue): Predicate;
+    lt(value: RuleValue): Predicate;
+    lte(value: RuleValue): Predicate;
+    contains(value: RuleValue): Predicate;
+    notContains(value: RuleValue): Predicate;
+    startsWith(value: RuleValue): Predicate;
+    endsWith(value: RuleValue): Predicate;
+    matches(pattern: string): Predicate;
+    hasProperty(name: string): Predicate;
+    isEmpty(): Predicate;
+    isNotEmpty(): Predicate;
+    isNull(): Predicate;
+    isNotNull(): Predicate;
+    isTrue(): Predicate;
+    isFalse(): Predicate;
+    /** Any operator the condition tree evaluates, with or without a value. */
+    is(operator: string, value?: RuleValue): Predicate;
+}
+/** A reference to a value of unknown shape. Any property is another reference. */
+type AnyRef = {
+    readonly [key: string]: AnyRef;
+} & PredicateMethods;
+/** A reference typed by the shape of the value it points at. */
+type OutputRef<T> = AnyRef & (T extends readonly unknown[] ? {
+    readonly [index: number]: OutputRef<T[number]>;
+} : T extends object ? {
+    readonly [K in keyof T]-?: OutputRef<T[K]>;
+} : unknown);
+/**
+ * The operator each method writes. These are the operators the builder's
+ * condition editor writes (`fluidgrids-fe-sdk` `condition-builder.tsx`), so a
+ * typed condition and one made on the canvas are the same tree.
+ */
+declare const PREDICATE_OPERATORS: Readonly<Record<string, {
+    operator: string;
+    unary: boolean;
+}>>;
+declare class BuilderError extends Error {
+    constructor(message: string);
+}
+/** All conditions must hold. */
+declare function and(...predicates: Predicate[]): Predicate;
+/** At least one condition must hold. */
+declare function or(...predicates: Predicate[]): Predicate;
+/**
+ * Tagged template for strings with references:
+ * `` expr`New lead: ${enrich.output.person.fullName}` `` lowers to
+ * `"New lead: {{ $node[\"enrich\"].item.person.fullName }}"`. Interpolated
+ * strings and numbers are inserted as they are.
+ */
+declare function expr(strings: TemplateStringsArray, ...values: unknown[]): string;
+
+declare const RECORDING_FORMAT = "fluidgrids.tier1-recording";
+declare const RECORDING_FORMAT_VERSION = 1;
+declare const WORKFLOW_MARKER = "fluidgrids.tier1-workflow";
+/** A handle on a node: an output port that edges leave from. */
+interface HandleRef {
+    readonly kind: 'handle';
+    readonly nodeId: string;
+    readonly handle: string;
+}
+/** What `wf.*` returns for a node. */
+interface NodeRef<Out = Json> {
+    readonly kind: 'node';
+    readonly id: string;
+    /** The node's output, as a typed reference. */
+    readonly output: OutputRef<Out>;
+    /** One of the node's output handles. */
+    handle(name: string): HandleRef;
+}
+/** An `internal:if` node. */
+interface IfRef extends NodeRef {
+    readonly true: HandleRef;
+    readonly false: HandleRef;
+}
+/** An `internal:switch` node. */
+interface SwitchRef extends NodeRef {
+    case(handle: string): HandleRef;
+    readonly default: HandleRef;
+}
+/** An `internal:loop` node. */
+interface LoopRef extends NodeRef {
+    /** The `loop` handle: each batch leaves here. */
+    readonly body: HandleRef;
+    /** The `done` handle: leaves once every batch is processed. */
+    readonly done: HandleRef;
+}
+/** An `internal:validate` node. */
+interface ValidateRef extends NodeRef {
+    readonly valid: HandleRef;
+    readonly invalid: HandleRef;
+}
+/** An `internal:send-and-wait` node. */
+interface ApprovalRef extends NodeRef {
+    readonly approved: HandleRef;
+    readonly declined: HandleRef;
+    readonly timedOut: HandleRef;
+}
+/** An `internal:wait-for-signal` node. */
+interface SignalWaitRef extends NodeRef {
+    readonly received: HandleRef;
+    readonly timedOut: HandleRef;
+}
+/** An `internal:compare-datasets` node. */
+interface CompareRef extends NodeRef {
+    readonly inAOnly: HandleRef;
+    readonly inBOnly: HandleRef;
+    readonly same: HandleRef;
+    readonly different: HandleRef;
+}
+/** Options of an explicit edge, made with {@link edge}. */
+interface EdgeOptions {
+    /** Edge id. Default: `e-<source>-<target>[-<sourceHandle>][-<targetHandle>]`; `false` writes none. */
+    id?: string | false;
+    /** Edge type. Default `deletable` (what the canvas writes); `false` writes none. */
+    type?: string | false;
+    targetHandle?: string;
+    label?: string;
+    data?: JsonObject;
+    /** Legacy `${…}` edge mapping, kept verbatim. */
+    mapping?: JsonObject;
+    /** Other edge fields, copied verbatim. */
+    extra?: JsonObject;
+}
+/** Where an edge starts: a node, a handle, or a node id (for nodes declared later). */
+type EdgeSource = NodeRef<unknown> | HandleRef | string;
+/** An incoming edge with options. */
+interface EdgeSpec extends EdgeOptions {
+    readonly kind: 'edge';
+    readonly from: EdgeSource;
+}
+/** One entry of `after`. */
+type AfterInput = EdgeSource | EdgeSpec;
+/** An incoming edge with options: `after: [edge(prev, { id: 'e1' })]`. */
+declare function edge(from: EdgeSource, options?: EdgeOptions): EdgeSpec;
+/** A value a node argument can hold: JSON, references and nested structures of them. */
+type ArgValue = string | number | boolean | null | AnyRef | readonly ArgValue[] | {
+    readonly [key: string]: ArgValue;
+};
+/** Arguments typed by the operation input, open to further keys. */
+type ArgsOf<In> = {
+    [K in keyof In]: In[K] | AnyRef | ArgValue;
+} & {
+    readonly [key: string]: ArgValue;
+};
+/** Error routing sugar: `stop`, `continue`, or a branch to a node id. */
+type OnErrorOption = 'stop' | 'continue' | {
+    branch: string;
+};
+/** Options every node method accepts. */
+interface NodeOptions<In = Record<string, Json>> {
+    /** Node id. Required (stable ids keep layout and pinned data across builds). */
+    id?: string;
+    label?: string;
+    after?: AfterInput | readonly AfterInput[];
+    args?: ArgsOf<In>;
+    /** `operation_name` override; `false` writes none. */
+    operation?: string | false;
+    /** Node package `version` override; `false` writes none. */
+    version?: string | false;
+    /** Connection name(s), resolved to connection ids at push time. */
+    connection?: string | readonly string[];
+    /** Connection references by id, written as they are. */
+    connections?: readonly ConnectionRef[];
+    /** Legacy credential references (`args.credentials`), written as they are. */
+    credentials?: readonly LegacyCredentialRef[];
+    /** `args.context`, written as it is. */
+    context?: JsonObject;
+    retry?: RetryConfig;
+    timeout?: NodeTimeout;
+    onError?: OnErrorOption;
+    /** The whole error policy, written as it is (instead of retry / timeout / onError). */
+    errorConfig?: NodeErrorConfig;
+    executionSettings?: ExecutionSettings;
+    disabled?: boolean;
+    /** Other node fields, deep-merged into the node verbatim. */
+    extra?: JsonObject;
+}
+/** Options of {@link defineWorkflow}. */
+interface WorkflowOptions {
+    key: string;
+    name?: string;
+    description?: string;
+    config?: WorkflowConfig;
+    interface?: WorkflowInterface;
+    code?: WorkflowCode;
+    tags?: readonly Json[];
+    meta?: JsonObject;
+    /** Derive missing node ids from labels (quick scripts only; `validate --strict` rejects pushes made this way). */
+    autoIds?: boolean;
+    /** Other top-level fields, deep-merged into the document verbatim. */
+    extra?: JsonObject;
+}
+/** A sticky note. */
+interface NoteOptions {
+    id: string;
+    color?: string;
+    /** Place the note above this node. */
+    near?: NodeRef<unknown> | string;
+}
+/** One node in a recording. */
+interface RecordedNode {
+    node: WorkflowNode;
+    connectionNames?: string[];
+}
+/** One sticky note in a recording, placed at assembly. */
+interface RecordedNote {
+    note: JsonObject;
+    near?: string;
+}
+/** Everything a `defineWorkflow` callback recorded. Plain JSON. */
+interface Tier1Recording {
+    format: typeof RECORDING_FORMAT;
+    formatVersion: typeof RECORDING_FORMAT_VERSION;
+    key: string;
+    document: JsonObject;
+    nodes: RecordedNode[];
+    edges: WorkflowEdge[];
+    edgeOrder?: Array<string | number>;
+    notes: RecordedNote[];
+}
+/** The value `defineWorkflow` returns. */
+interface Tier1Workflow {
+    readonly __fluidgrids: typeof WORKFLOW_MARKER;
+    readonly key: string;
+    readonly recording: Tier1Recording;
+}
+/** True for a value returned by {@link defineWorkflow}. */
+declare function isTier1Workflow(value: unknown): value is Tier1Workflow;
+/** Default edge id, the scheme the AI draft generator uses. */
+declare function defaultEdgeId(source: string, target: string, sourceHandle?: string, targetHandle?: string): string;
+/** Options of `wf.if`. */
+interface IfOptions extends NodeOptions {
+    /** A typed condition (→ `conditionTree`) or a JavaScript condition string (→ `condition`). */
+    condition?: Predicate | string;
+}
+/** Options of `wf.switch`. */
+interface SwitchOptions extends NodeOptions {
+    /** `switchValue`. */
+    value?: ArgValue;
+    /** `cases`: case value → handle id. */
+    cases?: Readonly<Record<string, string>>;
+}
+/** Options of `wf.loop`. */
+interface LoopOptions extends NodeOptions {
+    /** `sourceArray`. */
+    items?: ArgValue;
+    batchSize?: number;
+}
+/** Options of `wf.merge`. */
+interface MergeOptions extends NodeOptions {
+    /** Branches in order; each enters on `input-<n>`. */
+    inputs?: readonly EdgeSource[];
+    mode?: 'append' | 'combine' | 'multiplex' | 'keepSeparate' | 'chooseBranch' | string;
+}
+/** Options of `wf.waitForSignal`. */
+interface WaitForSignalOptions extends NodeOptions {
+    /** `signalName`. */
+    name?: string;
+    /** `limitWait` as `{ amount, unit }`, or a duration such as `'2d'`. */
+    limit?: string | {
+        amount: number;
+        unit: string;
+    };
+}
+/** Options of `wf.subworkflow`. */
+interface SubworkflowOptions extends NodeOptions {
+    /** `workflowKey`. */
+    key?: string;
+    /** The child workflow version (`args.state.version`), distinct from the node package `version`. */
+    targetVersion?: string;
+    /** `inputMapping`. */
+    input?: ArgValue;
+}
+/** The recording builder passed to the `defineWorkflow` callback. */
+declare class WorkflowBuilder {
+    private readonly autoIds;
+    /** `$json`: the current item's JSON. */
+    readonly json: AnyRef;
+    /** `$vars`: workflow variables. */
+    readonly vars: AnyRef;
+    /** `$now`. */
+    readonly now: AnyRef;
+    /** `$execution`: run metadata. */
+    readonly execution: AnyRef;
+    private readonly nodes;
+    private readonly edges;
+    private readonly notes;
+    private readonly ids;
+    private readonly edgeIds;
+    private edgeOrder;
+    constructor(autoIds: boolean);
+    /** A reference to a node by id, for nodes declared later in the source. */
+    ref(id: string): NodeRef;
+    /** A trigger node. */
+    trigger<In, Out>(operation: Operation<In, Out>, options?: NodeOptions<NoInfer<In>>): NodeRef<Out>;
+    /** A store or internal node. */
+    step<In, Out>(operation: Operation<In, Out>, options?: NodeOptions<NoInfer<In>>): NodeRef<Out>;
+    /** `internal:if`. */
+    if(options: IfOptions): IfRef;
+    /** `internal:switch`. */
+    switch(options: SwitchOptions): SwitchRef;
+    /**
+     * `internal:loop`. With a body callback, the nodes the callback declares
+     * after `batch` form the loop body and the builder adds the return edge from
+     * the node the callback returns.
+     */
+    loop(options: LoopOptions, body?: (batch: HandleRef) => EdgeSource | undefined): LoopRef;
+    /** `internal:merge`. */
+    merge(options: MergeOptions): NodeRef;
+    /** `internal:wait`. */
+    wait(options: NodeOptions): NodeRef;
+    /** `internal:wait-for-signal` (IR v2). */
+    waitForSignal(options: WaitForSignalOptions): SignalWaitRef;
+    /** `internal:send-and-wait`. */
+    sendAndWait(options: NodeOptions): ApprovalRef;
+    /** `internal:subworkflow`. */
+    subworkflow(options: SubworkflowOptions): NodeRef;
+    /** `internal:validate`. */
+    validate(options: NodeOptions): ValidateRef;
+    /** `internal:compare-datasets`. */
+    compareDatasets(options: NodeOptions): CompareRef;
+    /** `internal:set`. */
+    set(options: NodeOptions): NodeRef;
+    /** `internal:filter`. */
+    filter(options: NodeOptions): NodeRef;
+    /** `internal:aggregate`. */
+    aggregate(options: NodeOptions): NodeRef;
+    /** `internal:split-out`. */
+    splitOut(options: NodeOptions): NodeRef;
+    /** `internal:limit`. */
+    limit(options: NodeOptions): NodeRef;
+    /** `internal:dedupe`. */
+    dedupe(options: NodeOptions): NodeRef;
+    /** `internal:sort`. */
+    sort(options: NodeOptions): NodeRef;
+    /** `internal:datatable`. */
+    dataTable(options: NodeOptions): NodeRef;
+    /** `internal:http`. */
+    http(options: NodeOptions): NodeRef;
+    /** `internal:code`. The code is a string (`args.code`), so it round-trips byte for byte. */
+    code(options: NodeOptions): NodeRef;
+    /** `internal:transform`. */
+    transform(options: NodeOptions): NodeRef;
+    /** `internal:log`. */
+    log(options: NodeOptions): NodeRef;
+    /** `internal:respond-to-webhook`. */
+    respondToWebhook(options: NodeOptions): NodeRef;
+    /** `internal:error` (stop and error). */
+    stopAndError(options: NodeOptions): NodeRef;
+    /** `internal:noop`. */
+    noop(options: NodeOptions): NodeRef;
+    /** A sticky note on the canvas. */
+    note(content: string, options: NoteOptions): void;
+    /** An edge added outside `after`, for example a loop's return edge. */
+    connect(from: EdgeSource, to: NodeRef<unknown> | string, options?: EdgeOptions): void;
+    /**
+     * Put `data.edges` in this exact order. Each entry names one edge, by id or,
+     * for an edge without an id, by its position in declaration order; every edge
+     * appears once. The lifter emits this when a stored definition's edge order
+     * differs from the order the code declares its edges in.
+     */
+    edgeOrderIs(order: ReadonlyArray<string | number>): void;
+    /** The recording, once the callback has returned. */
+    finish(key: string, document: JsonObject): Tier1Recording;
+    private claimId;
+    private resolveId;
+    private addEdge;
+    private add;
+}
+/** Define a tier-1 workflow. The callback runs once, immediately. */
+declare function defineWorkflow(options: WorkflowOptions, build: (wf: WorkflowBuilder) => void): Tier1Workflow;
+
+declare const LAYOUT_FORMAT = "fluidgrids.layout";
+declare const LAYOUT_FORMAT_VERSION = 1;
+/**
+ * The layout sidecar (`workflows/<key>.layout.json`): canvas positions, sticky
+ * notes and `meta.layout`, kept out of the code so it stays readable.
+ */
+interface LayoutSidecar {
+    format: typeof LAYOUT_FORMAT;
+    formatVersion: typeof LAYOUT_FORMAT_VERSION;
+    positions: Record<string, Position>;
+    stickyNotes?: JsonObject[];
+    metaLayout?: JsonObject;
+}
+/** How connection names in code resolve to connection references. */
+type ConnectionResolver = Readonly<Record<string, ConnectionRef>> | ((name: string) => ConnectionRef | undefined);
+interface AssembleOptions {
+    layout?: LayoutSidecar;
+    connections?: ConnectionResolver;
+    /** TEST-only pinned data (`workflows/<key>.pinned.json`). */
+    pinnedData?: JsonObject;
+    /** Provenance; defaults to `{ mode: 'canvas', generator: 'sdk-ts', generatorVersion }`. */
+    authoring?: WorkflowAuthoring;
+}
+/** Connection names used in code that the target workspace does not have. */
+declare class UnresolvedConnectionsError extends Error {
+    readonly names: string[];
+    constructor(names: string[]);
+}
+/** Validate a parsed layout sidecar. */
+declare function parseLayoutSidecar(value: unknown): LayoutSidecar;
+/** Assemble IR v2 from a recording. */
+declare function assembleRecording(recording: Tier1Recording, options?: AssembleOptions): WorkflowDefinition;
+/** Lower a tier-1 workflow to IR v2 (spec 10 §1 `toIR`). */
+declare function toIR(workflow: Tier1Workflow, options?: AssembleOptions): WorkflowDefinition;
+
+export { defineWorkflow as $, type AfterInput as A, BuilderError as B, type CompareRef as C, type SwitchOptions as D, type EdgeOptions as E, type FileRef as F, type SwitchRef as G, type HandleRef as H, type IfOptions as I, type Tier1Workflow as J, type TriggerOperation as K, LAYOUT_FORMAT as L, type MergeOptions as M, type NodeOptions as N, type OnErrorOption as O, PREDICATE_OPERATORS as P, WorkflowBuilder as Q, RECORDING_FORMAT as R, type SignalWaitRef as S, type Tier1Recording as T, UnresolvedConnectionsError as U, type ValidateRef as V, type WaitForSignalOptions as W, type WorkflowOptions as X, and as Y, assembleRecording as Z, defaultEdgeId as _, type AnyRef as a, edge as a0, expr as a1, internalNodes as a2, isOperation as a3, isTier1Workflow as a4, nodes as a5, op as a6, or as a7, parseLayoutSidecar as a8, toIR as a9, trigger as aa, triggers as ab, type ApprovalRef as b, type ArgValue as c, type ArgsOf as d, type AssembleOptions as e, type ConditionGroup as f, type ConditionRule as g, type ConnectionResolver as h, type EdgeSource as i, type EdgeSpec as j, type IfRef as k, LAYOUT_FORMAT_VERSION as l, type LayoutSidecar as m, type LoopOptions as n, type LoopRef as o, type NodeRef as p, type NoteOptions as q, type Operation as r, type OutputRef as s, type Predicate as t, type PredicateMethods as u, RECORDING_FORMAT_VERSION as v, type RecordedNode as w, type RecordedNote as x, type RuleValue as y, type SubworkflowOptions as z };