@alpic80/rivet-core 1.19.1-aidon.1

package/dist/types/model/nodes/IfElseNode.d.ts

@@ -0,0 +1,18 @@
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition, type PortId } from '../NodeBase.js';
+import { type DataValue } from '../DataValue.js';
+import type { EditorDefinition } from '../EditorDefinition.js';
+export type IfElseNode = ChartNode<'ifElse', IfElseNodeData>;
+export type IfElseNodeData = {
+    /** If true, unconnected input ports are control-flow-excluded. */
+    unconnectedControlFlowExcluded?: boolean;
+};
+export declare class IfElseNodeImpl extends NodeImpl<IfElseNode> {
+    static create: () => IfElseNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    static getUIData(): NodeUIData;
+    getEditors(): EditorDefinition<IfElseNode>[];
+    process(inputData: Record<PortId, DataValue>): Promise<Record<PortId, DataValue>>;
+}
+export declare const ifElseNode: import("../NodeDefinition.js").NodeDefinition<IfElseNode>;

package/dist/types/model/nodes/IfNode.d.ts

@@ -0,0 +1,17 @@
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import type { Inputs, Outputs } from '../GraphProcessor.js';
+import type { EditorDefinition } from '../EditorDefinition.js';
+export type IfNode = ChartNode<'if', IfNodeData>;
+export type IfNodeData = {
+    unconnectedControlFlowExcluded?: boolean;
+};
+export declare class IfNodeImpl extends NodeImpl<IfNode> {
+    static create: () => IfNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    static getUIData(): NodeUIData;
+    getEditors(): EditorDefinition<IfNode>[];
+    process(inputData: Inputs): Promise<Outputs>;
+}
+export declare const ifNode: import("../NodeDefinition.js").NodeDefinition<IfNode>;

package/dist/types/model/nodes/ImageNode.d.ts

@@ -0,0 +1,20 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type DataRef, type EditorDefinition, type Inputs, type InternalProcessContext, type Outputs } from '../../index.js';
+export type ImageNode = ChartNode<'image', ImageNodeData>;
+type ImageNodeData = {
+    data?: DataRef;
+    useDataInput: boolean;
+    mediaType: 'image/png' | 'image/jpeg' | 'image/gif';
+    useMediaTypeInput: boolean;
+};
+export declare class ImageNodeImpl extends NodeImpl<ImageNode> {
+    static create(): ImageNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<ImageNode>[];
+    static getUIData(): NodeUIData;
+    process(inputData: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const imageNode: import("../NodeDefinition.js").NodeDefinition<ImageNode>;
+export {};

package/dist/types/model/nodes/JoinNode.d.ts

@@ -0,0 +1,21 @@
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type ChartNode, type NodeConnection, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { type Inputs, type Outputs } from '../GraphProcessor.js';
+import { type EditorDefinition } from '../EditorDefinition.js';
+export type JoinNode = ChartNode<'join', JoinNodeData>;
+export type JoinNodeData = {
+    flatten?: boolean;
+    joinString: string;
+    useJoinStringInput?: boolean;
+};
+export declare class JoinNodeImpl extends NodeImpl<JoinNode> {
+    #private;
+    static create: () => JoinNode;
+    getInputDefinitions(connections: NodeConnection[]): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<JoinNode>[];
+    getBody(): string | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs): Promise<Outputs>;
+}
+export declare const joinNode: import("../NodeDefinition.js").NodeDefinition<JoinNode>;

package/dist/types/model/nodes/ListGraphsNode.d.ts

@@ -0,0 +1,14 @@
+import type { ChartNode, EditorDefinition, Inputs, InternalProcessContext, NodeInputDefinition, NodeOutputDefinition, NodeUIData, Outputs } from '../../index.js';
+import { NodeImpl } from '../NodeImpl.js';
+export type ListGraphsNode = ChartNode<'listGraphs', ListSubgraphsData>;
+type ListSubgraphsData = {};
+export declare class ListGraphsNodeImpl extends NodeImpl<ListGraphsNode> {
+    static create(): ListGraphsNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    static getUIData(): NodeUIData;
+    getEditors(): EditorDefinition<ListGraphsNode>[] | Promise<EditorDefinition<ListGraphsNode>[]>;
+    process(_inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const listGraphsNode: import("../NodeDefinition.js").NodeDefinition<ListGraphsNode>;
+export {};

package/dist/types/model/nodes/LoadDatasetNode.d.ts

@@ -0,0 +1,17 @@
+import type { ChartNode, DatasetId, Inputs, InternalProcessContext, NodeInputDefinition, NodeOutputDefinition, NodeUIData, Outputs, EditorDefinition } from '../../index.js';
+import { NodeImpl } from '../NodeImpl.js';
+export type LoadDatasetNode = ChartNode<'loadDataset', LoadDatasetNodeData>;
+type LoadDatasetNodeData = {
+    datasetId: DatasetId;
+    useDatasetIdInput?: boolean;
+};
+export declare class LoadDatasetNodeImpl extends NodeImpl<LoadDatasetNode> {
+    static create(): LoadDatasetNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    static getUIData(): NodeUIData;
+    getEditors(): EditorDefinition<LoadDatasetNode>[] | Promise<EditorDefinition<LoadDatasetNode>[]>;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const loadDatasetNode: import("../NodeDefinition.js").NodeDefinition<LoadDatasetNode>;
+export {};

package/dist/types/model/nodes/LoopControllerNode.d.ts

@@ -0,0 +1,20 @@
+import { type ChartNode, type NodeConnection, type NodeId, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type Inputs, type Outputs } from '../GraphProcessor.js';
+import { type InternalProcessContext } from '../ProcessContext.js';
+import { type EditorDefinition } from '../../index.js';
+export type LoopControllerNode = ChartNode<'loopController', LoopControllerNodeData>;
+export type LoopControllerNodeData = {
+    maxIterations?: number;
+    atMaxIterationsAction?: 'break' | 'error';
+};
+export declare class LoopControllerNodeImpl extends NodeImpl<LoopControllerNode> {
+    #private;
+    static create(): LoopControllerNode;
+    getInputDefinitions(connections: NodeConnection[], nodes: Record<NodeId, ChartNode>): NodeInputDefinition[];
+    getOutputDefinitions(connections: NodeConnection[], nodes: Record<NodeId, ChartNode>): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<LoopControllerNode>[];
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const loopControllerNode: import("../NodeDefinition.js").NodeDefinition<LoopControllerNode>;

package/dist/types/model/nodes/MatchNode.d.ts

@@ -0,0 +1,19 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type EditorDefinition, type Inputs, type NodeBody, type Outputs } from '../../index.js';
+export type MatchNode = ChartNode<'match', MatchNodeData>;
+export type MatchNodeData = {
+    cases: string[];
+    /** If true, only the first matching branch will be ran. */
+    exclusive?: boolean;
+};
+export declare class MatchNodeImpl extends NodeImpl<MatchNode> {
+    static create(): MatchNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getBody(): NodeBody;
+    getEditors(): EditorDefinition<MatchNode>[];
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs): Promise<Outputs>;
+}
+export declare const matchNode: import("../NodeDefinition.js").NodeDefinition<MatchNode>;

package/dist/types/model/nodes/NumberNode.d.ts

@@ -0,0 +1,21 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type Inputs, type Outputs } from '../GraphProcessor.js';
+import { type EditorDefinition } from '../../index.js';
+export type NumberNode = ChartNode<'number', NumberNodeData>;
+export type NumberNodeData = {
+    value?: number;
+    useValueInput?: boolean;
+    round?: boolean;
+    roundTo?: number;
+};
+export declare class NumberNodeImpl extends NodeImpl<NumberNode> {
+    static create(): NumberNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<NumberNode>[];
+    getBody(): string | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs): Promise<Outputs>;
+}
+export declare const numberNode: import("../NodeDefinition.js").NodeDefinition<NumberNode>;

package/dist/types/model/nodes/ObjectNode.d.ts

@@ -0,0 +1,18 @@
+import { type ChartNode, type NodeConnection, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type DataValue } from '../DataValue.js';
+import { type EditorDefinition } from '../EditorDefinition.js';
+export type ObjectNode = ChartNode<'object', ObjectNodeData>;
+export type ObjectNodeData = {
+    jsonTemplate: string;
+};
+export declare class ObjectNodeImpl extends NodeImpl<ObjectNode> {
+    static create(): ObjectNode;
+    getInputDefinitions(connections: NodeConnection[]): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<ObjectNode>[];
+    static getUIData(): NodeUIData;
+    interpolate(baseString: string, values: Record<string, any>): string;
+    process(inputs: Record<string, DataValue>): Promise<Record<string, DataValue>>;
+}
+export declare const objectNode: import("../NodeDefinition.js").NodeDefinition<ObjectNode>;

package/dist/types/model/nodes/PassthroughNode.d.ts

@@ -0,0 +1,14 @@
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type ChartNode, type NodeConnection, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { type Inputs, type Outputs } from '../GraphProcessor.js';
+export type PassthroughNode = ChartNode<'passthrough', PassthroughNodeData>;
+export type PassthroughNodeData = {};
+export declare class PassthroughNodeImpl extends NodeImpl<PassthroughNode> {
+    #private;
+    static create: () => PassthroughNode;
+    getInputDefinitions(connections: NodeConnection[]): NodeInputDefinition[];
+    getOutputDefinitions(connections: NodeConnection[]): NodeOutputDefinition[];
+    static getUIData(): NodeUIData;
+    process(inputData: Inputs): Promise<Outputs>;
+}
+export declare const passthroughNode: import("../NodeDefinition.js").NodeDefinition<PassthroughNode>;

package/dist/types/model/nodes/PlayAudioNode.d.ts

@@ -0,0 +1,15 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type EditorDefinition, type Inputs, type InternalProcessContext, type Outputs } from '../../index.js';
+export type PlayAudioNode = ChartNode<'playAudio', PlayAudioNodeData>;
+type PlayAudioNodeData = {};
+export declare class PlayAudioNodeImpl extends NodeImpl<PlayAudioNode> {
+    static create(): PlayAudioNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<PlayAudioNode>[];
+    static getUIData(): NodeUIData;
+    process(inputData: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const playAudioNode: import("../NodeDefinition.js").NodeDefinition<PlayAudioNode>;
+export {};

package/dist/types/model/nodes/PopNode.d.ts

@@ -0,0 +1,19 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeBody, type NodeUIData } from '../NodeImpl.js';
+import { type Inputs, type Outputs } from '../GraphProcessor.js';
+import type { EditorDefinition } from '../EditorDefinition.js';
+import type { RivetUIContext } from '../RivetUIContext.js';
+export type PopNode = ChartNode<'pop', PopNodeData>;
+export type PopNodeData = {
+    fromFront?: boolean;
+};
+export declare class PopNodeImpl extends NodeImpl<PopNode> {
+    static create(): PopNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(_context: RivetUIContext): EditorDefinition<PopNode>[] | Promise<EditorDefinition<PopNode>[]>;
+    static getUIData(): NodeUIData;
+    getBody(_context: RivetUIContext): NodeBody | Promise<NodeBody>;
+    process(inputs: Inputs): Promise<Outputs>;
+}
+export declare const popNode: import("../NodeDefinition.js").NodeDefinition<PopNode>;

package/dist/types/model/nodes/PromptNode.d.ts

@@ -0,0 +1,23 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type EditorDefinition, type Inputs, type InternalProcessContext, type NodeBodySpec, type Outputs } from '../../index.js';
+export type PromptNode = ChartNode<'prompt', PromptNodeData>;
+export type PromptNodeData = {
+    type: 'system' | 'user' | 'assistant' | 'function';
+    useTypeInput: boolean;
+    promptText: string;
+    name?: string;
+    useNameInput?: boolean;
+    enableFunctionCall?: boolean;
+    computeTokenCount?: boolean;
+};
+export declare class PromptNodeImpl extends NodeImpl<PromptNode> {
+    static create(): PromptNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<PromptNode>[];
+    getBody(): string | NodeBodySpec | NodeBodySpec[] | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs, context: InternalProcessContext<PromptNode>): Promise<Outputs>;
+}
+export declare const promptNode: import("../NodeDefinition.js").NodeDefinition<PromptNode>;

package/dist/types/model/nodes/RaceInputsNode.d.ts

@@ -0,0 +1,17 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition, type NodeConnection } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type Inputs, type Outputs } from '../GraphProcessor.js';
+import { type InternalProcessContext } from '../ProcessContext.js';
+import { type EditorDefinition } from '../../index.js';
+export type RaceInputsNode = ChartNode<'raceInputs', RaceInputsNodeData>;
+export type RaceInputsNodeData = {};
+export declare class RaceInputsNodeImpl extends NodeImpl<RaceInputsNode> {
+    #private;
+    static create(): RaceInputsNode;
+    getInputDefinitions(connections: NodeConnection[]): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<RaceInputsNode>[];
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const raceInputsNode: import("../NodeDefinition.js").NodeDefinition<RaceInputsNode>;

package/dist/types/model/nodes/RaiseEventNode.d.ts

@@ -0,0 +1,22 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type DataValue } from '../DataValue.js';
+import { type Inputs } from '../GraphProcessor.js';
+import { type InternalProcessContext } from '../ProcessContext.js';
+import { type EditorDefinition } from '../EditorDefinition.js';
+import { type NodeBodySpec } from '../NodeBodySpec.js';
+export type RaiseEventNode = ChartNode<'raiseEvent', RaiseEventNodeData>;
+export type RaiseEventNodeData = {
+    eventName: string;
+    useEventNameInput: boolean;
+};
+export declare class RaiseEventNodeImpl extends NodeImpl<RaiseEventNode> {
+    static create(): RaiseEventNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<RaiseEventNode>[];
+    getBody(): string | NodeBodySpec | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Record<string, DataValue>>;
+}
+export declare const raiseEventNode: import("../NodeDefinition.js").NodeDefinition<RaiseEventNode>;

package/dist/types/model/nodes/RandomNumberNode.d.ts

@@ -0,0 +1,23 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type Inputs, type Outputs } from '../GraphProcessor.js';
+import { type EditorDefinition } from '../../index.js';
+export type RandomNumberNode = ChartNode<'randomNumber', RandomNumberNodeData>;
+export type RandomNumberNodeData = {
+    min?: number;
+    max?: number;
+    integers?: boolean;
+    maxInclusive?: boolean;
+    useMinInput?: boolean;
+    useMaxInput?: boolean;
+};
+export declare class RandomNumberNodeImpl extends NodeImpl<RandomNumberNode> {
+    static create(): RandomNumberNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<RandomNumberNode>[];
+    getBody(): string | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs): Promise<Outputs>;
+}
+export declare const randomNumberNode: import("../NodeDefinition.js").NodeDefinition<RandomNumberNode>;

package/dist/types/model/nodes/ReadDirectoryNode.d.ts

@@ -0,0 +1,30 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type Inputs, type Outputs } from '../GraphProcessor.js';
+import { type NodeBodySpec } from '../../index.js';
+import { type InternalProcessContext } from '../ProcessContext.js';
+export type ReadDirectoryNode = ChartNode<'readDirectory', ReadDirectoryNodeData>;
+type ReadDirectoryNodeData = {
+    path: string;
+    usePathInput: boolean;
+    recursive: boolean;
+    useRecursiveInput: boolean;
+    includeDirectories: boolean;
+    useIncludeDirectoriesInput: boolean;
+    filterGlobs: string[];
+    useFilterGlobsInput: boolean;
+    relative: boolean;
+    useRelativeInput: boolean;
+    ignores?: string[];
+    useIgnoresInput: boolean;
+};
+export declare class ReadDirectoryNodeImpl extends NodeImpl<ReadDirectoryNode> {
+    static create(): ReadDirectoryNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getBody(): string | NodeBodySpec | undefined;
+    static getUIData(): NodeUIData;
+    process(inputData: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const readDirectoryNode: import("../NodeDefinition.js").NodeDefinition<ReadDirectoryNode>;
+export {};

package/dist/types/model/nodes/ReadFileNode.d.ts

@@ -0,0 +1,23 @@
+import { type ChartNode, type PortId, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { type DataValue } from '../DataValue.js';
+import { NodeImpl, type NodeBody, type NodeUIData } from '../NodeImpl.js';
+import { type InternalProcessContext } from '../ProcessContext.js';
+import type { EditorDefinition } from '../EditorDefinition.js';
+export type ReadFileNode = ChartNode<'readFile', ReadFileNodeData>;
+type ReadFileNodeData = {
+    path: string;
+    usePathInput: boolean;
+    asBinary?: boolean;
+    errorOnMissingFile?: boolean;
+};
+export declare class ReadFileNodeImpl extends NodeImpl<ReadFileNode> {
+    static create(): ReadFileNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    static getUIData(): NodeUIData;
+    getEditors(): EditorDefinition<ReadFileNode>[];
+    getBody(): NodeBody;
+    process(inputData: Record<PortId, DataValue>, context: InternalProcessContext): Promise<Record<PortId, DataValue>>;
+}
+export declare const readFileNode: import("../NodeDefinition.js").NodeDefinition<ReadFileNode>;
+export {};

package/dist/types/model/nodes/ReplaceDatasetNode.d.ts

@@ -0,0 +1,21 @@
+import type { ChartNode, NodeInputDefinition, NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import type { InternalProcessContext } from '../ProcessContext.js';
+import type { DatasetId } from '../Dataset.js';
+import type { EditorDefinition } from '../EditorDefinition.js';
+import type { Inputs, Outputs } from '../GraphProcessor.js';
+export type ReplaceDatasetNode = ChartNode<'replaceDataset', ReplaceDatasetNodeData>;
+type ReplaceDatasetNodeData = {
+    datasetId: DatasetId;
+    useDatasetIdInput?: boolean;
+};
+export declare class ReplaceDatasetNodeImpl extends NodeImpl<ReplaceDatasetNode> {
+    static create(): ReplaceDatasetNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    static getUIData(): NodeUIData;
+    getEditors(): EditorDefinition<ReplaceDatasetNode>[] | Promise<EditorDefinition<ReplaceDatasetNode>[]>;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const replaceDatasetNode: import("../NodeDefinition.js").NodeDefinition<ReplaceDatasetNode>;
+export {};

package/dist/types/model/nodes/SetGlobalNode.d.ts

@@ -0,0 +1,23 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type DataType } from '../DataValue.js';
+import { type Inputs, type Outputs } from '../GraphProcessor.js';
+import { type InternalProcessContext } from '../ProcessContext.js';
+import { type EditorDefinition } from '../EditorDefinition.js';
+import { type NodeBodySpec } from '../NodeBodySpec.js';
+export type SetGlobalNode = ChartNode<'setGlobal', SetGlobalNodeData>;
+export type SetGlobalNodeData = {
+    id: string;
+    useIdInput: boolean;
+    dataType: DataType;
+};
+export declare class SetGlobalNodeImpl extends NodeImpl<SetGlobalNode> {
+    static create(): SetGlobalNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<SetGlobalNode>[];
+    getBody(): string | NodeBodySpec | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const setGlobalNode: import("../NodeDefinition.js").NodeDefinition<SetGlobalNode>;

package/dist/types/model/nodes/ShuffleNode.d.ts

@@ -0,0 +1,12 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type Inputs, type Outputs } from '../GraphProcessor.js';
+export type ShuffleNode = ChartNode<'shuffle'>;
+export declare class ShuffleNodeImpl extends NodeImpl<ShuffleNode> {
+    static create(): ShuffleNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs): Promise<Outputs>;
+}
+export declare const shuffleNode: import("../NodeDefinition.js").NodeDefinition<ShuffleNode>;

package/dist/types/model/nodes/SliceNode.d.ts

@@ -0,0 +1,22 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type Inputs, type Outputs } from '../GraphProcessor.js';
+import { type EditorDefinition } from '../EditorDefinition.js';
+import { type NodeBodySpec } from '../../index.js';
+export type SliceNode = ChartNode<'slice', SliceNodeData>;
+export type SliceNodeData = {
+    start?: number;
+    useStartInput?: boolean;
+    count?: number;
+    useCountInput?: boolean;
+};
+export declare class SliceNodeImpl extends NodeImpl<SliceNode> {
+    static create(): SliceNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<SliceNode>[];
+    getBody(): string | NodeBodySpec | NodeBodySpec[] | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs): Promise<Outputs>;
+}
+export declare const sliceNode: import("../NodeDefinition.js").NodeDefinition<SliceNode>;

package/dist/types/model/nodes/SplitNode.d.ts

@@ -0,0 +1,19 @@
+import type { ChartNode, NodeInputDefinition, NodeOutputDefinition, NodeUIData, EditorDefinition, Inputs, InternalProcessContext, Outputs, NodeBodySpec } from '../../index.js';
+import { NodeImpl } from '../NodeImpl.js';
+export type SplitNode = ChartNode<'split', SplitNodeData>;
+type SplitNodeData = {
+    delimiter: string;
+    useDelimiterInput?: boolean;
+    regex?: boolean;
+};
+export declare class SplitNodeImpl extends NodeImpl<SplitNode> {
+    static create(): SplitNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    static getUIData(): NodeUIData;
+    getEditors(): EditorDefinition<SplitNode>[] | Promise<EditorDefinition<SplitNode>[]>;
+    getBody(): string | NodeBodySpec | NodeBodySpec[] | undefined;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const splitNode: import("../NodeDefinition.js").NodeDefinition<SplitNode>;
+export {};

package/dist/types/model/nodes/SubGraphNode.d.ts

@@ -0,0 +1,29 @@
+import { type ChartNode, type NodeConnection, type NodeId, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type Inputs, type Outputs } from '../GraphProcessor.js';
+import { type GraphId } from '../NodeGraph.js';
+import { type Project } from '../Project.js';
+import { type DataValue } from '../DataValue.js';
+import { type InternalProcessContext } from '../ProcessContext.js';
+import { type EditorDefinition } from '../../index.js';
+import type { RivetUIContext } from '../RivetUIContext.js';
+export type SubGraphNode = ChartNode & {
+    type: 'subGraph';
+    data: {
+        graphId: GraphId;
+        useErrorOutput?: boolean;
+        useAsGraphPartialOutput?: boolean;
+        /** Data for each of the inputs of the subgraph */
+        inputData?: Record<string, DataValue>;
+    };
+};
+export declare class SubGraphNodeImpl extends NodeImpl<SubGraphNode> {
+    static create(): SubGraphNode;
+    getInputDefinitions(_connections: NodeConnection[], _nodes: Record<NodeId, ChartNode>, project: Project): NodeInputDefinition[];
+    getGraphOutputs(project: Project): NodeOutputDefinition[];
+    getOutputDefinitions(_connections: NodeConnection[], _nodes: Record<NodeId, ChartNode>, project: Project): NodeOutputDefinition[];
+    getEditors(context: RivetUIContext): EditorDefinition<SubGraphNode>[];
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const subGraphNode: import("../NodeDefinition.js").NodeDefinition<SubGraphNode>;

package/dist/types/model/nodes/TextNode.d.ts

@@ -0,0 +1,18 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type DataValue } from '../DataValue.js';
+import { type EditorDefinition, type NodeBodySpec } from '../../index.js';
+export type TextNode = ChartNode<'text', TextNodeData>;
+export type TextNodeData = {
+    text: string;
+};
+export declare class TextNodeImpl extends NodeImpl<TextNode> {
+    static create(): TextNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<TextNode>[];
+    getBody(): string | NodeBodySpec | undefined;
+    process(inputs: Record<string, DataValue>): Promise<Record<string, DataValue>>;
+    static getUIData(): NodeUIData;
+}
+export declare const textNode: import("../NodeDefinition.js").NodeDefinition<TextNode>;

package/dist/types/model/nodes/ToJsonNode.d.ts

@@ -0,0 +1,18 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type Inputs, type Outputs } from '../GraphProcessor.js';
+import { type EditorDefinition } from '../../index.js';
+export type ToJsonNode = ChartNode<'toJson', ToJsonNodeData>;
+export type ToJsonNodeData = {
+    indented?: boolean;
+};
+export declare class ToJsonNodeImpl extends NodeImpl<ToJsonNode> {
+    static create(): ToJsonNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<ToJsonNode>[];
+    getBody(): string | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs): Promise<Outputs>;
+}
+export declare const toJsonNode: import("../NodeDefinition.js").NodeDefinition<ToJsonNode>;

package/dist/types/model/nodes/ToYamlNode.d.ts

@@ -0,0 +1,13 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type Inputs, type Outputs } from '../GraphProcessor.js';
+export type ToYamlNode = ChartNode<'toYaml', ToYamlNodeData>;
+export type ToYamlNodeData = {};
+export declare class ToYamlNodeImpl extends NodeImpl<ToYamlNode> {
+    static create(): ToYamlNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs): Promise<Outputs>;
+}
+export declare const toYamlNode: import("../NodeDefinition.js").NodeDefinition<ToYamlNode>;

package/dist/types/model/nodes/TrimChatMessagesNode.d.ts

@@ -0,0 +1,20 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../../model/NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../../model/NodeImpl.js';
+import { type EditorDefinition, type Inputs, type InternalProcessContext, type NodeBodySpec, type Outputs } from '../../index.js';
+export type TrimChatMessagesNodeData = {
+    maxTokenCount: number;
+    useMaxTokenCountInput?: boolean;
+    removeFromBeginning: boolean;
+    useRemoveFromBeginningInput?: boolean;
+};
+export type TrimChatMessagesNode = ChartNode<'trimChatMessages', TrimChatMessagesNodeData>;
+export declare class TrimChatMessagesNodeImpl extends NodeImpl<TrimChatMessagesNode> {
+    static create(): TrimChatMessagesNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<TrimChatMessagesNode>[];
+    getBody(): string | NodeBodySpec | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs, context: InternalProcessContext<TrimChatMessagesNode>): Promise<Outputs>;
+}
+export declare const trimChatMessagesNode: import("../NodeDefinition.js").NodeDefinition<TrimChatMessagesNode>;

package/dist/types/model/nodes/URLReferenceNode.d.ts

@@ -0,0 +1,19 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl } from '../NodeImpl.js';
+import { type Inputs, type Outputs } from '../GraphProcessor.js';
+import { type EditorDefinition, type NodeUIData } from '../../index.js';
+export type UrlReferenceNode = ChartNode<'urlReference', UrlReferenceNodeData>;
+export type UrlReferenceNodeData = {
+    url: string;
+    useUrlInput?: boolean;
+};
+export declare class UrlReferenceNodeImpl extends NodeImpl<UrlReferenceNode> {
+    static create(): UrlReferenceNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<UrlReferenceNode>[];
+    static getUIData(): NodeUIData;
+    getBody(): string;
+    process(inputs: Inputs): Promise<Outputs>;
+}
+export declare const urlReferenceNode: import("../../index.js").NodeDefinition<UrlReferenceNode>;