@xentom/integration-framework 0.0.0

package/dist/nodes/callable.d.ts

@@ -0,0 +1,98 @@
+import { type NodeType } from '.';
+import { type IntegrationState } from '../integration';
+import { type DataPin, type ExecPin, type ExtractPinsOfType, type InferPinRecordInput, type InferPinRecordOutput, type PinRecord, type PinRecordHasPinType } from '../pins';
+import { type HasRequiredKeys } from '../utils';
+import { type Webhook } from '../webhook';
+import { type BaseNode } from './base';
+import { type TriggerRunContext } from './trigger';
+export type CallableNodeInputs = PinRecord<DataPin>;
+export type CallableNodeOutputs = PinRecord<DataPin | ExecPin>;
+/**
+ * CallableNode is a type of node that can be called by other nodes.
+ */
+export interface CallableNode<I extends CallableNodeInputs = CallableNodeInputs, O extends CallableNodeOutputs = CallableNodeOutputs> extends BaseNode<I, O> {
+    type: NodeType.Callable;
+    /**
+     * Runs the node with the provided inputs, state, and context.
+     * This method is invoked when the node is called by another node.
+     *
+     * @param opts - Options containing the execution context, state, inputs, variables, webhook, and next callback.
+     */
+    run(opts: CallableNodeRunOptions<I, O>): void | Promise<void>;
+}
+/**
+ * CallableNodeRunOptions defines the options passed to the run method of a CallableNode.
+ */
+export interface CallableNodeRunOptions<I extends CallableNodeInputs, O extends CallableNodeOutputs> {
+    /**
+     * Information about the node instance being executed.
+     * Includes the unique identifier for this node within the workflow.
+     */
+    node: {
+        id: string;
+    };
+    /**
+     * Execution context for the node run, which may include metadata such as
+     * workflow identifiers, timestamps, or invocation sources.
+     * Useful for tracking or handling logic that depends on when or how the node is triggered.
+     */
+    ctx: TriggerRunContext;
+    /**
+     * In-memory state for the integration, shared across all nodes.
+     * Can be used to manage reusable resources like API clients or caches.
+     * This state is not persisted across restarts.
+     */
+    state: IntegrationState;
+    /**
+     * The resolved input values for the node, typically based on user configuration
+     * or outputs from preceding nodes in the workflow.
+     */
+    inputs: InferPinRecordOutput<I>;
+    /**
+     * A key-value map of variables defined by the user or resolved from other connected nodes.
+     *
+     * Useful for AI-powered nodes that can use these variables as additional context
+     * during execution or generation.
+     */
+    variables: Record<string, unknown>;
+    /**
+     * Webhook utility exposing the integration's public URL.
+     * Can be shared with external systems to send data back into the workflow.
+     */
+    webhook: Pick<Webhook, 'url'>;
+    /**
+     * Function used to programmatically run an output pin of the node.
+     * Calling this starts a workflow run with optional execution context and output values.
+     *
+     * @example
+     * If the node has no exec pins defined, you can call `next` directly with the output values:
+     * ```ts
+     * next({
+     *   value: Math.random(),
+     * });
+     * ```
+     *
+     * @example
+     * If the node defines one or more exec pins, you must specify the pin name
+     * and provide the corresponding output values:
+     * ```ts
+     * next('myCustomExecPin', {
+     *   value: Math.random(),
+     * });
+     * ```
+     */
+    next: NodeNextCallback<O>;
+}
+export type NodeNextCallback<PR extends PinRecord = PinRecord, AdditionalNextArgs extends unknown[] = []> = <P extends keyof ExtractPinsOfType<PR, ExecPin>>(this: void, ...args: PinRecordHasPinType<PR, ExecPin> extends true ? NodeNextCallbackArgsWithCustomExecPin<PR, P, AdditionalNextArgs> : NodeNextCallbackArgsWithDefaultExecPin<PR, AdditionalNextArgs>) => Promise<void>;
+export type NodeNextCallbackArgsWithCustomExecPin<PR extends PinRecord, P extends string, AdditionalNextArgs extends unknown[] = []> = HasRequiredKeys<NodeNextCallbackArgsWithCustomExecPinOutputs<PR, P>> extends true ? [
+    pin: P,
+    outputs: NodeNextCallbackArgsWithCustomExecPinOutputs<PR, P>,
+    ...AdditionalNextArgs
+] : [
+    pin: P,
+    outputs?: NodeNextCallbackArgsWithCustomExecPinOutputs<PR, P>,
+    ...AdditionalNextArgs
+];
+export type NodeNextCallbackArgsWithCustomExecPinOutputs<PR extends PinRecord, P extends string> = PR[P] extends ExecPin<infer R> ? string extends keyof R ? InferPinRecordInput<PR> : InferPinRecordInput<R> : never;
+export type NodeNextCallbackArgsWithDefaultExecPin<PR extends PinRecord, AdditionalNextArgs extends unknown[] = never[]> = HasRequiredKeys<InferPinRecordInput<PR>> extends true ? [outputs: InferPinRecordInput<PR>, ...AdditionalNextArgs] : [outputs?: InferPinRecordInput<PR>, ...AdditionalNextArgs];
+export type CallableNodeBuilder = <I extends CallableNodeInputs, O extends CallableNodeOutputs>(definition: Omit<CallableNode<I, O>, 'type'>) => CallableNode<I, O>;

package/dist/nodes/index.d.ts

@@ -0,0 +1,111 @@
+import { type CallableNode, type CallableNodeBuilder } from './callable';
+import { type PureNode, type PureNodeBuilder } from './pure';
+import { type TriggerNode, type TriggerNodeBuilder } from './trigger';
+export * from './base';
+export * from './callable';
+export * from './pure';
+export * from './trigger';
+export * from './utils';
+export type Node = TriggerNode | CallableNode | PureNode;
+export type NodeRecord<N extends Node = Node> = Record<string, N>;
+export declare enum NodeType {
+    /**
+     * Trigger nodes are entry points that can invoke other nodes but cannot be invoked by any.
+     * They represent the starting point of a workflow, typically triggered by external events
+     * such as webhooks, scheduled timers, or user interactions.
+     */
+    Trigger = "trigger",
+    /**
+     * Callable nodes can both invoke other nodes and be invoked by them.
+     * They represent intermediate processing steps in a workflow, allowing for
+     * complex branching and chaining of operations.
+     */
+    Callable = "callable",
+    /**
+     * Pure nodes are isolated - they neither invoke other nodes nor can be invoked by them.
+     * They represent standalone operations that perform calculations or transformations
+     * without any side effects or dependencies on other nodes.
+     */
+    Pure = "pure"
+}
+/**
+ * Collection of utilities for defining workflow nodes.
+ *
+ * Includes:
+ * - `trigger`: Defines a trigger that starts a workflow in response to internal or external events.
+ * - `callable`: Defines a node that performs side effects and explicitly control workflow execution.
+ * - `pure`: Defines a side-effect-free, deterministic node that computes outputs from inputs.
+ */
+export declare const nodes: {
+    /**
+     * Defines a trigger that starts a workflow in response to internal or external events
+     * such as incoming webhooks, scheduled timers, or custom event sources.
+     *
+     * A trigger includes a `subscribe` function, where you can listen for events and
+     * call `next()` to emit outputs and initiate the workflow.
+     *
+     * @example
+     * ```ts
+     * export const onMessage = i.nodes.trigger({
+     *   outputs: {
+     *     message: i.pins.data(),
+     *   },
+     *   subscribe(opts) {
+     *     const unsubscribe = opts.state.client.on('message', (data) => {
+     *       opts.next({ message: data });
+     *     });
+     *
+     *     return () => unsubscribe();
+     *   },
+     * });
+     * ```
+     */
+    trigger: TriggerNodeBuilder;
+    /**
+     * Defines a callable node that is executed during a workflow run.
+     * Callable nodes are typically used to perform side effects such as API requests,
+     * data mutations, or interacting with external systems.
+     *
+     * The `run` function is executed when the workflow reaches this node. To continue
+     * the workflow through an exec pin, the node must call `next()` explicitly.
+     *
+     * @example
+     * ```ts
+     * export const logMessage = i.nodes.callable({
+     *   displayName: 'Log Message',
+     *   inputs: {
+     *     message: i.pins.data(),
+     *   },
+     *   run({ inputs, next }) {
+     *     console.log(inputs.message);
+     *     next(); // Required to continue workflow execution
+     *   },
+     * });
+     * ```
+     */
+    callable: CallableNodeBuilder;
+    /**
+     * Defines a pure node that computes outputs based only on its inputs.
+     * Pure nodes are deterministic and side-effect-free. They cannot be executed directly
+     * instead, they are evaluated automatically when their outputs are needed in the workflow.
+     *
+     * The `run` function is used to assign outputs based on the resolved inputs.
+     *
+     * @example
+     * ```ts
+     * export const addition = i.nodes.pure({
+     *   inputs: {
+     *     a: i.pins.data(),
+     *     b: i.pins.data(),
+     *   },
+     *   outputs: {
+     *     result: i.pins.data(),
+     *   },
+     *   run({ inputs, outputs }) {
+     *     outputs.result = inputs.a + inputs.b;
+     *   },
+     * });
+     * ```
+     */
+    pure: PureNodeBuilder;
+};

package/dist/nodes/index.js

@@ -0,0 +1,48 @@
+export * from './base';
+export * from './callable';
+export * from './pure';
+export * from './trigger';
+export * from './utils';
+export var NodeType;
+(function (NodeType) {
+    /**
+     * Trigger nodes are entry points that can invoke other nodes but cannot be invoked by any.
+     * They represent the starting point of a workflow, typically triggered by external events
+     * such as webhooks, scheduled timers, or user interactions.
+     */
+    NodeType["Trigger"] = "trigger";
+    /**
+     * Callable nodes can both invoke other nodes and be invoked by them.
+     * They represent intermediate processing steps in a workflow, allowing for
+     * complex branching and chaining of operations.
+     */
+    NodeType["Callable"] = "callable";
+    /**
+     * Pure nodes are isolated - they neither invoke other nodes nor can be invoked by them.
+     * They represent standalone operations that perform calculations or transformations
+     * without any side effects or dependencies on other nodes.
+     */
+    NodeType["Pure"] = "pure";
+})(NodeType || (NodeType = {}));
+/**
+ * Collection of utilities for defining workflow nodes.
+ *
+ * Includes:
+ * - `trigger`: Defines a trigger that starts a workflow in response to internal or external events.
+ * - `callable`: Defines a node that performs side effects and explicitly control workflow execution.
+ * - `pure`: Defines a side-effect-free, deterministic node that computes outputs from inputs.
+ */
+export const nodes = {
+    trigger: (definition) => ({
+        ...definition,
+        type: NodeType.Trigger,
+    }),
+    callable: (definition) => ({
+        ...definition,
+        type: NodeType.Callable,
+    }),
+    pure: (definition) => ({
+        ...definition,
+        type: NodeType.Pure,
+    }),
+};

package/dist/nodes/pure.d.ts

@@ -0,0 +1,77 @@
+import { type NodeType } from '.';
+import { type IntegrationState } from '../integration';
+import { type DataPin, type InferPinRecordInput, type InferPinRecordOutput, type PinRecord } from '../pins';
+import { type Webhook } from '../webhook';
+import { type BaseNode } from './base';
+import { type TriggerRunContext } from './trigger';
+export type PureNodeInputs = PinRecord<DataPin>;
+export type PureNodeOutputs = PinRecord<DataPin>;
+/**
+ * PureNode is a type of node that is isolated and does not invoke other nodes or can be invoked by them.
+ */
+export interface PureNode<I extends PureNodeInputs = PureNodeInputs, O extends PureNodeOutputs = PureNodeOutputs> extends BaseNode<I, O> {
+    /**
+     * Identifies the node as a pure node.
+     * Pure nodes do not mutate any external or internal state and produce outputs solely based on their inputs.
+     * They cannot be triggered directly or independently, they must be connected to an input pin.
+     * The `run` function is executed automatically when the node is required as part of a data flow.
+     */
+    type: NodeType.Pure;
+    /**
+     * Optional function that contains the core logic of the pure node.
+     * It is executed automatically when the node is evaluated as part of the workflow.
+     * Should compute outputs purely from the inputs without causing side effects.
+     *
+     * @example
+     * ```ts
+     * run(opts) {
+     *   opts.outputs.result = opts.inputs.a + opts.inputs.b;
+     * }
+     * ```
+     */
+    run?(opts: PureNodeRunOptions<I, O>): Promise<void> | void;
+}
+export interface PureNodeRunOptions<I extends PureNodeInputs = PureNodeInputs, O extends PureNodeOutputs = PureNodeOutputs> {
+    /**
+     * Information about the node instance being executed.
+     * Includes the unique identifier for this node within the workflow.
+     */
+    node: {
+        id: string;
+    };
+    /**
+     * Execution context for the node run, which may include metadata such as
+     * workflow identifiers, timestamps, or invocation sources.
+     * Useful for tracking or handling logic that depends on when or how the node is triggered.
+     */
+    ctx: TriggerRunContext;
+    /**
+     * In-memory state for the integration, shared across all nodes.
+     * Can be used to manage reusable resources like API clients or caches.
+     * This state is not persisted across restarts.
+     */
+    state: IntegrationState;
+    /**
+     * The resolved input values for the node, typically based on user configuration
+     * or outputs from preceding steps in the workflow.
+     */
+    inputs: InferPinRecordOutput<I>;
+    /**
+     * The object used to assign output values from the node.
+     * Each output pin should be populated within the `run` function to pass values forward in the workflow.
+     */
+    outputs: InferPinRecordInput<O>;
+    /**
+     * A key-value map of variables defined by the user or resolved from other connected nodes.
+     *
+     * Useful for AI-powered nodes that can use these variables as additional context
+     * during execution or generation.
+     */
+    variables: Record<string, unknown>;
+    /**
+     * Webhook utility exposing the integration's public URL.
+     * Can be shared with external systems to send data back into the workflow.
+     */
+    webhook: Pick<Webhook, 'url'>;
+}
+export type PureNodeBuilder = <I extends PureNodeInputs, O extends PureNodeOutputs>(definition: Omit<PureNode<I, O>, 'type'>) => PureNode<I, O>;

package/dist/nodes/trigger.d.ts

@@ -0,0 +1,124 @@
+import { type IntegrationState } from '../integration';
+import { type DataPin, type ExecPin, type InferPinRecordOutput, type PinRecord } from '../pins';
+import { type Webhook } from '../webhook';
+import { type BaseNode } from './base';
+import { type NodeNextCallback } from './callable';
+import { type NodeType } from './index';
+/**
+ * TriggerNode is a type of node that can be triggered by an external event, such as a webhook or a timer.
+ */
+export type TriggerNodeInputs = PinRecord<DataPin>;
+export type TriggerNodeOutputs = PinRecord<DataPin | ExecPin>;
+export interface TriggerNode<I extends TriggerNodeInputs = TriggerNodeInputs, O extends TriggerNodeOutputs = TriggerNodeOutputs> extends BaseNode<I, O> {
+    type: NodeType.Trigger;
+    /**
+     * Registers a callback to subscribe to internal or external events.
+     * This allows the trigger to listen for changes (e.g. webhooks, timers, system events)
+     * and initiate a workflow run when the event occurs.
+     *
+     * The callback is called during setup and can return a cleanup function to unsubscribe when the workflow is stopped or reconfigured.
+     *
+     * @example
+     * Listening for a webhook event:
+     * ```ts
+     * subscribe(opts) {
+     *   const unsubscribe = opts.webhook.subscribe((req) => {
+     *     // Handle incoming webhook requests
+     *     return new Response('OK');
+     *   });
+     *
+     *   return () => {
+     *     unsubscribe();
+     *   };
+     * }
+     * ```
+     *
+     * @example
+     * Listening for a timer event:
+     * ```ts
+     * subscribe(opts) {
+     *   const interval = setInterval(() => {
+     *     opts.next({
+     *       timestamp: new Date().getTime(),
+     *     });
+     *   }, 60000); // Trigger every minute
+  
+     *   return () => {
+     *     clearInterval(interval);
+     *   };
+     * }
+     * ```
+     *
+     * @example
+     * Listening for a external event via client:
+     * ```ts
+     * subscribe(opts) {
+     *   const unsubscribe = opts.state.client.on('message', (content: string) => {
+     *     // Handle the incoming message content
+     *   });
+     *
+     *   return () => {
+     *     unsubscribe();
+     *   };
+     * }
+     * ```
+     */
+    subscribe(opts: TriggerSubscribeOptions<I, O>): TriggerSubscribeCleanup;
+}
+export type TriggerSubscribeCleanup = Promise<(() => void) | void> | (() => void) | void;
+export interface TriggerSubscribeOptions<I extends TriggerNodeInputs, O extends TriggerNodeOutputs> {
+    /**
+     * Information about the node instance being executed.
+     * Includes the unique identifier for this node within the workflow.
+     */
+    node: {
+        id: string;
+    };
+    /**
+     * In-memory state for the integration, shared across all nodes.
+     * Can be used to manage reusable resources like API clients or caches.
+     * This state is not persisted across restarts.
+     */
+    state: IntegrationState;
+    /**
+     * Webhook utility for registering handlers that respond to incoming HTTP requests.
+     * Typically used when the trigger relies on external events via webhooks.
+     */
+    webhook: Webhook;
+    /**
+     * The resolved input values for the trigger, typically based on user configuration
+     * or outputs from preceding steps in the workflow.
+     */
+    inputs: InferPinRecordOutput<I>;
+    /**
+     * A key-value map of variables defined by the user or resolved from other connected nodes.
+     *
+     * Useful for AI-powered nodes that can use these variables as additional context
+     * during execution or generation.
+     */
+    variables: Record<string, unknown>;
+    /**
+     * Function used to programmatically run an output pin of the trigger.
+     * Calling this starts a workflow run with optional execution context and output values.
+     *
+     * @example
+     * If the trigger has no exec pins defined, you can call `next` directly with the output values:
+     * ```ts
+     * next({
+     *   value: Math.random(),
+     * });
+     * ```
+     *
+     * @example
+     * If the trigger defines one or more exec pins, you must specify the pin name
+     * and provide the corresponding output values:
+     * ```ts
+     * next('myCustomExecPin', {
+     *   value: Math.random(),
+     * });
+     * ```
+     */
+    next: NodeNextCallback<O, [ctx?: TriggerRunContext]>;
+}
+export type TriggerRunContext = Record<string, any>;
+export type TriggerNodeBuilder = <I extends TriggerNodeInputs, O extends TriggerNodeOutputs>(definition: Omit<TriggerNode<I, O>, 'type'>) => TriggerNode<I, O>;

package/dist/nodes/utils.d.ts

@@ -0,0 +1,13 @@
+import { type Node, type NodeRecord } from '.';
+import { type InferPinRecordInput, type InferPinRecordOutput, type PinRecord } from '../pins';
+export declare const DefaultExecPinName = "__exec";
+export type InferNodeRecordOutput<R extends NodeRecord> = {
+    [K in keyof R]: InferNodeOutput<R[K]>;
+};
+export type InferNodeOutput<N extends Node> = N extends {
+    inputs?: infer I;
+    outputs?: infer O;
+} ? {
+    inputs: I extends PinRecord ? InferPinRecordInput<I> : never;
+    outputs: O extends PinRecord ? InferPinRecordOutput<O> : never;
+} : never;

package/dist/nodes/utils.js

@@ -0,0 +1 @@
+export const DefaultExecPinName = '__exec';

package/dist/pins/base.d.ts

@@ -0,0 +1,13 @@
+export interface BasePin {
+    /**
+     * Custom display name for the pin. If set to a string, it overrides the default label.
+     * If set to `false`, the label is hidden but the pin remains visible. Useful for reducing
+     * visual clutter when the pin's purpose is self-explanatory.
+     */
+    displayName?: string | false;
+    /**
+     * Optional description providing additional context or guidance for the pin.
+     * Typically shown as a tooltip or inline help text.
+     */
+    description?: string;
+}

package/dist/pins/data.d.ts

@@ -0,0 +1,95 @@
+import { type StandardSchemaV1 } from '@standard-schema/spec';
+import { type PinType } from '.';
+import { type Control } from '../controls';
+import { type IntegrationOptions } from '../integration';
+import { type ConditionalOptional } from '../utils';
+import { type BasePin } from './base';
+export interface DataPin<Input = any, Output = Input, Optional extends boolean = boolean> extends BasePin {
+    type: PinType.Data;
+    /**
+     * Validation schema compatible with the Standard Schema specification.
+     * Defines the structure and constraints for the pin's data.
+     * Can be used with any validator that conforms to the Standard Schema interface.
+     *
+     * @see {@link https://github.com/standard-schema/standard-schema}
+     *
+     * @example
+     * Using Valibot for validation:
+     * ```ts
+     * v.pipe(v.string(), v.trim())
+     * ```
+     */
+    schema?: StandardSchemaV1<Input, Output> | ((opts: IntegrationOptions) => StandardSchemaV1<Input, Output>);
+    /**
+     * Optional control configuration that defines how the pin should be rendered in the UI.
+     * Supports various input types such as text fields, select dropdowns, and toggles.
+     *
+     * @example
+     * ```ts
+     * control: i.controls.text({
+     *   label: 'Message',
+     * })
+     * ```
+     */
+    control?: false | Control<ConditionalOptional<Optional, Input & {}>>;
+    /**
+     * Optional examples that provide users with predefined values for the pin.
+     * Each example includes a title and a value to illustrate the expected input format
+     * or showcase common use cases.
+     *
+     * These examples are helpful both for users and for AI assistance,
+     * as they provide context and practical references for how the pin can be used.
+     *
+     * @example
+     * ```ts
+     * examples: [
+     *   {
+     *     title: 'Example 1',
+     *     value: 'This is an example input',
+     *   },
+     *   {
+     *     title: 'Example 2',
+     *     value: [
+     *       'This is another example input',
+     *       'It can be an array or any other type',
+     *     ],
+     *   },
+     * ]
+     * ```
+     */
+    examples?: DataPinExample<ConditionalOptional<Optional, Input & {}>>[];
+    /**
+     * Determines if the pin is optional in the UI.
+     * When `true`, the pin does not appear initially but can be manually added by the user if needed.
+     * This is useful for reducing visual clutter or showing context-specific pins when required.
+     *
+     * @example
+     * ```ts
+     * optional: true,
+     * ```
+     */
+    optional?: Optional;
+}
+export interface DataPinExample<I> {
+    /**
+     * A human-readable title for the example, providing context or a brief description.
+     */
+    title: string;
+    /**
+     * The value of the example, which can be any valid input type for the pin.
+     * This value is used to illustrate how the pin can be utilized in practice.
+     */
+    value: I;
+}
+export type DataPinBuilder<ParentInput = any, ParentOutput = ParentInput, ParentOptional extends boolean = false> = <Input = ParentInput, Output = undefined extends ParentOutput ? Input : ParentOutput, Optional extends boolean = ParentOptional>(definition?: Omit<DataPin<Input, Output, Optional>, 'type' | 'with'>) => NoInfer<DataPin<ConditionalOptional<Optional, Input>, ConditionalOptional<Optional, Output>, Optional> & {
+    /**
+     * A function that builds a new pin with the given definition.
+     *
+     * @example
+     * ```ts
+     * i.pins.data().with({
+     *   description: 'A message to send',
+     * })
+     */
+    with: DataPinBuilder<Input, Output, Optional>;
+}>;

package/dist/pins/exec.d.ts

@@ -0,0 +1,61 @@
+import { type PinRecord, type PinType } from '.';
+import { type BasePin } from './base';
+import { type DataPin } from './data';
+export interface ExecPin<PR extends PinRecord<DataPin> = PinRecord<DataPin>> extends BasePin {
+    type: PinType.Exec;
+    /**
+     * Optional outputs for the exec pin, defined as a set of named data pins.
+     * These outputs are scoped locally to the exec pin and are separate from the node's global outputs.
+     * Useful for cases like iteration, where the exec pin is triggered for each item in a list.
+     *
+     * @example
+     * ```ts
+     * outputs: {
+     *   item: i.pins.data(),
+     *   index: i.pins.data(),
+     * }
+     * ```
+     *
+     * @example
+     * Full example of an exec pin that iterates over an array:
+     * ```ts
+     * i.nodes.callable({
+     *   inputs: {
+     *     array: i.pins.data<unknown[]>(),
+     *   },
+     *   outputs: {
+     *     completed: i.pins.exec(),
+     *     iteration: i.pins.exec({
+     *       outputs: {
+     *         element: i.pins.data(),
+     *         index: i.pins.data(),
+     *       },
+     *     }),
+     *   },
+     *   run(opts) {
+     *     opts.inputs.array.forEach((element, index) => {
+     *       opts.next('iteration', {
+     *         element,
+     *         index,
+     *       });
+     *     });
+     *
+     *     opts.next('completed');
+     *   },
+     * });
+     * ```
+     */
+    outputs?: PR;
+}
+export type ExecPinBuilder<ParentPR extends PinRecord<DataPin> = PinRecord<DataPin>> = <PR extends PinRecord<DataPin> = ParentPR>(definition?: Omit<ExecPin<PR>, 'type' | 'with'>) => ExecPin<PR> & {
+    /**
+     * A function that builds a new pin with the given definition.
+     *
+     * @example
+     * ```ts
+     * i.pins.exec().with({
+     *   description: 'A message to send',
+     * })
+     */
+    with: ExecPinBuilder<PR>;
+};