vellum-ai 0.3.14 → 0.3.15

package/serialization/types/WorkflowResultEvent.d.ts

@@ -4,15 +4,20 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { WorkflowNodeResultEventState } from "./WorkflowNodeResultEventState";
+import { WorkflowResultEventOutputData } from "./WorkflowResultEventOutputData";
+import { WorkflowEventError } from "./WorkflowEventError";
+import { WorkflowOutput } from "./WorkflowOutput";
+import { ExecutionVellumValue } from "./ExecutionVellumValue";
 export declare const WorkflowResultEvent: core.serialization.ObjectSchema<serializers.WorkflowResultEvent.Raw, Vellum.WorkflowResultEvent>;
 export declare namespace WorkflowResultEvent {
     interface Raw {
         id: string;
-        state: serializers.WorkflowNodeResultEventState.Raw;
+        state: WorkflowNodeResultEventState.Raw;
         ts: string;
-        output?: serializers.WorkflowResultEventOutputData.Raw | null;
-        error?: serializers.WorkflowEventError.Raw | null;
-        outputs?: serializers.WorkflowOutput.Raw[] | null;
-        inputs?: serializers.ExecutionVellumValue.Raw[] | null;
+        output?: WorkflowResultEventOutputData.Raw | null;
+        error?: WorkflowEventError.Raw | null;
+        outputs?: WorkflowOutput.Raw[] | null;
+        inputs?: ExecutionVellumValue.Raw[] | null;
     }
 }

package/serialization/types/WorkflowResultEvent.js

@@ -25,28 +25,20 @@ 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.WorkflowResultEvent = void 0;
 const core = __importStar(require("../../core"));
+const WorkflowNodeResultEventState_1 = require("./WorkflowNodeResultEventState");
+const WorkflowResultEventOutputData_1 = require("./WorkflowResultEventOutputData");
+const WorkflowEventError_1 = require("./WorkflowEventError");
+const WorkflowOutput_1 = require("./WorkflowOutput");
+const ExecutionVellumValue_1 = require("./ExecutionVellumValue");
 exports.WorkflowResultEvent = core.serialization.object({
     id: core.serialization.string(),
-    state: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowNodeResultEventState; })),
+    state: WorkflowNodeResultEventState_1.WorkflowNodeResultEventState,
     ts: core.serialization.date(),
-    output: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowResultEventOutputData; })).optional(),
-    error: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowEventError; })).optional(),
-    outputs: core.serialization
-        .list(core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowOutput; })))
-        .optional(),
-    inputs: core.serialization
-        .list(core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ExecutionVellumValue; })))
-        .optional(),
+    output: WorkflowResultEventOutputData_1.WorkflowResultEventOutputData.optional(),
+    error: WorkflowEventError_1.WorkflowEventError.optional(),
+    outputs: core.serialization.list(WorkflowOutput_1.WorkflowOutput).optional(),
+    inputs: core.serialization.list(ExecutionVellumValue_1.ExecutionVellumValue).optional(),
 });

package/serialization/types/WorkflowResultEventOutputData.d.ts

@@ -4,31 +4,39 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { WorkflowResultEventOutputDataString } from "./WorkflowResultEventOutputDataString";
+import { WorkflowResultEventOutputDataNumber } from "./WorkflowResultEventOutputDataNumber";
+import { WorkflowResultEventOutputDataJson } from "./WorkflowResultEventOutputDataJson";
+import { WorkflowResultEventOutputDataChatHistory } from "./WorkflowResultEventOutputDataChatHistory";
+import { WorkflowResultEventOutputDataSearchResults } from "./WorkflowResultEventOutputDataSearchResults";
+import { WorkflowResultEventOutputDataArray } from "./WorkflowResultEventOutputDataArray";
+import { WorkflowResultEventOutputDataFunctionCall } from "./WorkflowResultEventOutputDataFunctionCall";
+import { WorkflowResultEventOutputDataError } from "./WorkflowResultEventOutputDataError";
 export declare const WorkflowResultEventOutputData: core.serialization.Schema<serializers.WorkflowResultEventOutputData.Raw, Vellum.WorkflowResultEventOutputData>;
 export declare namespace WorkflowResultEventOutputData {
     type Raw = WorkflowResultEventOutputData.String | WorkflowResultEventOutputData.Number | WorkflowResultEventOutputData.Json | WorkflowResultEventOutputData.ChatHistory | WorkflowResultEventOutputData.SearchResults | WorkflowResultEventOutputData.Array | WorkflowResultEventOutputData.FunctionCall | WorkflowResultEventOutputData.Error;
-    interface String extends serializers.WorkflowResultEventOutputDataString.Raw {
+    interface String extends WorkflowResultEventOutputDataString.Raw {
         type: "STRING";
     }
-    interface Number extends serializers.WorkflowResultEventOutputDataNumber.Raw {
+    interface Number extends WorkflowResultEventOutputDataNumber.Raw {
         type: "NUMBER";
     }
-    interface Json extends serializers.WorkflowResultEventOutputDataJson.Raw {
+    interface Json extends WorkflowResultEventOutputDataJson.Raw {
         type: "JSON";
     }
-    interface ChatHistory extends serializers.WorkflowResultEventOutputDataChatHistory.Raw {
+    interface ChatHistory extends WorkflowResultEventOutputDataChatHistory.Raw {
         type: "CHAT_HISTORY";
     }
-    interface SearchResults extends serializers.WorkflowResultEventOutputDataSearchResults.Raw {
+    interface SearchResults extends WorkflowResultEventOutputDataSearchResults.Raw {
         type: "SEARCH_RESULTS";
     }
-    interface Array extends serializers.WorkflowResultEventOutputDataArray.Raw {
+    interface Array extends WorkflowResultEventOutputDataArray.Raw {
         type: "ARRAY";
     }
-    interface FunctionCall extends serializers.WorkflowResultEventOutputDataFunctionCall.Raw {
+    interface FunctionCall extends WorkflowResultEventOutputDataFunctionCall.Raw {
         type: "FUNCTION_CALL";
     }
-    interface Error extends serializers.WorkflowResultEventOutputDataError.Raw {
+    interface Error extends WorkflowResultEventOutputDataError.Raw {
         type: "ERROR";
     }
 }

package/serialization/types/WorkflowResultEventOutputData.js

@@ -25,28 +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.WorkflowResultEventOutputData = void 0;
 const core = __importStar(require("../../core"));
+const WorkflowResultEventOutputDataString_1 = require("./WorkflowResultEventOutputDataString");
+const WorkflowResultEventOutputDataNumber_1 = require("./WorkflowResultEventOutputDataNumber");
+const WorkflowResultEventOutputDataJson_1 = require("./WorkflowResultEventOutputDataJson");
+const WorkflowResultEventOutputDataChatHistory_1 = require("./WorkflowResultEventOutputDataChatHistory");
+const WorkflowResultEventOutputDataSearchResults_1 = require("./WorkflowResultEventOutputDataSearchResults");
+const WorkflowResultEventOutputDataArray_1 = require("./WorkflowResultEventOutputDataArray");
+const WorkflowResultEventOutputDataFunctionCall_1 = require("./WorkflowResultEventOutputDataFunctionCall");
+const WorkflowResultEventOutputDataError_1 = require("./WorkflowResultEventOutputDataError");
 exports.WorkflowResultEventOutputData = core.serialization
     .union("type", {
-    STRING: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowResultEventOutputDataString; })),
-    NUMBER: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowResultEventOutputDataNumber; })),
-    JSON: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowResultEventOutputDataJson; })),
-    CHAT_HISTORY: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowResultEventOutputDataChatHistory; })),
-    SEARCH_RESULTS: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowResultEventOutputDataSearchResults; })),
-    ARRAY: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowResultEventOutputDataArray; })),
-    FUNCTION_CALL: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowResultEventOutputDataFunctionCall; })),
-    ERROR: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowResultEventOutputDataError; })),
+    STRING: WorkflowResultEventOutputDataString_1.WorkflowResultEventOutputDataString,
+    NUMBER: WorkflowResultEventOutputDataNumber_1.WorkflowResultEventOutputDataNumber,
+    JSON: WorkflowResultEventOutputDataJson_1.WorkflowResultEventOutputDataJson,
+    CHAT_HISTORY: WorkflowResultEventOutputDataChatHistory_1.WorkflowResultEventOutputDataChatHistory,
+    SEARCH_RESULTS: WorkflowResultEventOutputDataSearchResults_1.WorkflowResultEventOutputDataSearchResults,
+    ARRAY: WorkflowResultEventOutputDataArray_1.WorkflowResultEventOutputDataArray,
+    FUNCTION_CALL: WorkflowResultEventOutputDataFunctionCall_1.WorkflowResultEventOutputDataFunctionCall,
+    ERROR: WorkflowResultEventOutputDataError_1.WorkflowResultEventOutputDataError,
 })
     .transform({
     transform: (value) => value,

package/serialization/types/WorkflowResultEventOutputDataArray.d.ts

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

package/serialization/types/WorkflowResultEventOutputDataArray.js

@@ -25,25 +25,16 @@ 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.WorkflowResultEventOutputDataArray = void 0;
 const core = __importStar(require("../../core"));
+const WorkflowNodeResultEventState_1 = require("./WorkflowNodeResultEventState");
+const ArrayVariableValueItem_1 = require("./ArrayVariableValueItem");
 exports.WorkflowResultEventOutputDataArray = core.serialization.object({
     id: core.serialization.string().optional(),
     name: core.serialization.string(),
-    state: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowNodeResultEventState; })),
+    state: WorkflowNodeResultEventState_1.WorkflowNodeResultEventState,
     nodeId: core.serialization.property("node_id", core.serialization.string()),
     delta: core.serialization.string().optional(),
-    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/serialization/types/WorkflowResultEventOutputDataChatHistory.d.ts

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

package/serialization/types/WorkflowResultEventOutputDataChatHistory.js

@@ -25,25 +25,16 @@ 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.WorkflowResultEventOutputDataChatHistory = void 0;
 const core = __importStar(require("../../core"));
+const WorkflowNodeResultEventState_1 = require("./WorkflowNodeResultEventState");
+const ChatMessage_1 = require("./ChatMessage");
 exports.WorkflowResultEventOutputDataChatHistory = core.serialization.object({
     id: core.serialization.string().optional(),
     name: core.serialization.string(),
-    state: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowNodeResultEventState; })),
+    state: WorkflowNodeResultEventState_1.WorkflowNodeResultEventState,
     nodeId: core.serialization.property("node_id", core.serialization.string()),
     delta: core.serialization.string().optional(),
-    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/serialization/types/WorkflowResultEventOutputDataError.d.ts

@@ -4,14 +4,16 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { WorkflowNodeResultEventState } from "./WorkflowNodeResultEventState";
+import { VellumError } from "./VellumError";
 export declare const WorkflowResultEventOutputDataError: core.serialization.ObjectSchema<serializers.WorkflowResultEventOutputDataError.Raw, Vellum.WorkflowResultEventOutputDataError>;
 export declare namespace WorkflowResultEventOutputDataError {
     interface Raw {
         id?: string | null;
         name: string;
-        state: serializers.WorkflowNodeResultEventState.Raw;
+        state: WorkflowNodeResultEventState.Raw;
         node_id: string;
         delta?: string | null;
-        value?: serializers.VellumError.Raw | null;
+        value?: VellumError.Raw | null;
     }
 }

package/serialization/types/WorkflowResultEventOutputDataError.js

@@ -25,23 +25,16 @@ 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.WorkflowResultEventOutputDataError = void 0;
 const core = __importStar(require("../../core"));
+const WorkflowNodeResultEventState_1 = require("./WorkflowNodeResultEventState");
+const VellumError_1 = require("./VellumError");
 exports.WorkflowResultEventOutputDataError = core.serialization.object({
     id: core.serialization.string().optional(),
     name: core.serialization.string(),
-    state: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowNodeResultEventState; })),
+    state: WorkflowNodeResultEventState_1.WorkflowNodeResultEventState,
     nodeId: core.serialization.property("node_id", core.serialization.string()),
     delta: core.serialization.string().optional(),
-    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/serialization/types/WorkflowResultEventOutputDataFunctionCall.d.ts

@@ -4,14 +4,16 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { WorkflowNodeResultEventState } from "./WorkflowNodeResultEventState";
+import { FunctionCall } from "./FunctionCall";
 export declare const WorkflowResultEventOutputDataFunctionCall: core.serialization.ObjectSchema<serializers.WorkflowResultEventOutputDataFunctionCall.Raw, Vellum.WorkflowResultEventOutputDataFunctionCall>;
 export declare namespace WorkflowResultEventOutputDataFunctionCall {
     interface Raw {
         id?: string | null;
         name: string;
-        state: serializers.WorkflowNodeResultEventState.Raw;
+        state: WorkflowNodeResultEventState.Raw;
         node_id: string;
         delta?: string | null;
-        value?: serializers.FunctionCall.Raw | null;
+        value?: FunctionCall.Raw | null;
     }
 }

package/serialization/types/WorkflowResultEventOutputDataFunctionCall.js

@@ -25,23 +25,16 @@ 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.WorkflowResultEventOutputDataFunctionCall = void 0;
 const core = __importStar(require("../../core"));
+const WorkflowNodeResultEventState_1 = require("./WorkflowNodeResultEventState");
+const FunctionCall_1 = require("./FunctionCall");
 exports.WorkflowResultEventOutputDataFunctionCall = core.serialization.object({
     id: core.serialization.string().optional(),
     name: core.serialization.string(),
-    state: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowNodeResultEventState; })),
+    state: WorkflowNodeResultEventState_1.WorkflowNodeResultEventState,
     nodeId: core.serialization.property("node_id", core.serialization.string()),
     delta: core.serialization.string().optional(),
-    value: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).FunctionCall; })).optional(),
+    value: FunctionCall_1.FunctionCall.optional(),
 });

package/serialization/types/WorkflowResultEventOutputDataJson.d.ts

@@ -4,12 +4,13 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { WorkflowNodeResultEventState } from "./WorkflowNodeResultEventState";
 export declare const WorkflowResultEventOutputDataJson: core.serialization.ObjectSchema<serializers.WorkflowResultEventOutputDataJson.Raw, Vellum.WorkflowResultEventOutputDataJson>;
 export declare namespace WorkflowResultEventOutputDataJson {
     interface Raw {
         id?: string | null;
         name: string;
-        state: serializers.WorkflowNodeResultEventState.Raw;
+        state: WorkflowNodeResultEventState.Raw;
         node_id: string;
         delta?: string | null;
         value?: Record<string, unknown> | null;

package/serialization/types/WorkflowResultEventOutputDataJson.js

@@ -25,22 +25,14 @@ 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.WorkflowResultEventOutputDataJson = void 0;
 const core = __importStar(require("../../core"));
+const WorkflowNodeResultEventState_1 = require("./WorkflowNodeResultEventState");
 exports.WorkflowResultEventOutputDataJson = core.serialization.object({
     id: core.serialization.string().optional(),
     name: core.serialization.string(),
-    state: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowNodeResultEventState; })),
+    state: WorkflowNodeResultEventState_1.WorkflowNodeResultEventState,
     nodeId: core.serialization.property("node_id", core.serialization.string()),
     delta: core.serialization.string().optional(),
     value: core.serialization.record(core.serialization.string(), core.serialization.unknown()).optional(),

package/serialization/types/WorkflowResultEventOutputDataNumber.d.ts

@@ -4,12 +4,13 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { WorkflowNodeResultEventState } from "./WorkflowNodeResultEventState";
 export declare const WorkflowResultEventOutputDataNumber: core.serialization.ObjectSchema<serializers.WorkflowResultEventOutputDataNumber.Raw, Vellum.WorkflowResultEventOutputDataNumber>;
 export declare namespace WorkflowResultEventOutputDataNumber {
     interface Raw {
         id?: string | null;
         name: string;
-        state: serializers.WorkflowNodeResultEventState.Raw;
+        state: WorkflowNodeResultEventState.Raw;
         node_id: string;
         delta?: string | null;
         value?: number | null;

package/serialization/types/WorkflowResultEventOutputDataNumber.js

@@ -25,22 +25,14 @@ 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.WorkflowResultEventOutputDataNumber = void 0;
 const core = __importStar(require("../../core"));
+const WorkflowNodeResultEventState_1 = require("./WorkflowNodeResultEventState");
 exports.WorkflowResultEventOutputDataNumber = core.serialization.object({
     id: core.serialization.string().optional(),
     name: core.serialization.string(),
-    state: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowNodeResultEventState; })),
+    state: WorkflowNodeResultEventState_1.WorkflowNodeResultEventState,
     nodeId: core.serialization.property("node_id", core.serialization.string()),
     delta: core.serialization.string().optional(),
     value: core.serialization.number().optional(),

package/serialization/types/WorkflowResultEventOutputDataSearchResults.d.ts

@@ -4,14 +4,16 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { WorkflowNodeResultEventState } from "./WorkflowNodeResultEventState";
+import { SearchResult } from "./SearchResult";
 export declare const WorkflowResultEventOutputDataSearchResults: core.serialization.ObjectSchema<serializers.WorkflowResultEventOutputDataSearchResults.Raw, Vellum.WorkflowResultEventOutputDataSearchResults>;
 export declare namespace WorkflowResultEventOutputDataSearchResults {
     interface Raw {
         id?: string | null;
         name: string;
-        state: serializers.WorkflowNodeResultEventState.Raw;
+        state: WorkflowNodeResultEventState.Raw;
         node_id: string;
         delta?: string | null;
-        value?: serializers.SearchResult.Raw[] | null;
+        value?: SearchResult.Raw[] | null;
     }
 }

package/serialization/types/WorkflowResultEventOutputDataSearchResults.js

@@ -25,25 +25,16 @@ 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.WorkflowResultEventOutputDataSearchResults = void 0;
 const core = __importStar(require("../../core"));
+const WorkflowNodeResultEventState_1 = require("./WorkflowNodeResultEventState");
+const SearchResult_1 = require("./SearchResult");
 exports.WorkflowResultEventOutputDataSearchResults = core.serialization.object({
     id: core.serialization.string().optional(),
     name: core.serialization.string(),
-    state: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowNodeResultEventState; })),
+    state: WorkflowNodeResultEventState_1.WorkflowNodeResultEventState,
     nodeId: core.serialization.property("node_id", core.serialization.string()),
     delta: core.serialization.string().optional(),
-    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/serialization/types/WorkflowResultEventOutputDataString.d.ts

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

package/serialization/types/WorkflowResultEventOutputDataString.js

@@ -25,22 +25,14 @@ 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.WorkflowResultEventOutputDataString = void 0;
 const core = __importStar(require("../../core"));
+const WorkflowNodeResultEventState_1 = require("./WorkflowNodeResultEventState");
 exports.WorkflowResultEventOutputDataString = core.serialization.object({
     id: core.serialization.string().optional(),
     name: core.serialization.string(),
-    state: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowNodeResultEventState; })),
+    state: WorkflowNodeResultEventState_1.WorkflowNodeResultEventState,
     nodeId: core.serialization.property("node_id", core.serialization.string()),
     delta: core.serialization.string().optional(),
     value: core.serialization.string().optional(),

package/serialization/types/WorkflowStreamEvent.d.ts

@@ -4,13 +4,15 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { WorkflowExecutionWorkflowResultEvent } from "./WorkflowExecutionWorkflowResultEvent";
+import { WorkflowExecutionNodeResultEvent } from "./WorkflowExecutionNodeResultEvent";
 export declare const WorkflowStreamEvent: core.serialization.Schema<serializers.WorkflowStreamEvent.Raw, Vellum.WorkflowStreamEvent>;
 export declare namespace WorkflowStreamEvent {
     type Raw = WorkflowStreamEvent.Workflow | WorkflowStreamEvent.Node;
-    interface Workflow extends serializers.WorkflowExecutionWorkflowResultEvent.Raw {
+    interface Workflow extends WorkflowExecutionWorkflowResultEvent.Raw {
         type: "WORKFLOW";
     }
-    interface Node extends serializers.WorkflowExecutionNodeResultEvent.Raw {
+    interface Node extends WorkflowExecutionNodeResultEvent.Raw {
         type: "NODE";
     }
 }

package/serialization/types/WorkflowStreamEvent.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.WorkflowStreamEvent = void 0;
 const core = __importStar(require("../../core"));
+const WorkflowExecutionWorkflowResultEvent_1 = require("./WorkflowExecutionWorkflowResultEvent");
+const WorkflowExecutionNodeResultEvent_1 = require("./WorkflowExecutionNodeResultEvent");
 exports.WorkflowStreamEvent = core.serialization
     .union("type", {
-    WORKFLOW: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowExecutionWorkflowResultEvent; })),
-    NODE: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowExecutionNodeResultEvent; })),
+    WORKFLOW: WorkflowExecutionWorkflowResultEvent_1.WorkflowExecutionWorkflowResultEvent,
+    NODE: WorkflowExecutionNodeResultEvent_1.WorkflowExecutionNodeResultEvent,
 })
     .transform({
     transform: (value) => value,

package/serialization/types/index.d.ts

@@ -15,8 +15,10 @@ export * from "./ChatMessageContent";
 export * from "./ChatMessageContentRequest";
 export * from "./ChatMessageRequest";
 export * from "./ChatMessageRole";
+export * from "./CodeExecutionNodeArrayResult";
 export * from "./CodeExecutionNodeChatHistoryResult";
 export * from "./CodeExecutionNodeErrorResult";
+export * from "./CodeExecutionNodeFunctionCallResult";
 export * from "./CodeExecutionNodeJsonResult";
 export * from "./CodeExecutionNodeNumberResult";
 export * from "./CodeExecutionNodeResult";
@@ -111,6 +113,7 @@ export * from "./NamedTestCaseVariableValueRequest";
 export * from "./NodeInputCompiledArrayValue";
 export * from "./NodeInputCompiledChatHistoryValue";
 export * from "./NodeInputCompiledErrorValue";
+export * from "./NodeInputCompiledFunctionCall";
 export * from "./NodeInputCompiledJsonValue";
 export * from "./NodeInputCompiledNumberValue";
 export * from "./NodeInputCompiledSearchResultsValue";
@@ -202,8 +205,10 @@ export * from "./SubmitCompletionActualsErrorResponse";
 export * from "./SubmitWorkflowExecutionActualRequest";
 export * from "./SubworkflowEnum";
 export * from "./SubworkflowNodeResult";
+export * from "./TemplatingNodeArrayResult";
 export * from "./TemplatingNodeChatHistoryResult";
 export * from "./TemplatingNodeErrorResult";
+export * from "./TemplatingNodeFunctionCallResult";
 export * from "./TemplatingNodeJsonResult";
 export * from "./TemplatingNodeNumberResult";
 export * from "./TemplatingNodeResult";