@alpic80/rivet-core 1.19.1-aidon.1

package/dist/types/plugins/google/index.d.ts

@@ -0,0 +1,2 @@
+import { googlePlugin } from './plugin.js';
+export default googlePlugin;

package/dist/types/plugins/google/nodes/ChatGoogleNode.d.ts

@@ -0,0 +1,27 @@
+import { type ChartNode, type ChatMessage, type Inputs, type PluginNodeImpl } from '../../../index.js';
+import { type GoogleModels } from '../google.js';
+export type ChatGoogleNode = ChartNode<'chatGoogle', ChatGoogleNodeData>;
+export type ChatGoogleNodeConfigData = {
+    model: GoogleModels;
+    temperature: number;
+    useTopP: boolean;
+    top_p?: number;
+    top_k?: number;
+    maxTokens: number;
+};
+export type ChatGoogleNodeData = ChatGoogleNodeConfigData & {
+    useModelInput: boolean;
+    useTemperatureInput: boolean;
+    useTopPInput: boolean;
+    useTopKInput: boolean;
+    useUseTopPInput: boolean;
+    useMaxTokensInput: boolean;
+    /** Given the same set of inputs, return the same output without hitting GPT */
+    cache: boolean;
+    useAsGraphPartialOutput?: boolean;
+};
+export declare const ChatGoogleNodeImpl: PluginNodeImpl<ChatGoogleNode>;
+export declare const chatGoogleNode: import("../../../index.js").PluginNodeDefinition<ChatGoogleNode>;
+export declare function getChatGoogleNodeMessages(inputs: Inputs): {
+    messages: ChatMessage[];
+};

package/dist/types/plugins/google/plugin.d.ts

@@ -0,0 +1,2 @@
+import { type RivetPlugin } from '../../index.js';
+export declare const googlePlugin: RivetPlugin;

package/dist/types/plugins/huggingface/index.d.ts

@@ -0,0 +1,2 @@
+import { huggingFacePlugin } from './plugin.js';
+export default huggingFacePlugin;

package/dist/types/plugins/huggingface/nodes/ChatHuggingFace.d.ts

@@ -0,0 +1,24 @@
+import { type ChartNode, type PluginNodeImpl } from '../../../index.js';
+export type ChatHuggingFaceNode = ChartNode<'chatHuggingFace', ChatHuggingFaceNodeData>;
+export type ChatHuggingFaceNodeData = {
+    model: string;
+    useModelInput?: boolean;
+    endpoint?: string;
+    useEndpointInput?: boolean;
+    temperature?: number;
+    useTemperatureInput?: boolean;
+    maxNewTokens: number;
+    useMaxNewTokensInput?: boolean;
+    doSample: boolean;
+    useDoSampleInput?: boolean;
+    maxTime?: number;
+    useMaxTimeInput?: boolean;
+    repetitionPenalty?: number;
+    useRepetitionPenaltyInput?: boolean;
+    topP?: number;
+    useTopPInput?: boolean;
+    topK?: number;
+    useTopKInput?: boolean;
+};
+export declare const ChatHuggingFaceNodeImpl: PluginNodeImpl<ChatHuggingFaceNode>;
+export declare const chatHuggingFaceNode: import("../../../index.js").PluginNodeDefinition<ChatHuggingFaceNode>;

package/dist/types/plugins/huggingface/nodes/TextToImageHuggingFace.d.ts

@@ -0,0 +1,20 @@
+import { type ChartNode, type PluginNodeImpl } from '../../../index.js';
+export type TextToImageHuggingFaceNode = ChartNode<'textToImageHuggingFace', TextToImageHuggingFaceNodeData>;
+export type TextToImageHuggingFaceNodeData = {
+    model: string;
+    useModelInput?: boolean;
+    endpoint?: string;
+    useEndpointInput?: boolean;
+    width: number;
+    useWidthInput?: boolean;
+    height: number;
+    useHeightInput?: boolean;
+    negativePrompt?: string;
+    useNegativePromptInput?: boolean;
+    guidanceScale: number;
+    useGuidanceScaleInput?: boolean;
+    numInferenceSteps: number;
+    useNumInferenceStepsInput?: boolean;
+};
+export declare const TextToImageHuggingFaceNodeImpl: PluginNodeImpl<TextToImageHuggingFaceNode>;
+export declare const textToImageHuggingFaceNode: import("../../../index.js").PluginNodeDefinition<TextToImageHuggingFaceNode>;

package/dist/types/plugins/huggingface/plugin.d.ts

@@ -0,0 +1,2 @@
+import { type RivetPlugin } from '../../index.js';
+export declare const huggingFacePlugin: RivetPlugin;

package/dist/types/plugins/openai/handleOpenaiError.d.ts

@@ -0,0 +1 @@
+export declare function handleOpenAIError(response: Response): Promise<void>;

package/dist/types/plugins/openai/index.d.ts

@@ -0,0 +1,2 @@
+import { openAIPlugin } from './plugin.js';
+export default openAIPlugin;

package/dist/types/plugins/openai/nodes/AttachAssistantFileNode.d.ts

@@ -0,0 +1,10 @@
+import { type ChartNode, type PluginNodeImpl } from '../../../index.js';
+export type AttachAssistantFileNode = ChartNode<'openaiAttachAssistantFile', AttachAssistantFileNodeData>;
+export type AttachAssistantFileNodeData = {
+    assistantId?: string;
+    useAssistantIdInput?: boolean;
+    fileId?: string;
+    useFileIdInput?: boolean;
+};
+export declare const AttachAssistantFileNodeImpl: PluginNodeImpl<AttachAssistantFileNode>;
+export declare const attachAssistantFileNode: import("../../../index.js").PluginNodeDefinition<AttachAssistantFileNode>;

package/dist/types/plugins/openai/nodes/CreateAssistantNode.d.ts

@@ -0,0 +1,26 @@
+import { type ChartNode, type PluginNodeImpl, type GptFunction } from '../../../index.js';
+export type CreateAssistantNode = ChartNode<'openaiCreateAssistant', CreateAssistantNodeData>;
+export type CreateAssistantNodeData = {
+    assistantId: string;
+    useAssistantIdInput?: boolean;
+    model?: string;
+    useModelInput?: boolean;
+    name?: string;
+    useNameInput?: boolean;
+    description?: string;
+    useDescriptionInput?: boolean;
+    instructions?: string;
+    useInstructionsInput?: boolean;
+    useCodeInterpreterTool?: boolean;
+    useRetrievalTool?: boolean;
+    functions?: GptFunction[];
+    file_ids?: string[];
+    useFileIdsInput?: boolean;
+    metadata: {
+        key: string;
+        value: string;
+    }[];
+    useMetadataInput?: boolean;
+};
+export declare const CreateAssistantNodeImpl: PluginNodeImpl<CreateAssistantNode>;
+export declare const createAssistantNode: import("../../../index.js").PluginNodeDefinition<CreateAssistantNode>;

package/dist/types/plugins/openai/nodes/CreateThreadMessageNode.d.ts

@@ -0,0 +1,15 @@
+import { type ChartNode, type PluginNodeImpl } from '../../../index.js';
+export type CreateThreadMessageNode = ChartNode<'openaiCreateThreadMessage', CreateThreadMessageNodeData>;
+export type CreateThreadMessageNodeData = {
+    threadId: string;
+    useThreadIdInput?: boolean;
+    file_ids: string[];
+    useFileIdsInput?: boolean;
+    metadata: {
+        key: string;
+        value: string;
+    }[];
+    useMetadataInput?: boolean;
+};
+export declare const CreateThreadMessageNodeImpl: PluginNodeImpl<CreateThreadMessageNode>;
+export declare const createThreadMessageNode: import("../../../index.js").PluginNodeDefinition<CreateThreadMessageNode>;

package/dist/types/plugins/openai/nodes/CreateThreadNode.d.ts

@@ -0,0 +1,13 @@
+import { type ChartNode, type PluginNodeImpl } from '../../../index.js';
+export type CreateThreadNode = ChartNode<'openaiCreateThread', CreateThreadNodeData>;
+export type CreateThreadNodeData = {
+    threadId?: string;
+    useThreadIdInput?: boolean;
+    metadata: {
+        key: string;
+        value: string;
+    }[];
+    useMetadataInput?: boolean;
+};
+export declare const CreateThreadNodeImpl: PluginNodeImpl<CreateThreadNode>;
+export declare const createThreadNode: import("../../../index.js").PluginNodeDefinition<CreateThreadNode>;

package/dist/types/plugins/openai/nodes/DeleteAssistantNode.d.ts

@@ -0,0 +1,8 @@
+import { type ChartNode, type PluginNodeImpl } from '../../../index.js';
+export type DeleteAssistantNode = ChartNode<'openaiDeleteAssistant', DeleteAssistantNodeData>;
+export type DeleteAssistantNodeData = {
+    assistantId: string;
+    useAssistantIdInput?: boolean;
+};
+export declare const DeleteAssistantNodeImpl: PluginNodeImpl<DeleteAssistantNode>;
+export declare const deleteAssistantNode: import("../../../index.js").PluginNodeDefinition<DeleteAssistantNode>;

package/dist/types/plugins/openai/nodes/DeleteThreadNode.d.ts

@@ -0,0 +1,8 @@
+import { type ChartNode, type PluginNodeImpl } from '../../../index.js';
+export type DeleteThreadNode = ChartNode<'openaiDeleteThread', DeleteThreadNodeData>;
+export type DeleteThreadNodeData = {
+    threadId: string;
+    useThreadIdInput?: boolean;
+};
+export declare const DeleteThreadNodeImpl: PluginNodeImpl<DeleteThreadNode>;
+export declare const deleteThreadNode: import("../../../index.js").PluginNodeDefinition<DeleteThreadNode>;

package/dist/types/plugins/openai/nodes/GetAssistantNode.d.ts

@@ -0,0 +1,8 @@
+import { type ChartNode, type PluginNodeImpl } from '../../../index.js';
+export type GetAssistantNode = ChartNode<'openaiGetAssistant', GetAssistantNodeData>;
+export type GetAssistantNodeData = {
+    assistantId?: string;
+    useAssistantIdInput?: boolean;
+};
+export declare const GetAssistantNodeImpl: PluginNodeImpl<GetAssistantNode>;
+export declare const getAssistantNode: import("../../../index.js").PluginNodeDefinition<GetAssistantNode>;

package/dist/types/plugins/openai/nodes/GetOpenAIFileNode.d.ts

@@ -0,0 +1,8 @@
+import { type ChartNode, type PluginNodeImpl } from '../../../index.js';
+export type GetOpenAIFileNode = ChartNode<'openaiGetFile', GetOpenAIFileNodeData>;
+export type GetOpenAIFileNodeData = {
+    fileId?: string;
+    useFileIdInput?: boolean;
+};
+export declare const GetOpenAIFileNodeImpl: PluginNodeImpl<GetOpenAIFileNode>;
+export declare const getOpenAIFileNode: import("../../../index.js").PluginNodeDefinition<GetOpenAIFileNode>;

package/dist/types/plugins/openai/nodes/GetThreadNode.d.ts

@@ -0,0 +1,8 @@
+import { type ChartNode, type PluginNodeImpl } from '../../../index.js';
+export type GetThreadNode = ChartNode<'openaiGetThread', GetThreadNodeData>;
+export type GetThreadNodeData = {
+    threadId: string;
+    useThreadIdInput?: boolean;
+};
+export declare const GetThreadNodeImpl: PluginNodeImpl<GetThreadNode>;
+export declare const getThreadNode: import("../../../index.js").PluginNodeDefinition<GetThreadNode>;

package/dist/types/plugins/openai/nodes/ListAssistantsNode.d.ts

@@ -0,0 +1,14 @@
+import { type ChartNode, type PluginNodeImpl } from '../../../index.js';
+export type ListAssistantsNode = ChartNode<'openaiListAssistants', ListAssistantsNodeData>;
+export type ListAssistantsNodeData = {
+    limit?: number;
+    useLimitInput?: boolean;
+    order?: string;
+    useOrderInput?: boolean;
+    after?: string;
+    useAfterInput?: boolean;
+    before?: string;
+    useBeforeInput?: boolean;
+};
+export declare const ListAssistantsNodeImpl: PluginNodeImpl<ListAssistantsNode>;
+export declare const listAssistantsNode: import("../../../index.js").PluginNodeDefinition<ListAssistantsNode>;

package/dist/types/plugins/openai/nodes/ListOpenAIFilesNode.d.ts

@@ -0,0 +1,8 @@
+import { type ChartNode, type PluginNodeImpl } from '../../../index.js';
+export type ListOpenAIFilesNode = ChartNode<'openaiListFiles', ListOpenAIFilesNodeData>;
+export type ListOpenAIFilesNodeData = {
+    purpose?: 'fine-tune' | 'fine-tune-results' | 'assistants' | 'assistants_output';
+    usePurposeInput?: boolean;
+};
+export declare const ListOpenAIFilesNodeImpl: PluginNodeImpl<ListOpenAIFilesNode>;
+export declare const listOpenAIFilesNode: import("../../../index.js").PluginNodeDefinition<ListOpenAIFilesNode>;

package/dist/types/plugins/openai/nodes/ListThreadMessagesNode.d.ts

@@ -0,0 +1,16 @@
+import { type ChartNode, type PluginNodeImpl } from '../../../index.js';
+export type ListThreadMessagesNode = ChartNode<'openaiListThreadMessages', ListThreadMessagesNodeData>;
+export type ListThreadMessagesNodeData = {
+    threadId: string;
+    useThreadIdInput?: boolean;
+    limit?: number;
+    useLimitInput?: boolean;
+    order?: string;
+    useOrderInput?: boolean;
+    after?: string;
+    useAfterInput?: boolean;
+    before?: string;
+    useBeforeInput?: boolean;
+};
+export declare const ListThreadMessagesNodeImpl: PluginNodeImpl<ListThreadMessagesNode>;
+export declare const listThreadMessagesNode: import("../../../index.js").PluginNodeDefinition<ListThreadMessagesNode>;

package/dist/types/plugins/openai/nodes/RunThreadNode.d.ts

@@ -0,0 +1,28 @@
+import { type ChartNode, type PluginNodeImpl, type GptFunction, type GraphId } from '../../../index.js';
+export type RunThreadNode = ChartNode<'openaiRunThread', RunThreadNodeData>;
+export type RunThreadNodeData = {
+    createThread: boolean;
+    threadId: string;
+    useThreadIdInput?: boolean;
+    assistantId: string;
+    useAssistantIdInput?: boolean;
+    model?: string;
+    useModelInput?: boolean;
+    instructions?: string;
+    useInstructionsInput?: boolean;
+    useCodeInterpreterTool?: boolean;
+    useRetrievalTool?: boolean;
+    functions?: GptFunction[];
+    metadata: {
+        key: string;
+        value: string;
+    }[];
+    useMetadataInput?: boolean;
+    toolCallHandlers: {
+        key: string;
+        value: GraphId;
+    }[];
+    onMessageCreationSubgraphId?: GraphId;
+};
+export declare const RunThreadNodeImpl: PluginNodeImpl<RunThreadNode>;
+export declare const runThreadNode: import("../../../index.js").PluginNodeDefinition<RunThreadNode>;

package/dist/types/plugins/openai/nodes/ThreadMessageNode.d.ts

@@ -0,0 +1,14 @@
+import { type ChartNode, type PluginNodeImpl } from '../../../index.js';
+export type ThreadMessageNode = ChartNode<'threadMessage', ThreadMessageNodeData>;
+export type ThreadMessageNodeData = {
+    text: string;
+    fileIds?: string[];
+    useFileIdsInput?: boolean;
+    metadata: {
+        key: string;
+        value: string;
+    }[];
+    useMetadataInput?: boolean;
+};
+export declare const ThreadMessageNodeImpl: PluginNodeImpl<ThreadMessageNode>;
+export declare const threadMessageNode: import("../../../index.js").PluginNodeDefinition<ThreadMessageNode>;

package/dist/types/plugins/openai/nodes/UploadFileNode.d.ts

@@ -0,0 +1,7 @@
+import { type ChartNode, type PluginNodeImpl } from '../../../index.js';
+export type UploadFileNode = ChartNode<'openaiUploadFile', UploadFileNodeData>;
+export type UploadFileNodeData = {
+    purpose: 'fine-tune' | 'assistants' | 'assistants_output';
+};
+export declare const UploadFileNodeImpl: PluginNodeImpl<UploadFileNode>;
+export declare const uploadFileNode: import("../../../index.js").PluginNodeDefinition<UploadFileNode>;

package/dist/types/plugins/openai/plugin.d.ts

@@ -0,0 +1,2 @@
+import { type RivetPlugin } from '../../index.js';
+export declare const openAIPlugin: RivetPlugin;

package/dist/types/plugins/pinecone/PineconeVectorDatabase.d.ts

@@ -0,0 +1,9 @@
+import { type ArrayDataValue, type DataValue, type ScalarDataValue, type Settings, type VectorDataValue, type VectorDatabase } from '../../index.js';
+export declare class PineconeVectorDatabase implements VectorDatabase {
+    #private;
+    constructor(settings: Settings);
+    store(collection: DataValue, vector: VectorDataValue, data: DataValue, { id }: {
+        id?: string;
+    }): Promise<void>;
+    nearestNeighbors(collection: DataValue, vector: VectorDataValue, k: number): Promise<ArrayDataValue<ScalarDataValue>>;
+}

package/dist/types/plugins/pinecone/index.d.ts

@@ -0,0 +1,2 @@
+import { pineconePlugin } from './plugin.js';
+export default pineconePlugin;

package/dist/types/plugins/pinecone/plugin.d.ts

@@ -0,0 +1,2 @@
+import { type RivetPlugin } from '../../index.js';
+export declare const pineconePlugin: RivetPlugin;

package/dist/types/plugins.d.ts

@@ -0,0 +1,20 @@
+import aidonPlugin from './plugins/aidon/index.js';
+import anthropicPlugin from './plugins/anthropic/index.js';
+import autoevalsPlugin from './plugins/autoevals/index.js';
+import assemblyAiPlugin from './plugins/assemblyAi/index.js';
+import { huggingFacePlugin } from './plugins/huggingface/plugin.js';
+import pineconePlugin from './plugins/pinecone/index.js';
+import gentracePlugin from './plugins/gentrace/index.js';
+import { googlePlugin } from './plugins/google/plugin.js';
+export { aidonPlugin, anthropicPlugin, autoevalsPlugin, assemblyAiPlugin, pineconePlugin, huggingFacePlugin, gentracePlugin, googlePlugin, };
+export declare const plugins: {
+    aidon: import("./index.js").RivetPlugin;
+    anthropic: import("./index.js").RivetPlugin;
+    autoevals: import("./index.js").RivetPlugin;
+    assemblyAi: import("./index.js").RivetPlugin;
+    pinecone: import("./index.js").RivetPlugin;
+    huggingFace: import("./index.js").RivetPlugin;
+    gentrace: import("./index.js").RivetPlugin;
+    openai: import("./index.js").RivetPlugin;
+    google: import("./index.js").RivetPlugin;
+};

package/dist/types/recording/ExecutionRecorder.d.ts

@@ -0,0 +1,25 @@
+import { type GraphProcessor, type RecordedEvents, type Recording, type RecordingId } from '../index.js';
+import Emittery from 'emittery';
+export type ExecutionRecorderEvents = {
+    finish: {
+        recording: Recording;
+    };
+};
+export type ExecutionRecorderOptions = {
+    includePartialOutputs?: boolean;
+    includeTrace?: boolean;
+};
+export declare class ExecutionRecorder {
+    #private;
+    recordingId: RecordingId | undefined;
+    constructor(options?: ExecutionRecorderOptions);
+    on: Emittery<ExecutionRecorderEvents>['on'];
+    off: Emittery<ExecutionRecorderEvents>['off'];
+    once: Emittery<ExecutionRecorderEvents>['once'];
+    recordSocket(channel: WebSocket): Promise<void>;
+    record(processor: GraphProcessor): void;
+    getRecording(): Recording;
+    get events(): RecordedEvents[];
+    static deserializeFromString(serialized: string): ExecutionRecorder;
+    serialize(): string;
+}

package/dist/types/recording/RecordedEvents.d.ts

@@ -0,0 +1,100 @@
+import type { Opaque, OverrideProperties } from 'type-fest';
+import { type ProcessEvents, type ProjectId, type GraphInputs, type DataValue, type GraphId, type GraphOutputs, type NodeId, type Inputs, type ProcessId, type Outputs, type StringArrayDataValue } from '../index.js';
+export type RecordingId = Opaque<string, 'RecordingId'>;
+export type RecordedEventsMap = OverrideProperties<ProcessEvents, {
+    start: {
+        projectId: ProjectId;
+        inputs: GraphInputs;
+        contextValues: Record<string, DataValue>;
+        startGraph: GraphId;
+    };
+    /** Called when a graph or subgraph has started. */
+    graphStart: {
+        graphId: GraphId;
+        inputs: GraphInputs;
+    };
+    /** Called when a graph or subgraph has errored. */
+    graphError: {
+        graphId: GraphId;
+        error: Error | string;
+    };
+    /** Called when a graph or a subgraph has finished. */
+    graphFinish: {
+        graphId: GraphId;
+        outputs: GraphOutputs;
+    };
+    /** Called when a graph or subgraph has been aborted. */
+    graphAbort: {
+        graphId: GraphId;
+        error?: string;
+        successful: boolean;
+    };
+    /** Called when a node has started processing, with the input values for the node. */
+    nodeStart: {
+        nodeId: NodeId;
+        inputs: Inputs;
+        processId: ProcessId;
+    };
+    /** Called when a node has finished processing, with the output values for the node. */
+    nodeFinish: {
+        nodeId: NodeId;
+        outputs: Outputs;
+        processId: ProcessId;
+    };
+    /** Called when a node has errored during processing. */
+    nodeError: {
+        nodeId: NodeId;
+        error: string;
+        processId: ProcessId;
+    };
+    /** Called when a node has been excluded from processing. */
+    nodeExcluded: {
+        nodeId: NodeId;
+        processId: ProcessId;
+        inputs: Inputs;
+        outputs: Outputs;
+        reason: string;
+    };
+    /** Called when a user input node requires user input. Call the callback when finished, or call userInput() on the GraphProcessor with the results. */
+    userInput: {
+        nodeId: NodeId;
+        inputs: Inputs;
+        callback: (values: StringArrayDataValue) => void;
+        processId: ProcessId;
+    };
+    /** Called when a node has partially processed, with the current partial output values for the node. */
+    partialOutput: {
+        nodeId: NodeId;
+        outputs: Outputs;
+        index: number;
+        processId: ProcessId;
+    };
+    /** Called when the outputs of a node have been cleared entirely. If processId is present, only the one process() should be cleared. */
+    nodeOutputsCleared: {
+        nodeId: NodeId;
+        processId?: ProcessId;
+    };
+    /** Called when the root graph has errored. The root graph will also throw. */
+    error: {
+        error: string;
+    };
+    newAbortController: undefined;
+}>;
+export type RecordedEvent<T extends keyof ProcessEvents> = {
+    type: T;
+    data: RecordedEventsMap[T];
+    ts: number;
+};
+export type RecordedEvents = Pick<{
+    [K in keyof RecordedEventsMap]: RecordedEvent<K>;
+}, keyof RecordedEventsMap>[keyof RecordedEventsMap];
+export type Recording = {
+    recordingId: RecordingId;
+    startTs: number;
+    finishTs: number;
+    events: RecordedEvents[];
+};
+export type SerializedRecording = {
+    version: number;
+    recording: Recording;
+};

package/dist/types/utils/assertNever.d.ts

@@ -0,0 +1 @@
+export declare function assertNever(x: never): never;

package/dist/types/utils/base64.d.ts

@@ -0,0 +1,2 @@
+export declare function uint8ArrayToBase64(uint8Array: Uint8Array): Promise<string | undefined>;
+export declare function base64ToUint8Array(base64: string): Uint8Array;

package/dist/types/utils/chatMessageToOpenAIChatCompletionMessage.d.ts

@@ -0,0 +1,3 @@
+import type { ChatMessage } from '../index.js';
+import type { ChatCompletionRequestMessage } from './openai.js';
+export declare function chatMessageToOpenAIChatCompletionMessage(message: ChatMessage): Promise<ChatCompletionRequestMessage>;

package/dist/types/utils/coerceType.d.ts

@@ -0,0 +1,6 @@
+import { type DataType, type DataValue, type GetDataValue } from '../model/DataValue.js';
+export declare function coerceTypeOptional<T extends DataType>(wrapped: DataValue | undefined, type: T): GetDataValue<T>['value'] | undefined;
+export declare function coerceType<T extends DataType>(value: DataValue | undefined, type: T): GetDataValue<T>['value'];
+export declare function inferType(value: unknown): DataValue;
+export declare function canBeCoercedAny(from: DataType | Readonly<DataType[]>, to: DataType | Readonly<DataType[]>): boolean;
+export declare function canBeCoerced(from: DataType, to: DataType): boolean;

package/dist/types/utils/compatibility.d.ts

@@ -0,0 +1,3 @@
+import { type DataType } from '../model/DataValue.js';
+export declare function isDataTypeAccepted(inputType: DataType | Readonly<DataType[]>, accepted: DataType | Readonly<DataType[]>): boolean;
+export declare function isDataTypeCompatible(inputType: DataType, accepted: DataType): boolean;

package/dist/types/utils/copyToClipboard.d.ts

@@ -0,0 +1 @@
+export declare const copyToClipboard: (text: string) => void;

package/dist/types/utils/defaults.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_CHAT_ENDPOINT = "https://api.openai.com/v1/chat/completions";
+export declare const DEFAULT_CHAT_NODE_TIMEOUT = 30000;

package/dist/types/utils/errors.d.ts

@@ -0,0 +1,2 @@
+/** Gets an Error from an unknown error object (strict unknown errors is enabled, helper util). */
+export declare function getError(error: unknown): Error;

package/dist/types/utils/expectType.d.ts

@@ -0,0 +1,3 @@
+import { type DataType, type DataValue, type GetDataValue } from '../model/DataValue.js';
+export declare function expectType<T extends DataType>(value: DataValue | undefined, type: T): GetDataValue<T>['value'];
+export declare function expectTypeOptional<T extends DataType>(value: DataValue | undefined, type: T): GetDataValue<T>['value'] | undefined;

package/dist/types/utils/fetchEventSource.d.ts

@@ -0,0 +1,12 @@
+export declare class EventSourceResponse extends Response {
+    name: string;
+    timeout?: number;
+    readonly streams: {
+        eventStream: ReadableStream<string>;
+        textStream: ReadableStream<string>;
+    } | null;
+    constructor(body: ReadableStream<Uint8Array> | null, init?: ResponseInit, timeout?: number);
+    events(): AsyncGenerator<string>;
+    private raceWithTimeout;
+}
+export default function fetchEventSource(url: string, init?: RequestInit, timeout?: number): Promise<EventSourceResponse>;

package/dist/types/utils/genericUtilFunctions.d.ts

@@ -0,0 +1,21 @@
+export declare function isNotNull<T>(value: T | undefined | null): value is T;
+/**
+ * Checks that the given tuple is exhaustive, ie. it represents all possible values in the union T.
+ * Note that this function returns a function, so the function needs to be called like
+ * `SpecificStrings.exhaustiveTuple<Furniture>()('v1', 'v2', ...)`.
+ * If you miss a value, the type error will tell you which value you missed.
+ *
+ * Taken from https://stackoverflow.com/a/55266531/
+ *
+ * @example
+ *   type Furniture = 'chair' | 'table' | 'lamp' | 'ottoman';
+ *   const furniture = SpecificStrings.exhaustiveTuple<Furniture>()('chair', 'table', 'lamp', 'ottoman');
+ *
+ *   // error, argument of type '"chair"' is not assignable to parameter of type '"You are missing ottoman"'.
+ *   const missingFurniture = SpecificStrings.exhaustiveTuple<Furniture>()('chair', 'table', 'lamp');
+ */
+export declare const exhaustiveTuple: <T extends string>() => <L extends T[]>(...x: [T] extends [L[number]] ? L : `You are missing ${Exclude<T, L[number]>}`[]) => [T] extends [L[number]] ? L : `You are missing ${Exclude<T, L[number]>}`[];
+/**
+ * See exhaustiveTuple above. Does the same thing except returns a Set, not an array.
+ */
+export declare const exhaustiveSet: <T extends string>() => <L extends T[]>(...x: [T] extends [L[number]] ? L : `You are missing ${Exclude<T, L[number]>}`[]) => Set<([T] extends [L[number]] ? L : `You are missing ${Exclude<T, L[number]>}`[])[number]>;

package/dist/types/utils/getPluginConfig.d.ts

@@ -0,0 +1,2 @@
+import type { RivetPlugin, Settings } from '../index.js';
+export declare function getPluginConfig(plugin: RivetPlugin | undefined, settings: Settings, name: string): string | undefined;

package/dist/types/utils/handleEscapeCharacters.d.ts

@@ -0,0 +1,2 @@
+/** Let the user type things like \n and \t in the editor, and they'll be replaced with the actual characters. */
+export declare function handleEscapeCharacters(inputString: string): string;

package/dist/types/utils/index.d.ts

@@ -0,0 +1,14 @@
+export * from './coerceType.js';
+export * from './expectType.js';
+export * from './errors.js';
+export * from './serialization/serialization.js';
+export * from './outputs.js';
+export * from './base64.js';
+export * from './inputs.js';
+export * from './misc.js';
+export * from './getPluginConfig.js';
+export * from './newId.js';
+export * from './serialization/serializationUtils.js';
+export * from './handleEscapeCharacters.js';
+export * from './compatibility.js';
+export * from './defaults.js';

package/dist/types/utils/inputs.d.ts

@@ -0,0 +1,3 @@
+import type { DataType, GetDataValue, Inputs } from '../index.js';
+export declare function getInputOrData<Data extends object, T extends DataType = 'string'>(data: Data, inputs: Inputs, inputAndDataKey: keyof Data & string, type?: T, useInputToggleDataKey?: keyof Data & string): GetDataValue<T>['value'];
+export declare function cleanHeaders(headers: Record<string, string>): Record<string, string>;

package/dist/types/utils/interpolation.d.ts

@@ -0,0 +1 @@
+export declare function interpolate(baseString: string, values: Record<string, string>): string;

package/dist/types/utils/misc.d.ts

@@ -0,0 +1 @@
+export { dedent } from 'ts-dedent';

package/dist/types/utils/newId.d.ts

@@ -0,0 +1 @@
+export declare function newId<T extends string>(): T;