@uipath/maestro-builder-sdk 6.20.6 → 6.21.1

package/dist/flow-node-registry.js

@@ -12,8 +12,9 @@ import { dataFabricFlowFamily } from './nodes/data-fabric/flow/family.js';
 import { delayFlowFamily } from './nodes/delay/flow/family.js';
 import { documentFlowFamily } from './nodes/document/flow/family.js';
 import { mockFlowFamily } from './nodes/mock/flow/family.js';
+import { queueFlowFamily } from './nodes/queue/flow/family.js';
 import { scriptFlowFamily } from './nodes/script/flow/family.js';
 import { transformFlowFamily } from './nodes/transform/flow/family.js';
 /** The families, in no significant order. Adding one is the whole of registering it. */
-export const FLOW_NODE_FAMILIES = [dataFabricFlowFamily, delayFlowFamily, documentFlowFamily, mockFlowFamily, scriptFlowFamily, transformFlowFamily];
+export const FLOW_NODE_FAMILIES = [dataFabricFlowFamily, delayFlowFamily, documentFlowFamily, mockFlowFamily, queueFlowFamily, scriptFlowFamily, transformFlowFamily];
 export const FLOW_NODE_TYPES = new NodeTypeRegistry('flow', FLOW_NODE_FAMILIES, { hasBundledDefinition });

package/dist/flow-node-type.d.ts

@@ -75,6 +75,12 @@ export interface FlowSerializeContext {
     } & Readonly<Record<string, unknown>>): void;
     /** The bundled definition `<typeName>@<version>`, or undefined when the SDK does not ship it. */
     definition(typeName: string, version: string): unknown;
+    /**
+     * The flow's bindings so far, by id — read-only. For a type that SHARES a
+     * binding with earlier steps on the same resource (a queue's name + folder
+     * pair) or must pick an id that is not taken; add entries through `bind`.
+     */
+    readonly bindings: ReadonlyMap<string, Readonly<Record<string, unknown>>>;
 }
 /** What `deserialize` may ask of the decompiler, for one serialized node. */
 export interface FlowDeserializeContext {

package/dist/flow-sdk.d.ts

@@ -22,6 +22,7 @@ export * from './nodes/data-fabric/flow/index.js';
 export * from './nodes/delay/flow/index.js';
 export * from './nodes/document/flow/index.js';
 export * from './nodes/mock/flow/index.js';
+export * from './nodes/queue/flow/index.js';
 export * from './nodes/script/flow/index.js';
 export * from './nodes/transform/flow/index.js';
 export { resolveFlowRefs, resolveRefPath, hasFileRefs } from './ref-resolve.js';
@@ -863,13 +864,11 @@ declare class StepList {
      * your handler), and it refuses at build time on a step whose node type has no
      * error port.
      *
-     * **A `.loop()` container takes one too.** `core.logic.loop` declares the
-     * handle, and a body step's failure routes to it: the container's envelope
-     * carries the body's message in `detail` and the failing body step's label
-     * (`display.label`, which defaults to the step name) in `element`, and the
-     * instance completes rather than faulting. `.doWhile()` does
-     * NOT — it declares an error variable and no error handle — so that one is
-     * refused by name, and its failures belong to the body step that can fail.
+     * **A `.loop()` or `.doWhile()` container takes one too.** Both definitions
+     * set `supportsErrorHandling: true`, and a body step's failure routes to the
+     * container: its envelope carries the body's message in `detail` and the
+     * failing body step's canvas label in `element`, and the instance completes rather than
+     * faulting.
      *
      * **A plain `http()` step is the trap worth knowing**: a 404 there is a
      * SUCCESS with `statusCode: 404`, so the handler never runs — use

package/dist/flow-sdk.js

@@ -26,6 +26,7 @@ export * from './nodes/data-fabric/flow/index.js';
 export * from './nodes/delay/flow/index.js';
 export * from './nodes/document/flow/index.js';
 export * from './nodes/mock/flow/index.js';
+export * from './nodes/queue/flow/index.js';
 export * from './nodes/script/flow/index.js';
 export * from './nodes/transform/flow/index.js';
 // `$ref`-split ingestion (design §5): decompile resolves local-file refs into
@@ -422,13 +423,11 @@ class StepList {
      * your handler), and it refuses at build time on a step whose node type has no
      * error port.
      *
-     * **A `.loop()` container takes one too.** `core.logic.loop` declares the
-     * handle, and a body step's failure routes to it: the container's envelope
-     * carries the body's message in `detail` and the failing body step's label
-     * (`display.label`, which defaults to the step name) in `element`, and the
-     * instance completes rather than faulting. `.doWhile()` does
-     * NOT — it declares an error variable and no error handle — so that one is
-     * refused by name, and its failures belong to the body step that can fail.
+     * **A `.loop()` or `.doWhile()` container takes one too.** Both definitions
+     * set `supportsErrorHandling: true`, and a body step's failure routes to the
+     * container: its envelope carries the body's message in `detail` and the
+     * failing body step's canvas label in `element`, and the instance completes rather than
+     * faulting.
      *
      * **A plain `http()` step is the trap worth knowing**: a 404 there is a
      * SUCCESS with `statusCode: 404`, so the handler never runs — use
@@ -468,25 +467,19 @@ class StepList {
             i--;
         }
         const source = this.steps[i];
-        // A `.loop()` CONTAINER is a legal source for the error port. Its definition
-        // declares the handle at both bundled versions (`core.logic.loop@1.0.0` and
-        // `@2.4`, gated on `errorHandlingEnabled` like every other error handle), and
-        // the platform routes it: a body step throwing inside a measured run left the
-        // instance Completed with the container's envelope published — `detail` the
-        // body's own message, `element` the label of the body step that failed.
-        //
-        // `.doWhile()` is NOT: `core.logic.dowhile@1.0` declares an error VARIABLE
-        // and no error HANDLE, so an edge would leave a handle the node does not
-        // have — the same shape as the agent `memory` handle that fails validate.
-        const containerPort = port === 'error' && source?.kind === 'loop';
+        // A container (`.loop()` or `.doWhile()`) is a legal source for the error
+        // port. Both definitions set `supportsErrorHandling: true`, and the platform
+        // routes it: a body step throwing inside a measured run left the instance
+        // Completed with the container's envelope published — `detail` the body's
+        // own message, `element` the canvas label of the body step that failed. `check` and
+        // `serialize` confirm the port against the bundled definition at the
+        // version the container emits (#1010).
+        const containerPort = port === 'error' && (source?.kind === 'loop' || source?.kind === 'doWhile');
         if (!source || (source.kind !== 'action' && !containerPort)) {
             throw new TypeError(`${called} leaves a port of the step BEFORE it, and ${source ? `the previous step is a ${source.kind}` : 'there is no previous step'}. `
                 + `Write .step('fetch', http({…}))${called}`
-                + (source?.kind === 'doWhile' && port === 'error'
-                    ? ' — a .doWhile() declares an error variable but no error HANDLE (core.logic.dowhile@1.0), so the edge '
-                        + 'would leave a handle the node does not have. Handle the failure inside the body instead.'
-                    : ' — a branch, parallel, terminate or return has no port to leave from; a .loop() has one only for '
-                        + "'error'."));
+                + ' — a branch, parallel, terminate or return has no port to leave from; a .loop() or .doWhile() has one '
+                + "only for 'error'.");
         }
         const taken = attached.some((s) => (s.kind === 'stepToList' || s.kind === 'stepToRef') && s.port === port);
         if (taken) {

package/dist/nodes/queue/flow/check.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The Queue family's rules and their catalog. Moved from check.ts in Phase 4 of
+ * docs/NODE_TYPE_ARCHITECTURE_DESIGN.md; codes and messages are unchanged.
+ */
+import type { DiagnosticCatalog } from '../../../core/nodes/family.js';
+import type { FlowCheckContext } from '../../../flow-node-type.js';
+import type { QueueItemInputs } from './spec.js';
+/** Every code the family reports, with the severity it reports it at. */
+export declare const QUEUE_DIAGNOSTICS: DiagnosticCatalog;
+/**
+ * Check a `queueItem(...)` call.
+ *
+ * WHAT THESE RULES CAN AND CANNOT SEE. Whether the queue exists, whether anything
+ * drains it, and what a consumer writes into a processed item's result all live on
+ * the tenant. So these cover the mistakes decidable from the call — plus the one
+ * mistake the PLATFORM decides and rejects at run time, which is worth catching
+ * here because its error arrives from Orchestrator as an HTTP 400 three layers
+ * away:
+ *
+ *  - a missing/blank `queue`, `folderPath` or `key`. Without the first two
+ *    nothing can resolve the node's `resourceBindings.name`, and without `key`
+ *    nothing joins the node to its bindings — both read as engine errors rather
+ *    than authoring ones.
+ *  - a `key` that is not a GUID. The commonest form is passing the queue's NAME
+ *    where its Orchestrator key belongs.
+ *  - a NESTED `item`. Orchestrator answers "Property values must be simple (like
+ *    numbers or text) and not complex or composite data types (like objects or
+ *    arrays)" — a run-time 400 for something visible in the source.
+ *  - a `priority` outside the three the node type offers. The platform normalizes
+ *    an unknown one silently, so it is a wrong RESULT, not an error.
+ *  - `returns` on a step that does not wait (there is nothing per-tenant to
+ *    declare), and a `wait: true` step whose result nothing can read.
+ *  - a non-ISO `dueDate` / `deferDate`.
+ */
+export declare function checkQueueItem(inputs: QueueItemInputs | undefined, ctx: FlowCheckContext): void;

package/dist/nodes/queue/flow/check.js

@@ -0,0 +1,126 @@
+import { commentText } from '../../../core/comment-text.js';
+import { nearestName } from '../../../core/edit-distance.js';
+import { Expr } from '../../../core/expr.js';
+import { GUID_RE } from '../../../core/binding-messages.js';
+/** Every code the family reports, with the severity it reports it at. */
+export const QUEUE_DIAGNOSTICS = {
+    QUEUE_NO_NAME: { severity: 'error', summary: 'no queue name' },
+    QUEUE_NO_FOLDER: { severity: 'error', summary: 'no folderPath' },
+    QUEUE_NO_KEY: { severity: 'error', summary: 'no queue key' },
+    QUEUE_KEY_NOT_GUID: { severity: 'error', summary: 'the key is not an Orchestrator GUID' },
+    QUEUE_NO_ITEM: { severity: 'warning', summary: 'the item carries no data' },
+    QUEUE_ITEM_NOT_OBJECT: { severity: 'error', summary: 'the item is not an object' },
+    QUEUE_ITEM_FIELD_NOT_PRIMITIVE: { severity: 'error', summary: 'an item field is not a primitive' },
+    QUEUE_BAD_PRIORITY: { severity: 'error', summary: 'a priority the node type does not offer' },
+    QUEUE_BAD_DATE: { severity: 'error', summary: 'a date Orchestrator cannot read' },
+    QUEUE_RETURNS_WITHOUT_WAIT: { severity: 'warning', summary: 'returns without wait: true' },
+    QUEUE_READ_NOT_OUTPUT: { severity: 'error', summary: 'a read outside the step\'s output' },
+    QUEUE_READ_WITHOUT_RETURNS: { severity: 'error', summary: 'a field read off a wait result with no returns' },
+    QUEUE_READ_UNKNOWN_FIELD: { severity: 'error', summary: 'a read of a field the step does not publish' },
+};
+/**
+ * Check a `queueItem(...)` call.
+ *
+ * WHAT THESE RULES CAN AND CANNOT SEE. Whether the queue exists, whether anything
+ * drains it, and what a consumer writes into a processed item's result all live on
+ * the tenant. So these cover the mistakes decidable from the call — plus the one
+ * mistake the PLATFORM decides and rejects at run time, which is worth catching
+ * here because its error arrives from Orchestrator as an HTTP 400 three layers
+ * away:
+ *
+ *  - a missing/blank `queue`, `folderPath` or `key`. Without the first two
+ *    nothing can resolve the node's `resourceBindings.name`, and without `key`
+ *    nothing joins the node to its bindings — both read as engine errors rather
+ *    than authoring ones.
+ *  - a `key` that is not a GUID. The commonest form is passing the queue's NAME
+ *    where its Orchestrator key belongs.
+ *  - a NESTED `item`. Orchestrator answers "Property values must be simple (like
+ *    numbers or text) and not complex or composite data types (like objects or
+ *    arrays)" — a run-time 400 for something visible in the source.
+ *  - a `priority` outside the three the node type offers. The platform normalizes
+ *    an unknown one silently, so it is a wrong RESULT, not an error.
+ *  - `returns` on a step that does not wait (there is nothing per-tenant to
+ *    declare), and a `wait: true` step whose result nothing can read.
+ *  - a non-ISO `dueDate` / `deferDate`.
+ */
+export function checkQueueItem(inputs, ctx) {
+    const step = ctx.step;
+    // Severity is the catalog's (QUEUE_DIAGNOSTICS): `at` and `warn` name the intent.
+    const at = (code, message, suggestion) => ctx.report(code, message, suggestion);
+    const warn = at;
+    const blank = (v) => v === undefined || v === null || (typeof v === 'string' && v.trim() === '');
+    if (blank(inputs?.queue)) {
+        at('QUEUE_NO_NAME', `Queue step "${step}" has no \`queue\`. That is the queue's name in Orchestrator, and the `
+            + `runtime resolves the queue by name + folder — without it the run fails before dispatch.`, `queue: 'SupplierInvoices'`);
+    }
+    if (blank(inputs?.folderPath)) {
+        at('QUEUE_NO_FOLDER', `Queue step "${step}" has no \`folderPath\`. Queues are folder-scoped, and the runtime `
+            + `resolves this one by name + folder.`, `folderPath: 'Shared'`);
+    }
+    if (blank(inputs?.key)) {
+        at('QUEUE_NO_KEY', `Queue step "${step}" has no \`key\`. That is the queue's own Orchestrator key, and it is `
+            + `what joins this node to the flow's queue bindings — without it nothing says which `
+            + `bindings belong to the node, so it cannot be dispatched. Find it with `
+            + `\`uip or queues list --all-folders\`.`, `key: 'fa1a7328-cd17-4525-b5ab-29d86e399312'`);
+    }
+    else if (!GUID_RE.test(String(inputs.key).trim())) {
+        at('QUEUE_KEY_NOT_GUID', `Queue step "${step}"'s \`key\` is ${JSON.stringify(inputs.key)}, which is not an `
+            + `Orchestrator key. \`key\` is the GUID the tenant gives the queue; the queue's NAME goes `
+            + `in \`queue\` and its folder in \`folderPath\`.`, `key: '<guid>', queue: ${JSON.stringify(inputs.key)}`);
+    }
+    // The item's data must be FLAT. This is the platform's rule, not ours, and it is
+    // enforced at the far end: a nested value earns an HTTP 400 from Orchestrator
+    // mid-run, which is a long way from the line that caused it.
+    const item = inputs?.item;
+    if (item === undefined || item === null) {
+        warn('QUEUE_NO_ITEM', `Queue step "${step}" has no \`item\`, so it enqueues an item with no data. That is legal `
+            + `— a bare item with a reference is a real pattern — but if the work needs a payload, this `
+            + `is where it goes.`, `item: { InvoiceId: input('invoiceRef') }`);
+    }
+    else if (typeof item !== 'object' || Array.isArray(item)) {
+        at('QUEUE_ITEM_NOT_OBJECT', `Queue step "${step}"'s \`item\` is ${Array.isArray(item) ? 'an array' : typeof item}. It `
+            + `must be an object of field names to primitive values — that object becomes the queue `
+            + `item's \`SpecificContent\`.`, `item: { InvoiceId: 'INV-1', Amount: 120 }`);
+    }
+    else {
+        for (const [k, v] of Object.entries(item)) {
+            // An Expr is a reference the runtime resolves — its VALUE may be anything,
+            // and nothing local can know, so it is not flagged here.
+            if (v instanceof Expr)
+                continue;
+            if (v !== null && typeof v === 'object') {
+                at('QUEUE_ITEM_FIELD_NOT_PRIMITIVE', `Queue step "${step}"'s \`item.${k}\` is ${Array.isArray(v) ? 'an array' : 'an object'}. `
+                    + `Orchestrator rejects a queue item whose property values are not simple: `
+                    + `"Property values must be simple (like numbers or text) and not complex or composite `
+                    + `data types (like objects or arrays)". Flatten it, or JSON-encode it into one string `
+                    + `field.`, `item: { ${k}: JSON.stringify(...) }  // or ${commentText(k)}Id, ${commentText(k)}Name, …`);
+            }
+        }
+    }
+    if (inputs?.priority !== undefined && !QUEUE_PRIORITIES.includes(String(inputs.priority))) {
+        at('QUEUE_BAD_PRIORITY', `Queue step "${step}"'s \`priority\` is ${JSON.stringify(inputs.priority)}. The node type `
+            + `offers exactly ${QUEUE_PRIORITIES.map((p) => `"${p}"`).join(', ')} — anything else is `
+            + `normalized silently by the platform, so the item is enqueued at the wrong priority `
+            + `rather than rejected.`, `priority: '${nearestName(String(inputs.priority), QUEUE_PRIORITIES) ?? 'Normal'}'`);
+    }
+    for (const field of ['deferDate', 'dueDate']) {
+        const v = inputs?.[field];
+        if (typeof v === 'string' && v.trim() !== '' && Number.isNaN(Date.parse(v))) {
+            at('QUEUE_BAD_DATE', `Queue step "${step}"'s \`${field}\` is ${JSON.stringify(v)}, which is not a date `
+                + `Orchestrator can read. It takes ISO-8601 — a full timestamp with a zone.`, `${field}: '2026-08-05T17:00:00Z'`);
+        }
+    }
+    // `returns` describes what a CONSUMER produced, which only exists if the step
+    // waited for one. On a fire-and-forget enqueue it is a misunderstanding worth
+    // naming: the output is the queue item's own record, and the serializer already
+    // declares its fields.
+    if (!inputs?.wait && inputs?.returns && Object.keys(inputs.returns).length) {
+        warn('QUEUE_RETURNS_WITHOUT_WAIT', `Queue step "${step}" declares \`returns\` but does not \`wait\`, so nothing produces those `
+            + `fields: a fire-and-forget enqueue publishes the queue ITEM's own Orchestrator record `
+            + `(\`Key\`, \`Status\`, \`Reference\`, \`SpecificContent\`, …), whose fields are already `
+            + `declared for you. \`returns\` describes what a CONSUMER wrote into a processed item's `
+            + `result, which needs \`wait: true\`.`, `wait: true`);
+    }
+}
+/** The three priorities `core.action.queue.create[-and-wait]`'s form offers. */
+const QUEUE_PRIORITIES = ['Low', 'Normal', 'High'];

package/dist/nodes/queue/flow/factories.d.ts

@@ -0,0 +1,49 @@
+/** The Queue family's factory. Moved from core/actions.ts in Phase 4 of docs/NODE_TYPE_ARCHITECTURE_DESIGN.md. */
+import { type ActionSpec } from '../../../core/actions.js';
+import type { QueueItemInputs } from './spec.js';
+/**
+ * Declare an Orchestrator QUEUE ITEM step.
+ *
+ * @remarks
+ * A queue is Orchestrator's work list: something puts items on it, and an
+ * automation bound to the queue takes them off one at a time. This step is the
+ * putting-on half.
+ *
+ * `queue` + `folderPath` are what the runtime resolves the queue by, and `key` is
+ * the queue's own Orchestrator key: it joins this node to the flow's queue
+ * bindings, which the serializer emits and points the node at. All three, for the
+ * same reason `rpaWorkflow` takes three — the key is the AUTHORING identity, the
+ * two bindings are the RUNTIME one.
+ *
+ * `item` is the work item's data. It becomes the item's `SpecificContent`, and it
+ * must be FLAT: Orchestrator rejects a nested object or array outright.
+ *
+ * **`wait`** picks between the family's two node types, which are one construct
+ * with two data paths. Default `false` enqueues and moves on, publishing the queue
+ * item's own Orchestrator record — read a field with `out('<step>', 'Key')`, and
+ * nothing extra has to be declared because that record's shape is the same for
+ * every queue. `wait: true` PARKS the flow until the item has been processed and
+ * publishes the consumer's result instead, which is per-automation — so a read of
+ * it needs `returns`, exactly as an rpa process's output does.
+ *
+ * What no rung can tell you: whether anything actually drains this queue. A
+ * `wait: true` step on a queue with no consumer waits until it times out.
+ *
+ * @example
+ * **Enqueue a work item and read its Orchestrator key**
+ * ```ts
+ * .step('enqueue', queueItem({
+ *   queue: 'SupplierInvoices',
+ *   folderPath: 'Shared',
+ *   key: 'fa1a7328-cd17-4525-b5ab-29d86e399312',
+ *   item: { InvoiceId: input('invoiceRef'), Amount: input('amount') },
+ *   reference: 'INV-2031',
+ * }))
+ * .return({ itemKey: out('enqueue', 'Key') })
+ * ```
+ *
+ * @param inputs - The `queue` and `folderPath`, the `item` to add, and whether
+ * to `wait` for it to be processed.
+ * @returns An action spec to pass to `.step(name, …)`.
+ */
+export declare function queueItem(inputs: QueueItemInputs): ActionSpec;

package/dist/nodes/queue/flow/factories.js

@@ -0,0 +1,50 @@
+/** The Queue family's factory. Moved from core/actions.ts in Phase 4 of docs/NODE_TYPE_ARCHITECTURE_DESIGN.md. */
+import { builtinActionSpec } from '../../../core/actions.js';
+/**
+ * Declare an Orchestrator QUEUE ITEM step.
+ *
+ * @remarks
+ * A queue is Orchestrator's work list: something puts items on it, and an
+ * automation bound to the queue takes them off one at a time. This step is the
+ * putting-on half.
+ *
+ * `queue` + `folderPath` are what the runtime resolves the queue by, and `key` is
+ * the queue's own Orchestrator key: it joins this node to the flow's queue
+ * bindings, which the serializer emits and points the node at. All three, for the
+ * same reason `rpaWorkflow` takes three — the key is the AUTHORING identity, the
+ * two bindings are the RUNTIME one.
+ *
+ * `item` is the work item's data. It becomes the item's `SpecificContent`, and it
+ * must be FLAT: Orchestrator rejects a nested object or array outright.
+ *
+ * **`wait`** picks between the family's two node types, which are one construct
+ * with two data paths. Default `false` enqueues and moves on, publishing the queue
+ * item's own Orchestrator record — read a field with `out('<step>', 'Key')`, and
+ * nothing extra has to be declared because that record's shape is the same for
+ * every queue. `wait: true` PARKS the flow until the item has been processed and
+ * publishes the consumer's result instead, which is per-automation — so a read of
+ * it needs `returns`, exactly as an rpa process's output does.
+ *
+ * What no rung can tell you: whether anything actually drains this queue. A
+ * `wait: true` step on a queue with no consumer waits until it times out.
+ *
+ * @example
+ * **Enqueue a work item and read its Orchestrator key**
+ * ```ts
+ * .step('enqueue', queueItem({
+ *   queue: 'SupplierInvoices',
+ *   folderPath: 'Shared',
+ *   key: 'fa1a7328-cd17-4525-b5ab-29d86e399312',
+ *   item: { InvoiceId: input('invoiceRef'), Amount: input('amount') },
+ *   reference: 'INV-2031',
+ * }))
+ * .return({ itemKey: out('enqueue', 'Key') })
+ * ```
+ *
+ * @param inputs - The `queue` and `folderPath`, the `item` to add, and whether
+ * to `wait` for it to be processed.
+ * @returns An action spec to pass to `.step(name, …)`.
+ */
+export function queueItem(inputs) {
+    return builtinActionSpec({ kind: 'queueItem', inputs });
+}

package/dist/nodes/queue/flow/family.d.ts

@@ -0,0 +1,3 @@
+/** The Queue node family, as flow-node-registry.ts lists it: `core.action.queue.create[-and-wait]`. */
+import type { FlowNodeFamily } from '../../../flow-node-type.js';
+export declare const queueFlowFamily: FlowNodeFamily;

package/dist/nodes/queue/flow/family.js

@@ -0,0 +1,8 @@
+import { QUEUE_DIAGNOSTICS } from './check.js';
+import { queueNodeTypes } from './node-type.js';
+export const queueFlowFamily = {
+    id: 'queue',
+    title: 'Queue',
+    types: queueNodeTypes,
+    diagnostics: QUEUE_DIAGNOSTICS,
+};

package/dist/nodes/queue/flow/index.d.ts

@@ -0,0 +1,3 @@
+/** The Queue family's public surface, which the package entry re-exports. */
+export * from './spec.js';
+export * from './factories.js';

package/dist/nodes/queue/flow/index.js

@@ -0,0 +1,3 @@
+/** The Queue family's public surface, which the package entry re-exports. */
+export * from './spec.js';
+export * from './factories.js';

package/dist/nodes/queue/flow/node-type.d.ts

@@ -0,0 +1,8 @@
+import type { FlowVersionedNodeType } from '../../../flow-node-type.js';
+import type { QueueItemInputs } from './spec.js';
+/** The spec both queue node types read. */
+export type QueueItemSpec = {
+    kind: 'queueItem';
+    inputs: QueueItemInputs;
+};
+export declare const queueNodeTypes: FlowVersionedNodeType<QueueItemSpec>[];