vellum-ai 0.3.14 → 0.3.15

package/dist/serialization/types/VellumErrorRequest.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.VellumErrorRequest = void 0;
 const core = __importStar(require("../../core"));
+const VellumErrorCodeEnum_1 = require("./VellumErrorCodeEnum");
 exports.VellumErrorRequest = core.serialization.object({
     message: core.serialization.string(),
-    code: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).VellumErrorCodeEnum; })),
+    code: VellumErrorCodeEnum_1.VellumErrorCodeEnum,
 });

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

@@ -4,11 +4,12 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { VellumVariableType } from "./VellumVariableType";
 export declare const VellumVariable: core.serialization.ObjectSchema<serializers.VellumVariable.Raw, Vellum.VellumVariable>;
 export declare namespace VellumVariable {
     interface Raw {
         id: string;
         key: string;
-        type: serializers.VellumVariableType.Raw;
+        type: VellumVariableType.Raw;
     }
 }

package/dist/serialization/types/VellumVariable.js

@@ -25,20 +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.VellumVariable = void 0;
 const core = __importStar(require("../../core"));
+const VellumVariableType_1 = require("./VellumVariableType");
 exports.VellumVariable = core.serialization.object({
     id: core.serialization.string(),
     key: core.serialization.string(),
-    type: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).VellumVariableType; })),
+    type: VellumVariableType_1.VellumVariableType,
 });

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

@@ -4,17 +4,20 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { EntityStatus } from "./EntityStatus";
+import { EnvironmentEnum } from "./EnvironmentEnum";
+import { VellumVariable } from "./VellumVariable";
 export declare const WorkflowDeploymentRead: core.serialization.ObjectSchema<serializers.WorkflowDeploymentRead.Raw, Vellum.WorkflowDeploymentRead>;
 export declare namespace WorkflowDeploymentRead {
     interface Raw {
         id: string;
         name: string;
         label: string;
-        status?: serializers.EntityStatus.Raw | null;
-        environment?: serializers.EnvironmentEnum.Raw | null;
+        status?: EntityStatus.Raw | null;
+        environment?: EnvironmentEnum.Raw | null;
         created: string;
         last_deployed_on: string;
-        input_variables: serializers.VellumVariable.Raw[];
-        output_variables: serializers.VellumVariable.Raw[];
+        input_variables: VellumVariable.Raw[];
+        output_variables: VellumVariable.Raw[];
     }
 }

package/dist/serialization/types/WorkflowDeploymentRead.js

@@ -25,26 +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.WorkflowDeploymentRead = void 0;
 const core = __importStar(require("../../core"));
+const EntityStatus_1 = require("./EntityStatus");
+const EnvironmentEnum_1 = require("./EnvironmentEnum");
+const VellumVariable_1 = require("./VellumVariable");
 exports.WorkflowDeploymentRead = core.serialization.object({
     id: core.serialization.string(),
     name: core.serialization.string(),
     label: core.serialization.string(),
-    status: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).EntityStatus; })).optional(),
-    environment: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).EnvironmentEnum; })).optional(),
+    status: EntityStatus_1.EntityStatus.optional(),
+    environment: EnvironmentEnum_1.EnvironmentEnum.optional(),
     created: core.serialization.date(),
     lastDeployedOn: core.serialization.property("last_deployed_on", core.serialization.date()),
-    inputVariables: core.serialization.property("input_variables", core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).VellumVariable; })))),
-    outputVariables: core.serialization.property("output_variables", core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).VellumVariable; })))),
+    inputVariables: core.serialization.property("input_variables", core.serialization.list(VellumVariable_1.VellumVariable)),
+    outputVariables: core.serialization.property("output_variables", core.serialization.list(VellumVariable_1.VellumVariable)),
 });

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

@@ -4,10 +4,11 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { WorkflowExecutionEventErrorCode } from "./WorkflowExecutionEventErrorCode";
 export declare const WorkflowEventError: core.serialization.ObjectSchema<serializers.WorkflowEventError.Raw, Vellum.WorkflowEventError>;
 export declare namespace WorkflowEventError {
     interface Raw {
         message: string;
-        code: serializers.WorkflowExecutionEventErrorCode.Raw;
+        code: WorkflowExecutionEventErrorCode.Raw;
     }
 }

package/dist/serialization/types/WorkflowEventError.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.WorkflowEventError = void 0;
 const core = __importStar(require("../../core"));
+const WorkflowExecutionEventErrorCode_1 = require("./WorkflowExecutionEventErrorCode");
 exports.WorkflowEventError = core.serialization.object({
     message: core.serialization.string(),
-    code: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowExecutionEventErrorCode; })),
+    code: WorkflowExecutionEventErrorCode_1.WorkflowExecutionEventErrorCode,
 });

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

@@ -4,6 +4,7 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { ChatMessageRequest } from "./ChatMessageRequest";
 export declare const WorkflowExecutionActualChatHistoryRequest: core.serialization.ObjectSchema<serializers.WorkflowExecutionActualChatHistoryRequest.Raw, Vellum.WorkflowExecutionActualChatHistoryRequest>;
 export declare namespace WorkflowExecutionActualChatHistoryRequest {
     interface Raw {
@@ -11,6 +12,6 @@ export declare namespace WorkflowExecutionActualChatHistoryRequest {
         output_key?: string | null;
         quality?: number | null;
         timestamp?: number | null;
-        desired_output_value?: serializers.ChatMessageRequest.Raw[] | null;
+        desired_output_value?: ChatMessageRequest.Raw[] | null;
     }
 }

package/dist/serialization/types/WorkflowExecutionActualChatHistoryRequest.js

@@ -25,24 +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.WorkflowExecutionActualChatHistoryRequest = void 0;
 const core = __importStar(require("../../core"));
+const ChatMessageRequest_1 = require("./ChatMessageRequest");
 exports.WorkflowExecutionActualChatHistoryRequest = core.serialization.object({
     outputId: core.serialization.property("output_id", core.serialization.string().optional()),
     outputKey: core.serialization.property("output_key", core.serialization.string().optional()),
     quality: core.serialization.number().optional(),
     timestamp: core.serialization.number().optional(),
-    desiredOutputValue: core.serialization.property("desired_output_value", core.serialization
-        .list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ChatMessageRequest; })))
-        .optional()),
+    desiredOutputValue: core.serialization.property("desired_output_value", core.serialization.list(ChatMessageRequest_1.ChatMessageRequest).optional()),
 });

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

@@ -4,12 +4,13 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { WorkflowNodeResultEvent } from "./WorkflowNodeResultEvent";
 export declare const WorkflowExecutionNodeResultEvent: core.serialization.ObjectSchema<serializers.WorkflowExecutionNodeResultEvent.Raw, Vellum.WorkflowExecutionNodeResultEvent>;
 export declare namespace WorkflowExecutionNodeResultEvent {
     interface Raw {
         execution_id: string;
         run_id?: string | null;
         external_id?: string | null;
-        data: serializers.WorkflowNodeResultEvent.Raw;
+        data: WorkflowNodeResultEvent.Raw;
     }
 }

package/dist/serialization/types/WorkflowExecutionNodeResultEvent.js

@@ -25,21 +25,13 @@ 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.WorkflowExecutionNodeResultEvent = void 0;
 const core = __importStar(require("../../core"));
+const WorkflowNodeResultEvent_1 = require("./WorkflowNodeResultEvent");
 exports.WorkflowExecutionNodeResultEvent = core.serialization.object({
     executionId: core.serialization.property("execution_id", core.serialization.string()),
     runId: core.serialization.property("run_id", core.serialization.string().optional()),
     externalId: core.serialization.property("external_id", core.serialization.string().optional()),
-    data: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowNodeResultEvent; })),
+    data: WorkflowNodeResultEvent_1.WorkflowNodeResultEvent,
 });

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

@@ -4,12 +4,13 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { WorkflowResultEvent } from "./WorkflowResultEvent";
 export declare const WorkflowExecutionWorkflowResultEvent: core.serialization.ObjectSchema<serializers.WorkflowExecutionWorkflowResultEvent.Raw, Vellum.WorkflowExecutionWorkflowResultEvent>;
 export declare namespace WorkflowExecutionWorkflowResultEvent {
     interface Raw {
         execution_id: string;
         run_id?: string | null;
         external_id?: string | null;
-        data: serializers.WorkflowResultEvent.Raw;
+        data: WorkflowResultEvent.Raw;
     }
 }

package/dist/serialization/types/WorkflowExecutionWorkflowResultEvent.js

@@ -25,21 +25,13 @@ 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.WorkflowExecutionWorkflowResultEvent = void 0;
 const core = __importStar(require("../../core"));
+const WorkflowResultEvent_1 = require("./WorkflowResultEvent");
 exports.WorkflowExecutionWorkflowResultEvent = core.serialization.object({
     executionId: core.serialization.property("execution_id", core.serialization.string()),
     runId: core.serialization.property("run_id", core.serialization.string().optional()),
     externalId: core.serialization.property("external_id", core.serialization.string().optional()),
-    data: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowResultEvent; })),
+    data: WorkflowResultEvent_1.WorkflowResultEvent,
 });

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

@@ -4,31 +4,39 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { PromptNodeResult } from "./PromptNodeResult";
+import { SearchNodeResult } from "./SearchNodeResult";
+import { TemplatingNodeResult } from "./TemplatingNodeResult";
+import { CodeExecutionNodeResult } from "./CodeExecutionNodeResult";
+import { ConditionalNodeResult } from "./ConditionalNodeResult";
+import { ApiNodeResult } from "./ApiNodeResult";
+import { TerminalNodeResult } from "./TerminalNodeResult";
+import { SubworkflowNodeResult } from "./SubworkflowNodeResult";
 export declare const WorkflowNodeResultData: core.serialization.Schema<serializers.WorkflowNodeResultData.Raw, Vellum.WorkflowNodeResultData>;
 export declare namespace WorkflowNodeResultData {
     type Raw = WorkflowNodeResultData.Prompt | WorkflowNodeResultData.Search | WorkflowNodeResultData.Templating | WorkflowNodeResultData.CodeExecution | WorkflowNodeResultData.Conditional | WorkflowNodeResultData.Api | WorkflowNodeResultData.Terminal | WorkflowNodeResultData.Subworkflow;
-    interface Prompt extends serializers.PromptNodeResult.Raw {
+    interface Prompt extends PromptNodeResult.Raw {
         type: "PROMPT";
     }
-    interface Search extends serializers.SearchNodeResult.Raw {
+    interface Search extends SearchNodeResult.Raw {
         type: "SEARCH";
     }
-    interface Templating extends serializers.TemplatingNodeResult.Raw {
+    interface Templating extends TemplatingNodeResult.Raw {
         type: "TEMPLATING";
     }
-    interface CodeExecution extends serializers.CodeExecutionNodeResult.Raw {
+    interface CodeExecution extends CodeExecutionNodeResult.Raw {
         type: "CODE_EXECUTION";
     }
-    interface Conditional extends serializers.ConditionalNodeResult.Raw {
+    interface Conditional extends ConditionalNodeResult.Raw {
         type: "CONDITIONAL";
     }
-    interface Api extends serializers.ApiNodeResult.Raw {
+    interface Api extends ApiNodeResult.Raw {
         type: "API";
     }
-    interface Terminal extends serializers.TerminalNodeResult.Raw {
+    interface Terminal extends TerminalNodeResult.Raw {
         type: "TERMINAL";
     }
-    interface Subworkflow extends serializers.SubworkflowNodeResult.Raw {
+    interface Subworkflow extends SubworkflowNodeResult.Raw {
         type: "SUBWORKFLOW";
     }
 }

package/dist/serialization/types/WorkflowNodeResultData.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.WorkflowNodeResultData = void 0;
 const core = __importStar(require("../../core"));
+const PromptNodeResult_1 = require("./PromptNodeResult");
+const SearchNodeResult_1 = require("./SearchNodeResult");
+const TemplatingNodeResult_1 = require("./TemplatingNodeResult");
+const CodeExecutionNodeResult_1 = require("./CodeExecutionNodeResult");
+const ConditionalNodeResult_1 = require("./ConditionalNodeResult");
+const ApiNodeResult_1 = require("./ApiNodeResult");
+const TerminalNodeResult_1 = require("./TerminalNodeResult");
+const SubworkflowNodeResult_1 = require("./SubworkflowNodeResult");
 exports.WorkflowNodeResultData = core.serialization
     .union("type", {
-    PROMPT: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).PromptNodeResult; })),
-    SEARCH: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).SearchNodeResult; })),
-    TEMPLATING: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TemplatingNodeResult; })),
-    CODE_EXECUTION: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).CodeExecutionNodeResult; })),
-    CONDITIONAL: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ConditionalNodeResult; })),
-    API: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ApiNodeResult; })),
-    TERMINAL: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TerminalNodeResult; })),
-    SUBWORKFLOW: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).SubworkflowNodeResult; })),
+    PROMPT: PromptNodeResult_1.PromptNodeResult,
+    SEARCH: SearchNodeResult_1.SearchNodeResult,
+    TEMPLATING: TemplatingNodeResult_1.TemplatingNodeResult,
+    CODE_EXECUTION: CodeExecutionNodeResult_1.CodeExecutionNodeResult,
+    CONDITIONAL: ConditionalNodeResult_1.ConditionalNodeResult,
+    API: ApiNodeResult_1.ApiNodeResult,
+    TERMINAL: TerminalNodeResult_1.TerminalNodeResult,
+    SUBWORKFLOW: SubworkflowNodeResult_1.SubworkflowNodeResult,
 })
     .transform({
     transform: (value) => value,

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

@@ -4,19 +4,23 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { InitiatedWorkflowNodeResultEvent } from "./InitiatedWorkflowNodeResultEvent";
+import { StreamingWorkflowNodeResultEvent } from "./StreamingWorkflowNodeResultEvent";
+import { FulfilledWorkflowNodeResultEvent } from "./FulfilledWorkflowNodeResultEvent";
+import { RejectedWorkflowNodeResultEvent } from "./RejectedWorkflowNodeResultEvent";
 export declare const WorkflowNodeResultEvent: core.serialization.Schema<serializers.WorkflowNodeResultEvent.Raw, Vellum.WorkflowNodeResultEvent>;
 export declare namespace WorkflowNodeResultEvent {
     type Raw = WorkflowNodeResultEvent.Initiated | WorkflowNodeResultEvent.Streaming | WorkflowNodeResultEvent.Fulfilled | WorkflowNodeResultEvent.Rejected;
-    interface Initiated extends serializers.InitiatedWorkflowNodeResultEvent.Raw {
+    interface Initiated extends InitiatedWorkflowNodeResultEvent.Raw {
         state: "INITIATED";
     }
-    interface Streaming extends serializers.StreamingWorkflowNodeResultEvent.Raw {
+    interface Streaming extends StreamingWorkflowNodeResultEvent.Raw {
         state: "STREAMING";
     }
-    interface Fulfilled extends serializers.FulfilledWorkflowNodeResultEvent.Raw {
+    interface Fulfilled extends FulfilledWorkflowNodeResultEvent.Raw {
         state: "FULFILLED";
     }
-    interface Rejected extends serializers.RejectedWorkflowNodeResultEvent.Raw {
+    interface Rejected extends RejectedWorkflowNodeResultEvent.Raw {
         state: "REJECTED";
     }
 }

package/dist/serialization/types/WorkflowNodeResultEvent.js

@@ -25,24 +25,19 @@ 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.WorkflowNodeResultEvent = void 0;
 const core = __importStar(require("../../core"));
+const InitiatedWorkflowNodeResultEvent_1 = require("./InitiatedWorkflowNodeResultEvent");
+const StreamingWorkflowNodeResultEvent_1 = require("./StreamingWorkflowNodeResultEvent");
+const FulfilledWorkflowNodeResultEvent_1 = require("./FulfilledWorkflowNodeResultEvent");
+const RejectedWorkflowNodeResultEvent_1 = require("./RejectedWorkflowNodeResultEvent");
 exports.WorkflowNodeResultEvent = core.serialization
     .union("state", {
-    INITIATED: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).InitiatedWorkflowNodeResultEvent; })),
-    STREAMING: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).StreamingWorkflowNodeResultEvent; })),
-    FULFILLED: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).FulfilledWorkflowNodeResultEvent; })),
-    REJECTED: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).RejectedWorkflowNodeResultEvent; })),
+    INITIATED: InitiatedWorkflowNodeResultEvent_1.InitiatedWorkflowNodeResultEvent,
+    STREAMING: StreamingWorkflowNodeResultEvent_1.StreamingWorkflowNodeResultEvent,
+    FULFILLED: FulfilledWorkflowNodeResultEvent_1.FulfilledWorkflowNodeResultEvent,
+    REJECTED: RejectedWorkflowNodeResultEvent_1.RejectedWorkflowNodeResultEvent,
 })
     .transform({
     transform: (value) => value,

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

@@ -4,34 +4,43 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { WorkflowOutputString } from "./WorkflowOutputString";
+import { WorkflowOutputNumber } from "./WorkflowOutputNumber";
+import { WorkflowOutputJson } from "./WorkflowOutputJson";
+import { WorkflowOutputChatHistory } from "./WorkflowOutputChatHistory";
+import { WorkflowOutputSearchResults } from "./WorkflowOutputSearchResults";
+import { WorkflowOutputArray } from "./WorkflowOutputArray";
+import { WorkflowOutputError } from "./WorkflowOutputError";
+import { WorkflowOutputFunctionCall } from "./WorkflowOutputFunctionCall";
+import { WorkflowOutputImage } from "./WorkflowOutputImage";
 export declare const WorkflowOutput: core.serialization.Schema<serializers.WorkflowOutput.Raw, Vellum.WorkflowOutput>;
 export declare namespace WorkflowOutput {
     type Raw = WorkflowOutput.String | WorkflowOutput.Number | WorkflowOutput.Json | WorkflowOutput.ChatHistory | WorkflowOutput.SearchResults | WorkflowOutput.Array | WorkflowOutput.Error | WorkflowOutput.FunctionCall | WorkflowOutput.Image;
-    interface String extends serializers.WorkflowOutputString.Raw {
+    interface String extends WorkflowOutputString.Raw {
         type: "STRING";
     }
-    interface Number extends serializers.WorkflowOutputNumber.Raw {
+    interface Number extends WorkflowOutputNumber.Raw {
         type: "NUMBER";
     }
-    interface Json extends serializers.WorkflowOutputJson.Raw {
+    interface Json extends WorkflowOutputJson.Raw {
         type: "JSON";
     }
-    interface ChatHistory extends serializers.WorkflowOutputChatHistory.Raw {
+    interface ChatHistory extends WorkflowOutputChatHistory.Raw {
         type: "CHAT_HISTORY";
     }
-    interface SearchResults extends serializers.WorkflowOutputSearchResults.Raw {
+    interface SearchResults extends WorkflowOutputSearchResults.Raw {
         type: "SEARCH_RESULTS";
     }
-    interface Array extends serializers.WorkflowOutputArray.Raw {
+    interface Array extends WorkflowOutputArray.Raw {
         type: "ARRAY";
     }
-    interface Error extends serializers.WorkflowOutputError.Raw {
+    interface Error extends WorkflowOutputError.Raw {
         type: "ERROR";
     }
-    interface FunctionCall extends serializers.WorkflowOutputFunctionCall.Raw {
+    interface FunctionCall extends WorkflowOutputFunctionCall.Raw {
         type: "FUNCTION_CALL";
     }
-    interface Image extends serializers.WorkflowOutputImage.Raw {
+    interface Image extends WorkflowOutputImage.Raw {
         type: "IMAGE";
     }
 }

package/dist/serialization/types/WorkflowOutput.js

@@ -25,29 +25,29 @@ 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.WorkflowOutput = void 0;
 const core = __importStar(require("../../core"));
+const WorkflowOutputString_1 = require("./WorkflowOutputString");
+const WorkflowOutputNumber_1 = require("./WorkflowOutputNumber");
+const WorkflowOutputJson_1 = require("./WorkflowOutputJson");
+const WorkflowOutputChatHistory_1 = require("./WorkflowOutputChatHistory");
+const WorkflowOutputSearchResults_1 = require("./WorkflowOutputSearchResults");
+const WorkflowOutputArray_1 = require("./WorkflowOutputArray");
+const WorkflowOutputError_1 = require("./WorkflowOutputError");
+const WorkflowOutputFunctionCall_1 = require("./WorkflowOutputFunctionCall");
+const WorkflowOutputImage_1 = require("./WorkflowOutputImage");
 exports.WorkflowOutput = core.serialization
     .union("type", {
-    STRING: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowOutputString; })),
-    NUMBER: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowOutputNumber; })),
-    JSON: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowOutputJson; })),
-    CHAT_HISTORY: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowOutputChatHistory; })),
-    SEARCH_RESULTS: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowOutputSearchResults; })),
-    ARRAY: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowOutputArray; })),
-    ERROR: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowOutputError; })),
-    FUNCTION_CALL: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowOutputFunctionCall; })),
-    IMAGE: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowOutputImage; })),
+    STRING: WorkflowOutputString_1.WorkflowOutputString,
+    NUMBER: WorkflowOutputNumber_1.WorkflowOutputNumber,
+    JSON: WorkflowOutputJson_1.WorkflowOutputJson,
+    CHAT_HISTORY: WorkflowOutputChatHistory_1.WorkflowOutputChatHistory,
+    SEARCH_RESULTS: WorkflowOutputSearchResults_1.WorkflowOutputSearchResults,
+    ARRAY: WorkflowOutputArray_1.WorkflowOutputArray,
+    ERROR: WorkflowOutputError_1.WorkflowOutputError,
+    FUNCTION_CALL: WorkflowOutputFunctionCall_1.WorkflowOutputFunctionCall,
+    IMAGE: WorkflowOutputImage_1.WorkflowOutputImage,
 })
     .transform({
     transform: (value) => value,

package/dist/serialization/types/WorkflowOutputArray.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 WorkflowOutputArray: core.serialization.ObjectSchema<serializers.WorkflowOutputArray.Raw, Vellum.WorkflowOutputArray>;
 export declare namespace WorkflowOutputArray {
     interface Raw {
         id: string;
         name: string;
-        value?: serializers.ArrayVariableValueItem.Raw[] | null;
+        value?: ArrayVariableValueItem.Raw[] | null;
     }
 }

package/dist/serialization/types/WorkflowOutputArray.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.WorkflowOutputArray = void 0;
 const core = __importStar(require("../../core"));
+const ArrayVariableValueItem_1 = require("./ArrayVariableValueItem");
 exports.WorkflowOutputArray = core.serialization.object({
     id: core.serialization.string(),
     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/WorkflowOutputChatHistory.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 WorkflowOutputChatHistory: core.serialization.ObjectSchema<serializers.WorkflowOutputChatHistory.Raw, Vellum.WorkflowOutputChatHistory>;
 export declare namespace WorkflowOutputChatHistory {
     interface Raw {
         id: string;
         name: string;
-        value?: serializers.ChatMessage.Raw[] | null;
+        value?: ChatMessage.Raw[] | null;
     }
 }