vellum-ai 0.3.14 → 0.3.15

package/dist/serialization/types/StreamingExecutePromptEvent.js

@@ -25,22 +25,15 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StreamingExecutePromptEvent = void 0;
 const core = __importStar(require("../../core"));
+const PromptOutput_1 = require("./PromptOutput");
+const StreamingPromptExecutionMeta_1 = require("./StreamingPromptExecutionMeta");
 exports.StreamingExecutePromptEvent = core.serialization.object({
-    output: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).PromptOutput; })),
+    output: PromptOutput_1.PromptOutput,
     outputIndex: core.serialization.property("output_index", core.serialization.number()),
     executionId: core.serialization.property("execution_id", core.serialization.string()),
-    meta: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).StreamingPromptExecutionMeta; })).optional(),
+    meta: StreamingPromptExecutionMeta_1.StreamingPromptExecutionMeta.optional(),
     raw: core.serialization.record(core.serialization.string(), core.serialization.unknown()).optional(),
 });

package/dist/serialization/types/StreamingWorkflowNodeResultEvent.d.ts

@@ -4,6 +4,8 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { WorkflowNodeResultData } from "./WorkflowNodeResultData";
+import { NodeOutputCompiledValue } from "./NodeOutputCompiledValue";
 export declare const StreamingWorkflowNodeResultEvent: core.serialization.ObjectSchema<serializers.StreamingWorkflowNodeResultEvent.Raw, Vellum.StreamingWorkflowNodeResultEvent>;
 export declare namespace StreamingWorkflowNodeResultEvent {
     interface Raw {
@@ -11,9 +13,9 @@ export declare namespace StreamingWorkflowNodeResultEvent {
         node_id: string;
         node_result_id: string;
         ts?: string | null;
-        data?: serializers.WorkflowNodeResultData.Raw | null;
+        data?: WorkflowNodeResultData.Raw | null;
         source_execution_id?: string | null;
-        output?: serializers.NodeOutputCompiledValue.Raw | null;
+        output?: NodeOutputCompiledValue.Raw | null;
         output_index?: number | null;
     }
 }

package/dist/serialization/types/StreamingWorkflowNodeResultEvent.js

@@ -25,25 +25,18 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StreamingWorkflowNodeResultEvent = void 0;
 const core = __importStar(require("../../core"));
+const WorkflowNodeResultData_1 = require("./WorkflowNodeResultData");
+const NodeOutputCompiledValue_1 = require("./NodeOutputCompiledValue");
 exports.StreamingWorkflowNodeResultEvent = core.serialization.object({
     id: core.serialization.string(),
     nodeId: core.serialization.property("node_id", core.serialization.string()),
     nodeResultId: core.serialization.property("node_result_id", core.serialization.string()),
     ts: core.serialization.date().optional(),
-    data: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowNodeResultData; })).optional(),
+    data: WorkflowNodeResultData_1.WorkflowNodeResultData.optional(),
     sourceExecutionId: core.serialization.property("source_execution_id", core.serialization.string().optional()),
-    output: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NodeOutputCompiledValue; })).optional(),
+    output: NodeOutputCompiledValue_1.NodeOutputCompiledValue.optional(),
     outputIndex: core.serialization.property("output_index", core.serialization.number().optional()),
 });

package/dist/serialization/types/SubmitWorkflowExecutionActualRequest.d.ts

@@ -4,16 +4,19 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { WorkflowExecutionActualStringRequest } from "./WorkflowExecutionActualStringRequest";
+import { WorkflowExecutionActualJsonRequest } from "./WorkflowExecutionActualJsonRequest";
+import { WorkflowExecutionActualChatHistoryRequest } from "./WorkflowExecutionActualChatHistoryRequest";
 export declare const SubmitWorkflowExecutionActualRequest: core.serialization.Schema<serializers.SubmitWorkflowExecutionActualRequest.Raw, Vellum.SubmitWorkflowExecutionActualRequest>;
 export declare namespace SubmitWorkflowExecutionActualRequest {
     type Raw = SubmitWorkflowExecutionActualRequest.String | SubmitWorkflowExecutionActualRequest.Json | SubmitWorkflowExecutionActualRequest.ChatHistory;
-    interface String extends serializers.WorkflowExecutionActualStringRequest.Raw {
+    interface String extends WorkflowExecutionActualStringRequest.Raw {
         output_type: "STRING";
     }
-    interface Json extends serializers.WorkflowExecutionActualJsonRequest.Raw {
+    interface Json extends WorkflowExecutionActualJsonRequest.Raw {
         output_type: "JSON";
     }
-    interface ChatHistory extends serializers.WorkflowExecutionActualChatHistoryRequest.Raw {
+    interface ChatHistory extends WorkflowExecutionActualChatHistoryRequest.Raw {
         output_type: "CHAT_HISTORY";
     }
 }

package/dist/serialization/types/SubmitWorkflowExecutionActualRequest.js

@@ -25,23 +25,17 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SubmitWorkflowExecutionActualRequest = void 0;
 const core = __importStar(require("../../core"));
+const WorkflowExecutionActualStringRequest_1 = require("./WorkflowExecutionActualStringRequest");
+const WorkflowExecutionActualJsonRequest_1 = require("./WorkflowExecutionActualJsonRequest");
+const WorkflowExecutionActualChatHistoryRequest_1 = require("./WorkflowExecutionActualChatHistoryRequest");
 exports.SubmitWorkflowExecutionActualRequest = core.serialization
     .union(core.serialization.discriminant("outputType", "output_type"), {
-    STRING: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowExecutionActualStringRequest; })),
-    JSON: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowExecutionActualJsonRequest; })),
-    CHAT_HISTORY: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowExecutionActualChatHistoryRequest; })),
+    STRING: WorkflowExecutionActualStringRequest_1.WorkflowExecutionActualStringRequest,
+    JSON: WorkflowExecutionActualJsonRequest_1.WorkflowExecutionActualJsonRequest,
+    CHAT_HISTORY: WorkflowExecutionActualChatHistoryRequest_1.WorkflowExecutionActualChatHistoryRequest,
 })
     .transform({
     transform: (value) => value,

package/dist/serialization/types/TemplatingNodeArrayResult.d.ts

@@ -0,0 +1,14 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "..";
+import * as Vellum from "../../api";
+import * as core from "../../core";
+import { ArrayVariableValueItem } from "./ArrayVariableValueItem";
+export declare const TemplatingNodeArrayResult: core.serialization.ObjectSchema<serializers.TemplatingNodeArrayResult.Raw, Vellum.TemplatingNodeArrayResult>;
+export declare namespace TemplatingNodeArrayResult {
+    interface Raw {
+        id: string;
+        value?: ArrayVariableValueItem.Raw[] | null;
+    }
+}

package/dist/serialization/types/TemplatingNodeArrayResult.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplatingNodeArrayResult = void 0;
+const core = __importStar(require("../../core"));
+const ArrayVariableValueItem_1 = require("./ArrayVariableValueItem");
+exports.TemplatingNodeArrayResult = core.serialization.object({
+    id: core.serialization.string(),
+    value: core.serialization.list(ArrayVariableValueItem_1.ArrayVariableValueItem).optional(),
+});

package/dist/serialization/types/TemplatingNodeChatHistoryResult.d.ts

@@ -4,10 +4,11 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { ChatMessage } from "./ChatMessage";
 export declare const TemplatingNodeChatHistoryResult: core.serialization.ObjectSchema<serializers.TemplatingNodeChatHistoryResult.Raw, Vellum.TemplatingNodeChatHistoryResult>;
 export declare namespace TemplatingNodeChatHistoryResult {
     interface Raw {
         id: string;
-        value?: serializers.ChatMessage.Raw[] | null;
+        value?: ChatMessage.Raw[] | null;
     }
 }

package/dist/serialization/types/TemplatingNodeChatHistoryResult.js

@@ -25,21 +25,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplatingNodeChatHistoryResult = void 0;
 const core = __importStar(require("../../core"));
+const ChatMessage_1 = require("./ChatMessage");
 exports.TemplatingNodeChatHistoryResult = core.serialization.object({
     id: core.serialization.string(),
-    value: core.serialization
-        .list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ChatMessage; })))
-        .optional(),
+    value: core.serialization.list(ChatMessage_1.ChatMessage).optional(),
 });

package/dist/serialization/types/TemplatingNodeErrorResult.d.ts

@@ -4,10 +4,11 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { VellumError } from "./VellumError";
 export declare const TemplatingNodeErrorResult: core.serialization.ObjectSchema<serializers.TemplatingNodeErrorResult.Raw, Vellum.TemplatingNodeErrorResult>;
 export declare namespace TemplatingNodeErrorResult {
     interface Raw {
         id: string;
-        value?: serializers.VellumError.Raw | null;
+        value?: VellumError.Raw | null;
     }
 }

package/dist/serialization/types/TemplatingNodeErrorResult.js

@@ -25,19 +25,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplatingNodeErrorResult = void 0;
 const core = __importStar(require("../../core"));
+const VellumError_1 = require("./VellumError");
 exports.TemplatingNodeErrorResult = core.serialization.object({
     id: core.serialization.string(),
-    value: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).VellumError; })).optional(),
+    value: VellumError_1.VellumError.optional(),
 });

package/dist/serialization/types/TemplatingNodeFunctionCallResult.d.ts

@@ -0,0 +1,14 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "..";
+import * as Vellum from "../../api";
+import * as core from "../../core";
+import { FunctionCall } from "./FunctionCall";
+export declare const TemplatingNodeFunctionCallResult: core.serialization.ObjectSchema<serializers.TemplatingNodeFunctionCallResult.Raw, Vellum.TemplatingNodeFunctionCallResult>;
+export declare namespace TemplatingNodeFunctionCallResult {
+    interface Raw {
+        id: string;
+        value?: FunctionCall.Raw | null;
+    }
+}

package/dist/serialization/types/TemplatingNodeFunctionCallResult.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplatingNodeFunctionCallResult = void 0;
+const core = __importStar(require("../../core"));
+const FunctionCall_1 = require("./FunctionCall");
+exports.TemplatingNodeFunctionCallResult = core.serialization.object({
+    id: core.serialization.string(),
+    value: FunctionCall_1.FunctionCall.optional(),
+});

package/dist/serialization/types/TemplatingNodeResult.d.ts

@@ -4,9 +4,10 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { TemplatingNodeResultData } from "./TemplatingNodeResultData";
 export declare const TemplatingNodeResult: core.serialization.ObjectSchema<serializers.TemplatingNodeResult.Raw, Vellum.TemplatingNodeResult>;
 export declare namespace TemplatingNodeResult {
     interface Raw {
-        data: serializers.TemplatingNodeResultData.Raw;
+        data: TemplatingNodeResultData.Raw;
     }
 }

package/dist/serialization/types/TemplatingNodeResult.js

@@ -25,18 +25,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplatingNodeResult = void 0;
 const core = __importStar(require("../../core"));
+const TemplatingNodeResultData_1 = require("./TemplatingNodeResultData");
 exports.TemplatingNodeResult = core.serialization.object({
-    data: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TemplatingNodeResultData; })),
+    data: TemplatingNodeResultData_1.TemplatingNodeResultData,
 });

package/dist/serialization/types/TemplatingNodeResultData.d.ts

@@ -4,9 +4,10 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { TemplatingNodeResultOutput } from "./TemplatingNodeResultOutput";
 export declare const TemplatingNodeResultData: core.serialization.ObjectSchema<serializers.TemplatingNodeResultData.Raw, Vellum.TemplatingNodeResultData>;
 export declare namespace TemplatingNodeResultData {
     interface Raw {
-        output: serializers.TemplatingNodeResultOutput.Raw;
+        output: TemplatingNodeResultOutput.Raw;
     }
 }

package/dist/serialization/types/TemplatingNodeResultData.js

@@ -25,18 +25,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplatingNodeResultData = void 0;
 const core = __importStar(require("../../core"));
+const TemplatingNodeResultOutput_1 = require("./TemplatingNodeResultOutput");
 exports.TemplatingNodeResultData = core.serialization.object({
-    output: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TemplatingNodeResultOutput; })),
+    output: TemplatingNodeResultOutput_1.TemplatingNodeResultOutput,
 });

package/dist/serialization/types/TemplatingNodeResultOutput.d.ts

@@ -4,25 +4,39 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { TemplatingNodeStringResult } from "./TemplatingNodeStringResult";
+import { TemplatingNodeNumberResult } from "./TemplatingNodeNumberResult";
+import { TemplatingNodeJsonResult } from "./TemplatingNodeJsonResult";
+import { TemplatingNodeChatHistoryResult } from "./TemplatingNodeChatHistoryResult";
+import { TemplatingNodeSearchResultsResult } from "./TemplatingNodeSearchResultsResult";
+import { TemplatingNodeErrorResult } from "./TemplatingNodeErrorResult";
+import { TemplatingNodeArrayResult } from "./TemplatingNodeArrayResult";
+import { TemplatingNodeFunctionCallResult } from "./TemplatingNodeFunctionCallResult";
 export declare const TemplatingNodeResultOutput: core.serialization.Schema<serializers.TemplatingNodeResultOutput.Raw, Vellum.TemplatingNodeResultOutput>;
 export declare namespace TemplatingNodeResultOutput {
-    type Raw = TemplatingNodeResultOutput.String | TemplatingNodeResultOutput.Number | TemplatingNodeResultOutput.Json | TemplatingNodeResultOutput.ChatHistory | TemplatingNodeResultOutput.SearchResults | TemplatingNodeResultOutput.Error;
-    interface String extends serializers.TemplatingNodeStringResult.Raw {
+    type Raw = TemplatingNodeResultOutput.String | TemplatingNodeResultOutput.Number | TemplatingNodeResultOutput.Json | TemplatingNodeResultOutput.ChatHistory | TemplatingNodeResultOutput.SearchResults | TemplatingNodeResultOutput.Error | TemplatingNodeResultOutput.Array | TemplatingNodeResultOutput.FunctionCall;
+    interface String extends TemplatingNodeStringResult.Raw {
         type: "STRING";
     }
-    interface Number extends serializers.TemplatingNodeNumberResult.Raw {
+    interface Number extends TemplatingNodeNumberResult.Raw {
         type: "NUMBER";
     }
-    interface Json extends serializers.TemplatingNodeJsonResult.Raw {
+    interface Json extends TemplatingNodeJsonResult.Raw {
         type: "JSON";
     }
-    interface ChatHistory extends serializers.TemplatingNodeChatHistoryResult.Raw {
+    interface ChatHistory extends TemplatingNodeChatHistoryResult.Raw {
         type: "CHAT_HISTORY";
     }
-    interface SearchResults extends serializers.TemplatingNodeSearchResultsResult.Raw {
+    interface SearchResults extends TemplatingNodeSearchResultsResult.Raw {
         type: "SEARCH_RESULTS";
     }
-    interface Error extends serializers.TemplatingNodeErrorResult.Raw {
+    interface Error extends TemplatingNodeErrorResult.Raw {
         type: "ERROR";
     }
+    interface Array extends TemplatingNodeArrayResult.Raw {
+        type: "ARRAY";
+    }
+    interface FunctionCall extends TemplatingNodeFunctionCallResult.Raw {
+        type: "FUNCTION_CALL";
+    }
 }

package/dist/serialization/types/TemplatingNodeResultOutput.js

@@ -25,26 +25,27 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplatingNodeResultOutput = void 0;
 const core = __importStar(require("../../core"));
+const TemplatingNodeStringResult_1 = require("./TemplatingNodeStringResult");
+const TemplatingNodeNumberResult_1 = require("./TemplatingNodeNumberResult");
+const TemplatingNodeJsonResult_1 = require("./TemplatingNodeJsonResult");
+const TemplatingNodeChatHistoryResult_1 = require("./TemplatingNodeChatHistoryResult");
+const TemplatingNodeSearchResultsResult_1 = require("./TemplatingNodeSearchResultsResult");
+const TemplatingNodeErrorResult_1 = require("./TemplatingNodeErrorResult");
+const TemplatingNodeArrayResult_1 = require("./TemplatingNodeArrayResult");
+const TemplatingNodeFunctionCallResult_1 = require("./TemplatingNodeFunctionCallResult");
 exports.TemplatingNodeResultOutput = core.serialization
     .union("type", {
-    STRING: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TemplatingNodeStringResult; })),
-    NUMBER: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TemplatingNodeNumberResult; })),
-    JSON: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TemplatingNodeJsonResult; })),
-    CHAT_HISTORY: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TemplatingNodeChatHistoryResult; })),
-    SEARCH_RESULTS: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TemplatingNodeSearchResultsResult; })),
-    ERROR: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TemplatingNodeErrorResult; })),
+    STRING: TemplatingNodeStringResult_1.TemplatingNodeStringResult,
+    NUMBER: TemplatingNodeNumberResult_1.TemplatingNodeNumberResult,
+    JSON: TemplatingNodeJsonResult_1.TemplatingNodeJsonResult,
+    CHAT_HISTORY: TemplatingNodeChatHistoryResult_1.TemplatingNodeChatHistoryResult,
+    SEARCH_RESULTS: TemplatingNodeSearchResultsResult_1.TemplatingNodeSearchResultsResult,
+    ERROR: TemplatingNodeErrorResult_1.TemplatingNodeErrorResult,
+    ARRAY: TemplatingNodeArrayResult_1.TemplatingNodeArrayResult,
+    FUNCTION_CALL: TemplatingNodeFunctionCallResult_1.TemplatingNodeFunctionCallResult,
 })
     .transform({
     transform: (value) => value,

package/dist/serialization/types/TemplatingNodeSearchResultsResult.d.ts

@@ -4,10 +4,11 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { SearchResult } from "./SearchResult";
 export declare const TemplatingNodeSearchResultsResult: core.serialization.ObjectSchema<serializers.TemplatingNodeSearchResultsResult.Raw, Vellum.TemplatingNodeSearchResultsResult>;
 export declare namespace TemplatingNodeSearchResultsResult {
     interface Raw {
         id: string;
-        value?: serializers.SearchResult.Raw[] | null;
+        value?: SearchResult.Raw[] | null;
     }
 }

package/dist/serialization/types/TemplatingNodeSearchResultsResult.js

@@ -25,21 +25,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplatingNodeSearchResultsResult = void 0;
 const core = __importStar(require("../../core"));
+const SearchResult_1 = require("./SearchResult");
 exports.TemplatingNodeSearchResultsResult = core.serialization.object({
     id: core.serialization.string(),
-    value: core.serialization
-        .list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).SearchResult; })))
-        .optional(),
+    value: core.serialization.list(SearchResult_1.SearchResult).optional(),
 });

package/dist/serialization/types/TerminalNodeArrayResult.d.ts

@@ -4,11 +4,12 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { ArrayVariableValueItem } from "./ArrayVariableValueItem";
 export declare const TerminalNodeArrayResult: core.serialization.ObjectSchema<serializers.TerminalNodeArrayResult.Raw, Vellum.TerminalNodeArrayResult>;
 export declare namespace TerminalNodeArrayResult {
     interface Raw {
         id?: string | null;
         name: string;
-        value?: serializers.ArrayVariableValueItem.Raw[] | null;
+        value?: ArrayVariableValueItem.Raw[] | null;
     }
 }

package/dist/serialization/types/TerminalNodeArrayResult.js

@@ -25,22 +25,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TerminalNodeArrayResult = void 0;
 const core = __importStar(require("../../core"));
+const ArrayVariableValueItem_1 = require("./ArrayVariableValueItem");
 exports.TerminalNodeArrayResult = core.serialization.object({
     id: core.serialization.string().optional(),
     name: core.serialization.string(),
-    value: core.serialization
-        .list(core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ArrayVariableValueItem; })))
-        .optional(),
+    value: core.serialization.list(ArrayVariableValueItem_1.ArrayVariableValueItem).optional(),
 });

package/dist/serialization/types/TerminalNodeChatHistoryResult.d.ts

@@ -4,11 +4,12 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { ChatMessage } from "./ChatMessage";
 export declare const TerminalNodeChatHistoryResult: core.serialization.ObjectSchema<serializers.TerminalNodeChatHistoryResult.Raw, Vellum.TerminalNodeChatHistoryResult>;
 export declare namespace TerminalNodeChatHistoryResult {
     interface Raw {
         id?: string | null;
         name: string;
-        value?: serializers.ChatMessage.Raw[] | null;
+        value?: ChatMessage.Raw[] | null;
     }
 }

package/dist/serialization/types/TerminalNodeChatHistoryResult.js

@@ -25,22 +25,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TerminalNodeChatHistoryResult = void 0;
 const core = __importStar(require("../../core"));
+const ChatMessage_1 = require("./ChatMessage");
 exports.TerminalNodeChatHistoryResult = core.serialization.object({
     id: core.serialization.string().optional(),
     name: core.serialization.string(),
-    value: core.serialization
-        .list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ChatMessage; })))
-        .optional(),
+    value: core.serialization.list(ChatMessage_1.ChatMessage).optional(),
 });

package/dist/serialization/types/TerminalNodeErrorResult.d.ts

@@ -4,11 +4,12 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { VellumError } from "./VellumError";
 export declare const TerminalNodeErrorResult: core.serialization.ObjectSchema<serializers.TerminalNodeErrorResult.Raw, Vellum.TerminalNodeErrorResult>;
 export declare namespace TerminalNodeErrorResult {
     interface Raw {
         id?: string | null;
         name: string;
-        value?: serializers.VellumError.Raw | null;
+        value?: VellumError.Raw | null;
     }
 }