@alpic80/rivet-core 1.19.1-aidon.1

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

@@ -0,0 +1,22 @@
+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 Outputs } from '../../index.js';
+import type { Tokenizer, TokenizerCallInfo } from '../../integrations/Tokenizer.js';
+export type ChunkNodeData = {
+    numTokensPerChunk: number;
+    model: string;
+    useModelInput: boolean;
+    overlap: number;
+};
+export type ChunkNode = ChartNode<'chunk', ChunkNodeData>;
+export declare class ChunkNodeImpl extends NodeImpl<ChunkNode> {
+    static create(): ChunkNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<ChunkNode>[];
+    getBody(): string | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const chunkNode: import("../NodeDefinition.js").NodeDefinition<ChunkNode>;
+export declare function chunkStringByTokenCount(tokenizer: Tokenizer, tokenizerInfo: TokenizerCallInfo, input: string, targetTokenCount: number, overlapPercent: number): Promise<string[]>;

package/dist/types/model/nodes/CoalesceNode.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 CoalesceNode = ChartNode<'coalesce', CoalesceNodeData>;
+export type CoalesceNodeData = {};
+export declare class CoalesceNodeImpl extends NodeImpl<CoalesceNode> {
+    #private;
+    static create: () => CoalesceNode;
+    getInputDefinitions(connections: NodeConnection[]): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    static getUIData(): NodeUIData;
+    process(inputData: Inputs): Promise<Outputs>;
+}
+export declare const coalesceNode: import("../NodeDefinition.js").NodeDefinition<CoalesceNode>;

package/dist/types/model/nodes/CodeNode.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 DataValue } from '../DataValue.js';
+import { type EditorDefinition } from '../EditorDefinition.js';
+import { type NodeBodySpec } from '../NodeBodySpec.js';
+export type CodeNode = ChartNode<'code', CodeNodeData>;
+export type CodeNodeData = {
+    code: string;
+    inputNames: string | string[];
+    outputNames: string | string[];
+};
+export declare class CodeNodeImpl extends NodeImpl<CodeNode> {
+    static create(): CodeNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<CodeNode>[];
+    getBody(): string | NodeBodySpec | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Record<string, DataValue>): Promise<Record<string, DataValue>>;
+}
+export declare const codeNode: import("../NodeDefinition.js").NodeDefinition<CodeNode>;

package/dist/types/model/nodes/CommentNode.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 DataValue } from '../DataValue.js';
+import { type EditorDefinition } from '../EditorDefinition.js';
+export type CommentNode = ChartNode<'comment', CommentNodeData>;
+export type CommentNodeData = {
+    text: string;
+    color?: string;
+    backgroundColor?: string;
+    height: number;
+};
+export declare class CommentNodeImpl extends NodeImpl<CommentNode> {
+    static create(): CommentNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<CommentNode>[];
+    static getUIData(): NodeUIData;
+    process(): Promise<Record<string, DataValue>>;
+}
+export declare const commentNode: import("../NodeDefinition.js").NodeDefinition<CommentNode>;

package/dist/types/model/nodes/CompareNode.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 Inputs, type Outputs } from '../GraphProcessor.js';
+import { type EditorDefinition } from '../../index.js';
+export type CompareNode = ChartNode<'compare', CompareNodeData>;
+export type CompareNodeData = {
+    comparisonFunction: '==' | '<' | '>' | '<=' | '>=' | '!=' | 'and' | 'or' | 'xor' | 'nand' | 'nor' | 'xnor';
+    useComparisonFunctionInput?: boolean;
+};
+export declare class CompareNodeImpl extends NodeImpl<CompareNode> {
+    static create(): CompareNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<CompareNode>[];
+    getBody(): string | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs): Promise<Outputs>;
+}
+export declare const compareNode: import("../NodeDefinition.js").NodeDefinition<CompareNode>;

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

@@ -0,0 +1,24 @@
+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 ContextNode = ChartNode<'context', ContextNodeData>;
+export type ContextNodeData = {
+    id: string;
+    dataType: DataType;
+    defaultValue?: unknown;
+    useDefaultValueInput?: boolean;
+};
+export declare class ContextNodeImpl extends NodeImpl<ContextNode> {
+    static create(): ContextNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<ContextNode>[];
+    getBody(): string | NodeBodySpec | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const contextNode: import("../NodeDefinition.js").NodeDefinition<ContextNode>;

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

@@ -0,0 +1,13 @@
+import type { ChartNode, Inputs, InternalProcessContext, NodeInputDefinition, NodeOutputDefinition, NodeUIData, Outputs } from '../../index.js';
+import { NodeImpl } from '../NodeImpl.js';
+export type CreateDatasetNode = ChartNode<'createDataset', CreateDatasetNodeData>;
+type CreateDatasetNodeData = {};
+export declare class CreateDatasetNodeImpl extends NodeImpl<CreateDatasetNode> {
+    static create(): CreateDatasetNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const createDatasetNode: import("../NodeDefinition.js").NodeDefinition<CreateDatasetNode>;
+export {};

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

@@ -0,0 +1,19 @@
+import type { ChartNode, DatasetId, Inputs, InternalProcessContext, NodeInputDefinition, NodeOutputDefinition, NodeUIData, Outputs, EditorDefinition } from '../../index.js';
+import { NodeImpl } from '../NodeImpl.js';
+export type DatasetNearestNeighborsNode = ChartNode<'datasetNearestNeighbors', DatasetNearestNeighborsNodeData>;
+type DatasetNearestNeighborsNodeData = {
+    datasetId: DatasetId;
+    useDatasetIdInput?: boolean;
+    k: number;
+    useKInput?: boolean;
+};
+export declare class DatasetNearestNeighborsNodeImpl extends NodeImpl<DatasetNearestNeighborsNode> {
+    static create(): DatasetNearestNeighborsNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    static getUIData(): NodeUIData;
+    getEditors(): EditorDefinition<DatasetNearestNeighborsNode>[];
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const datasetNearestNeighborsNode: import("../NodeDefinition.js").NodeDefinition<DatasetNearestNeighborsNode>;
+export {};

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

@@ -0,0 +1,20 @@
+import { type ChartNode, type NodeConnection, 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 DelayNode = ChartNode<'delay', DelayNodeData>;
+export type DelayNodeData = {
+    delay: number;
+    useDelayInput?: boolean;
+};
+export declare class DelayNodeImpl extends NodeImpl<DelayNode> {
+    #private;
+    static create(): DelayNode;
+    getInputDefinitions(connections: NodeConnection[]): NodeInputDefinition[];
+    getOutputDefinitions(connections: NodeConnection[]): NodeOutputDefinition[];
+    static getUIData(): NodeUIData;
+    getEditors(): EditorDefinition<DelayNode>[];
+    getBody(): string | undefined;
+    process(inputData: Inputs): Promise<Outputs>;
+}
+export declare const delayNode: import("../NodeDefinition.js").NodeDefinition<DelayNode>;

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

@@ -0,0 +1,25 @@
+import type { ChartNode, NodeInputDefinition, NodeOutputDefinition } from '../NodeBase.js';
+import type { GraphId } from '../NodeGraph.js';
+import { NodeImpl, type NodeBody, type NodeUIData } from '../NodeImpl.js';
+import type { EditorDefinition } from '../EditorDefinition.js';
+import type { RivetUIContext } from '../RivetUIContext.js';
+import type { InternalProcessContext } from '../ProcessContext.js';
+import type { Inputs, Outputs } from '../GraphProcessor.js';
+export type DelegateFunctionCallNode = ChartNode<'delegateFunctionCall', DelegateFunctionCallNodeData>;
+export type DelegateFunctionCallNodeData = {
+    handlers: {
+        key: string;
+        value: GraphId;
+    }[];
+    unknownHandler: GraphId | undefined;
+};
+export declare class DelegateFunctionCallNodeImpl extends NodeImpl<DelegateFunctionCallNode> {
+    static create(): DelegateFunctionCallNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    static getUIData(): NodeUIData;
+    getEditors(): EditorDefinition<DelegateFunctionCallNode>[];
+    getBody(context: RivetUIContext): NodeBody;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const delegateFunctionCallNode: import("../NodeDefinition.js").NodeDefinition<DelegateFunctionCallNode>;

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

@@ -0,0 +1,18 @@
+import { type ChartNode, type NodeInputDefinition, type PortId, 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 DestructureNode = ChartNode<'destructure', DestructureNodeData>;
+export type DestructureNodeData = {
+    paths: string[];
+};
+export declare class DestructureNodeImpl extends NodeImpl<DestructureNode> {
+    static create(): DestructureNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<DestructureNode>[];
+    getBody(): string | NodeBodySpec | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Record<PortId, DataValue>): Promise<Record<PortId, DataValue>>;
+}
+export declare const destructureNode: import("../NodeDefinition.js").NodeDefinition<DestructureNode>;

package/dist/types/model/nodes/EvaluateNode.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 Inputs, type Outputs } from '../GraphProcessor.js';
+import { type EditorDefinition } from '../../index.js';
+export type EvaluateNode = ChartNode<'evaluate', EvaluateNodeData>;
+export type EvaluateNodeData = {
+    operation: '+' | '-' | '*' | '/' | '^' | '%' | 'abs' | 'negate';
+    useOperationInput?: boolean;
+};
+export declare class EvaluateNodeImpl extends NodeImpl<EvaluateNode> {
+    static create(): EvaluateNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<EvaluateNode>[];
+    getBody(): string | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs): Promise<Outputs>;
+}
+export declare const evaluateNode: import("../NodeDefinition.js").NodeDefinition<EvaluateNode>;

package/dist/types/model/nodes/ExternalCallNode.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 InternalProcessContext } from '../ProcessContext.js';
+import { type EditorDefinition } from '../EditorDefinition.js';
+import { type NodeBodySpec } from '../NodeBodySpec.js';
+export type ExternalCallNode = ChartNode<'externalCall', ExternalCallNodeData>;
+export type ExternalCallNodeData = {
+    functionName: string;
+    useFunctionNameInput: boolean;
+    useErrorOutput: boolean;
+};
+export declare class ExternalCallNodeImpl extends NodeImpl<ExternalCallNode> {
+    static create(): ExternalCallNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<ExternalCallNode>[];
+    getBody(): string | NodeBodySpec | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const externalCallNode: import("../NodeDefinition.js").NodeDefinition<ExternalCallNode>;

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

@@ -0,0 +1,13 @@
+import { type ChartNode, type NodeInputDefinition, type PortId, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type DataValue } from '../DataValue.js';
+export type ExtractJsonNode = ChartNode<'extractJson', ExtractJsonNodeData>;
+export type ExtractJsonNodeData = {};
+export declare class ExtractJsonNodeImpl extends NodeImpl<ExtractJsonNode> {
+    static create(): ExtractJsonNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    static getUIData(): NodeUIData;
+    process(inputs: Record<PortId, DataValue>): Promise<Record<PortId, DataValue>>;
+}
+export declare const extractJsonNode: import("../NodeDefinition.js").NodeDefinition<ExtractJsonNode>;

package/dist/types/model/nodes/ExtractMarkdownCodeBlocksNode.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, Outputs } from '../GraphProcessor.js';
+export type ExtractMarkdownCodeBlocksNode = ChartNode<'extractMarkdownCodeBlocks', {}>;
+export declare class ExtractMarkdownCodeBlocksNodeImpl extends NodeImpl<ExtractMarkdownCodeBlocksNode> {
+    static create(): ExtractMarkdownCodeBlocksNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs): Promise<Outputs>;
+}
+export declare const extractMarkdownCodeBlocksNode: import("../NodeDefinition.js").NodeDefinition<ExtractMarkdownCodeBlocksNode>;

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

@@ -0,0 +1,19 @@
+import { type ChartNode, type NodeInputDefinition, type PortId, 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 ExtractObjectPathNode = ChartNode<'extractObjectPath', ExtractObjectPathNodeData>;
+export type ExtractObjectPathNodeData = {
+    path: string;
+    usePathInput: boolean;
+};
+export declare class ExtractObjectPathNodeImpl extends NodeImpl<ExtractObjectPathNode> {
+    static create(): ExtractObjectPathNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<ExtractObjectPathNode>[];
+    getBody(): string | NodeBodySpec | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Record<PortId, DataValue>): Promise<Record<PortId, DataValue>>;
+}
+export declare const extractObjectPathNode: import("../NodeDefinition.js").NodeDefinition<ExtractObjectPathNode>;

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

@@ -0,0 +1,22 @@
+import { type ChartNode, type NodeInputDefinition, type PortId, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type DataValue } from '../DataValue.js';
+import { type EditorDefinition } from '../EditorDefinition.js';
+import { type NodeBodySpec } from '../NodeBodySpec.js';
+export type ExtractRegexNode = ChartNode<'extractRegex', ExtractRegexNodeData>;
+export type ExtractRegexNodeData = {
+    regex: string;
+    useRegexInput: boolean;
+    errorOnFailed: boolean;
+    multilineMode?: boolean;
+};
+export declare class ExtractRegexNodeImpl extends NodeImpl<ExtractRegexNode> {
+    static create(): ExtractRegexNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<ExtractRegexNode>[];
+    getBody(): string | NodeBodySpec | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Record<PortId, DataValue>): Promise<Record<PortId, DataValue>>;
+}
+export declare const extractRegexNode: import("../NodeDefinition.js").NodeDefinition<ExtractRegexNode>;

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

@@ -0,0 +1,21 @@
+import { type ChartNode, type NodeInputDefinition, type PortId, 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 ExtractYamlNode = ChartNode<'extractYaml', ExtractYamlNodeData>;
+export type ExtractYamlNodeData = {
+    rootPropertyName: string;
+    useRootPropertyNameInput?: boolean;
+    objectPath?: string;
+    useObjectPathInput?: boolean;
+};
+export declare class ExtractYamlNodeImpl extends NodeImpl<ExtractYamlNode> {
+    static create(): ExtractYamlNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<ExtractYamlNode>[];
+    getBody(): string | NodeBodySpec | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Record<PortId, DataValue>): Promise<Record<PortId, DataValue>>;
+}
+export declare const extractYamlNode: import("../NodeDefinition.js").NodeDefinition<ExtractYamlNode>;

package/dist/types/model/nodes/FilterNode.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 FilterNode = ChartNode<'filter', FilterNodeData>;
+export type FilterNodeData = {};
+export declare class FilterNodeImpl extends NodeImpl<FilterNode> {
+    static create(): FilterNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs): Promise<Outputs>;
+}
+export declare const filterNode: import("../NodeDefinition.js").NodeDefinition<FilterNode>;

package/dist/types/model/nodes/GetAllDatasetsNode.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 GetAllDatasetsNode = ChartNode<'getAllDatasets', GetAllDatasetsNodeData>;
+type GetAllDatasetsNodeData = {};
+export declare class GetAllDatasetsNodeImpl extends NodeImpl<GetAllDatasetsNode> {
+    static create(): GetAllDatasetsNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    static getUIData(): NodeUIData;
+    getEditors(): EditorDefinition<GetAllDatasetsNode>[] | Promise<EditorDefinition<GetAllDatasetsNode>[]>;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const getAllDatasetsNode: import("../NodeDefinition.js").NodeDefinition<GetAllDatasetsNode>;
+export {};

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

@@ -0,0 +1,19 @@
+import type { ChartNode, DatasetId, Inputs, InternalProcessContext, NodeInputDefinition, NodeOutputDefinition, NodeUIData, Outputs, EditorDefinition } from '../../index.js';
+import { NodeImpl } from '../NodeImpl.js';
+export type GetDatasetRowNode = ChartNode<'getDatasetRow', GetDatasetRowNodeData>;
+type GetDatasetRowNodeData = {
+    datasetId: DatasetId;
+    useDatasetIdInput?: boolean;
+    rowId: string;
+    useRowIdInput?: boolean;
+};
+export declare class GetDatasetRowNodeImpl extends NodeImpl<GetDatasetRowNode> {
+    static create(): GetDatasetRowNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    static getUIData(): NodeUIData;
+    getEditors(): EditorDefinition<GetDatasetRowNode>[] | Promise<EditorDefinition<GetDatasetRowNode>[]>;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const getDatasetRowNode: import("../NodeDefinition.js").NodeDefinition<GetDatasetRowNode>;
+export {};

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

@@ -0,0 +1,24 @@
+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 InternalProcessContext } from '../ProcessContext.js';
+import { type EditorDefinition } from '../../index.js';
+export type GetEmbeddingNode = ChartNode<'getEmbedding', GetEmbeddingNodeData>;
+export type GetEmbeddingNodeData = {
+    integration: string;
+    model?: string;
+    dimensions?: number;
+    useIntegrationInput?: boolean;
+    useModelInput?: boolean;
+    useDimensionsInput?: boolean;
+};
+export declare class GetEmbeddingNodeImpl extends NodeImpl<GetEmbeddingNode> {
+    static create(): GetEmbeddingNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<GetEmbeddingNode>[];
+    getBody(): string | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const getEmbeddingNode: import("../NodeDefinition.js").NodeDefinition<GetEmbeddingNode>;

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

@@ -0,0 +1,29 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type ScalarOrArrayDataType } from '../DataValue.js';
+import { type Inputs, type Outputs } from '../GraphProcessor.js';
+import { type InternalProcessContext } from '../ProcessContext.js';
+import { type EditorDefinition, type NodeBodySpec } from '../../index.js';
+export type GetGlobalNode = ChartNode<'getGlobal', GetGlobalNodeData>;
+export type GetGlobalNodeData = {
+    id: string;
+    useIdInput: boolean;
+    dataType: ScalarOrArrayDataType;
+    /**
+     * Returns a fn<value> instead of a value, so that the variable is read when nodes need it, rather than when this node executes.
+     * The only time you wouldn't want this is to read a global at the start of a subgraph.
+     */
+    onDemand: boolean;
+    /** Wait until the variable is available */
+    wait: boolean;
+};
+export declare class GetGlobalNodeImpl extends NodeImpl<GetGlobalNode> {
+    static create(): GetGlobalNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<GetGlobalNode>[];
+    getBody(): string | NodeBodySpec | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const getGlobalNode: import("../NodeDefinition.js").NodeDefinition<GetGlobalNode>;

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

@@ -0,0 +1,25 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type EditorDefinition } from '../EditorDefinition.js';
+import { type NodeBodySpec } from '../NodeBodySpec.js';
+import type { Inputs, Outputs } from '../GraphProcessor.js';
+export type GptFunctionNode = ChartNode<'gptFunction', GptFunctionNodeData>;
+export type GptFunctionNodeData = {
+    name: string;
+    useNameInput?: boolean;
+    description: string;
+    useDescriptionInput?: boolean;
+    schema: string;
+    useSchemaInput?: boolean;
+    strict?: boolean;
+};
+export declare class GptFunctionNodeImpl extends NodeImpl<GptFunctionNode> {
+    static create(): GptFunctionNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<GptFunctionNode>[];
+    getBody(): string | NodeBodySpec | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs): Promise<Outputs>;
+}
+export declare const gptFunctionNode: import("../NodeDefinition.js").NodeDefinition<GptFunctionNode>;

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

@@ -0,0 +1,24 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type DataType, type DataValue } from '../DataValue.js';
+import { type Inputs } from '../GraphProcessor.js';
+import { type InternalProcessContext } from '../ProcessContext.js';
+import { type DynamicEditorEditor, type EditorDefinition, type NodeBodySpec } from '../../index.js';
+export type GraphInputNode = ChartNode<'graphInput', GraphInputNodeData>;
+export type GraphInputNodeData = {
+    id: string;
+    dataType: DataType;
+    defaultValue?: unknown;
+    useDefaultValueInput?: boolean;
+    editor?: DynamicEditorEditor;
+};
+export declare class GraphInputNodeImpl extends NodeImpl<GraphInputNode> {
+    static create(): GraphInputNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<GraphInputNode>[];
+    getBody(): string | NodeBodySpec | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Record<string, DataValue>>;
+}
+export declare const graphInputNode: import("../NodeDefinition.js").NodeDefinition<GraphInputNode>;

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

@@ -0,0 +1,22 @@
+import { type ChartNode, type NodeOutputDefinition, type NodeInputDefinition } 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 GraphOutputNode = ChartNode<'graphOutput', GraphOutputNodeData>;
+export type GraphOutputNodeData = {
+    id: string;
+    dataType: DataType;
+};
+export declare class GraphOutputNodeImpl extends NodeImpl<GraphOutputNode> {
+    static create(): GraphOutputNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<GraphOutputNode>[];
+    getBody(): string | NodeBodySpec | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const graphOutputNode: import("../NodeDefinition.js").NodeDefinition<GraphOutputNode>;

package/dist/types/model/nodes/GraphReferenceNode.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 GraphId } from '../NodeGraph.js';
+import { type InternalProcessContext } from '../ProcessContext.js';
+import { type EditorDefinition } from '../../index.js';
+import type { RivetUIContext } from '../RivetUIContext.js';
+export type GraphReferenceNode = ChartNode<'graphReference', GraphReferenceNodeData>;
+export type GraphReferenceNodeData = {
+    graphId: GraphId;
+    useGraphIdOrNameInput: boolean;
+};
+export declare class GraphReferenceNodeImpl extends NodeImpl<GraphReferenceNode> {
+    static create(): GraphReferenceNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<GraphReferenceNode>[];
+    static getUIData(): NodeUIData;
+    getBody(context: RivetUIContext): string;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const graphReferenceNode: import("../NodeDefinition.js").NodeDefinition<GraphReferenceNode>;

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

@@ -0,0 +1,17 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type EditorDefinition, type Inputs, type Outputs } from '../../index.js';
+export type HashNode = ChartNode<'hash', HashNodeData>;
+export type HashNodeData = {
+    algorithm: 'md5' | 'sha1' | 'sha256' | 'sha512';
+};
+export declare class HashNodeImpl extends NodeImpl<HashNode> {
+    static create(): HashNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<HashNode>[];
+    getBody(): string | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs): Promise<Outputs>;
+}
+export declare const hashNode: import("../NodeDefinition.js").NodeDefinition<HashNode>;

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

@@ -0,0 +1,27 @@
+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, type InternalProcessContext } from '../../index.js';
+export type HttpCallNode = ChartNode<'httpCall', HttpCallNodeData>;
+export type HttpCallNodeData = {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    useMethodInput?: boolean;
+    url: string;
+    useUrlInput?: boolean;
+    headers: string;
+    useHeadersInput?: boolean;
+    body: string;
+    useBodyInput?: boolean;
+    isBinaryOutput?: boolean;
+    errorOnNon200?: boolean;
+};
+export declare class HttpCallNodeImpl extends NodeImpl<HttpCallNode> {
+    static create(): HttpCallNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<HttpCallNode>[];
+    getBody(): string;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const httpCallNode: import("../NodeDefinition.js").NodeDefinition<HttpCallNode>;