vellum-ai 0.3.14 → 0.3.16

package/serialization/types/FulfilledExecuteWorkflowWorkflowResultEvent.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.FulfilledExecuteWorkflowWorkflowResultEvent = void 0;
 const core = __importStar(require("../../core"));
+const WorkflowOutput_1 = require("./WorkflowOutput");
 exports.FulfilledExecuteWorkflowWorkflowResultEvent = core.serialization.object({
     id: core.serialization.string(),
     ts: core.serialization.date(),
-    outputs: core.serialization.list(core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowOutput; }))),
+    outputs: core.serialization.list(WorkflowOutput_1.WorkflowOutput),
 });

package/serialization/types/FulfilledPromptExecutionMeta.d.ts

@@ -4,10 +4,11 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { FinishReasonEnum } from "./FinishReasonEnum";
 export declare const FulfilledPromptExecutionMeta: core.serialization.ObjectSchema<serializers.FulfilledPromptExecutionMeta.Raw, Vellum.FulfilledPromptExecutionMeta>;
 export declare namespace FulfilledPromptExecutionMeta {
     interface Raw {
         latency?: number | null;
-        finish_reason?: serializers.FinishReasonEnum.Raw | null;
+        finish_reason?: FinishReasonEnum.Raw | null;
     }
 }

package/serialization/types/FulfilledPromptExecutionMeta.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.FulfilledPromptExecutionMeta = void 0;
 const core = __importStar(require("../../core"));
+const FinishReasonEnum_1 = require("./FinishReasonEnum");
 exports.FulfilledPromptExecutionMeta = core.serialization.object({
     latency: core.serialization.number().optional(),
-    finishReason: core.serialization.property("finish_reason", core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).FinishReasonEnum; })).optional()),
+    finishReason: core.serialization.property("finish_reason", FinishReasonEnum_1.FinishReasonEnum.optional()),
 });

package/serialization/types/FulfilledWorkflowNodeResultEvent.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 FulfilledWorkflowNodeResultEvent: core.serialization.ObjectSchema<serializers.FulfilledWorkflowNodeResultEvent.Raw, Vellum.FulfilledWorkflowNodeResultEvent>;
 export declare namespace FulfilledWorkflowNodeResultEvent {
     interface Raw {
@@ -11,9 +13,9 @@ export declare namespace FulfilledWorkflowNodeResultEvent {
         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_values?: serializers.NodeOutputCompiledValue.Raw[] | null;
+        output_values?: NodeOutputCompiledValue.Raw[] | null;
         mocked?: boolean | null;
     }
 }

package/serialization/types/FulfilledWorkflowNodeResultEvent.js

@@ -25,27 +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.FulfilledWorkflowNodeResultEvent = void 0;
 const core = __importStar(require("../../core"));
+const WorkflowNodeResultData_1 = require("./WorkflowNodeResultData");
+const NodeOutputCompiledValue_1 = require("./NodeOutputCompiledValue");
 exports.FulfilledWorkflowNodeResultEvent = 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()),
-    outputValues: core.serialization.property("output_values", core.serialization
-        .list(core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NodeOutputCompiledValue; })))
-        .optional()),
+    outputValues: core.serialization.property("output_values", core.serialization.list(NodeOutputCompiledValue_1.NodeOutputCompiledValue).optional()),
     mocked: core.serialization.boolean().optional(),
 });

package/serialization/types/FunctionCall.d.ts

@@ -4,13 +4,15 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { FulfilledFunctionCall } from "./FulfilledFunctionCall";
+import { RejectedFunctionCall } from "./RejectedFunctionCall";
 export declare const FunctionCall: core.serialization.Schema<serializers.FunctionCall.Raw, Vellum.FunctionCall>;
 export declare namespace FunctionCall {
     type Raw = FunctionCall.Fulfilled | FunctionCall.Rejected;
-    interface Fulfilled extends serializers.FulfilledFunctionCall.Raw {
+    interface Fulfilled extends FulfilledFunctionCall.Raw {
         state: "FULFILLED";
     }
-    interface Rejected extends serializers.RejectedFunctionCall.Raw {
+    interface Rejected extends RejectedFunctionCall.Raw {
         state: "REJECTED";
     }
 }

package/serialization/types/FunctionCall.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.FunctionCall = void 0;
 const core = __importStar(require("../../core"));
+const FulfilledFunctionCall_1 = require("./FulfilledFunctionCall");
+const RejectedFunctionCall_1 = require("./RejectedFunctionCall");
 exports.FunctionCall = core.serialization
     .union("state", {
-    FULFILLED: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).FulfilledFunctionCall; })),
-    REJECTED: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).RejectedFunctionCall; })),
+    FULFILLED: FulfilledFunctionCall_1.FulfilledFunctionCall,
+    REJECTED: RejectedFunctionCall_1.RejectedFunctionCall,
 })
     .transform({
     transform: (value) => value,

package/serialization/types/FunctionCallChatMessageContent.d.ts

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

package/serialization/types/FunctionCallChatMessageContent.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.FunctionCallChatMessageContent = void 0;
 const core = __importStar(require("../../core"));
+const FunctionCallChatMessageContentValue_1 = require("./FunctionCallChatMessageContentValue");
 exports.FunctionCallChatMessageContent = core.serialization.object({
-    value: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).FunctionCallChatMessageContentValue; })),
+    value: FunctionCallChatMessageContentValue_1.FunctionCallChatMessageContentValue,
 });

package/serialization/types/FunctionCallChatMessageContentRequest.d.ts

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

package/serialization/types/FunctionCallChatMessageContentRequest.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.FunctionCallChatMessageContentRequest = void 0;
 const core = __importStar(require("../../core"));
+const FunctionCallChatMessageContentValueRequest_1 = require("./FunctionCallChatMessageContentValueRequest");
 exports.FunctionCallChatMessageContentRequest = core.serialization.object({
-    value: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).FunctionCallChatMessageContentValueRequest; })),
+    value: FunctionCallChatMessageContentValueRequest_1.FunctionCallChatMessageContentValueRequest,
 });

package/serialization/types/FunctionCallVariableValue.d.ts

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

package/serialization/types/FunctionCallVariableValue.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.FunctionCallVariableValue = void 0;
 const core = __importStar(require("../../core"));
+const FunctionCall_1 = require("./FunctionCall");
 exports.FunctionCallVariableValue = core.serialization.object({
-    value: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).FunctionCall; })),
+    value: FunctionCall_1.FunctionCall,
 });

package/serialization/types/GenerateOptionsRequest.d.ts

@@ -4,9 +4,10 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { LogprobsEnum } from "./LogprobsEnum";
 export declare const GenerateOptionsRequest: core.serialization.ObjectSchema<serializers.GenerateOptionsRequest.Raw, Vellum.GenerateOptionsRequest>;
 export declare namespace GenerateOptionsRequest {
     interface Raw {
-        logprobs?: serializers.LogprobsEnum.Raw | null;
+        logprobs?: LogprobsEnum.Raw | null;
     }
 }

package/serialization/types/GenerateOptionsRequest.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.GenerateOptionsRequest = void 0;
 const core = __importStar(require("../../core"));
+const LogprobsEnum_1 = require("./LogprobsEnum");
 exports.GenerateOptionsRequest = core.serialization.object({
-    logprobs: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).LogprobsEnum; })).optional(),
+    logprobs: LogprobsEnum_1.LogprobsEnum.optional(),
 });

package/serialization/types/GenerateRequest.d.ts

@@ -4,11 +4,12 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { ChatMessageRequest } from "./ChatMessageRequest";
 export declare const GenerateRequest: core.serialization.ObjectSchema<serializers.GenerateRequest.Raw, Vellum.GenerateRequest>;
 export declare namespace GenerateRequest {
     interface Raw {
         input_values: Record<string, unknown>;
-        chat_history?: serializers.ChatMessageRequest.Raw[] | null;
+        chat_history?: ChatMessageRequest.Raw[] | null;
         external_ids?: string[] | null;
     }
 }

package/serialization/types/GenerateRequest.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.GenerateRequest = void 0;
 const core = __importStar(require("../../core"));
+const ChatMessageRequest_1 = require("./ChatMessageRequest");
 exports.GenerateRequest = core.serialization.object({
     inputValues: core.serialization.property("input_values", core.serialization.record(core.serialization.string(), core.serialization.unknown())),
-    chatHistory: core.serialization.property("chat_history", core.serialization
-        .list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ChatMessageRequest; })))
-        .optional()),
+    chatHistory: core.serialization.property("chat_history", core.serialization.list(ChatMessageRequest_1.ChatMessageRequest).optional()),
     externalIds: core.serialization.property("external_ids", core.serialization.list(core.serialization.string()).optional()),
 });

package/serialization/types/GenerateResponse.d.ts

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

package/serialization/types/GenerateResponse.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.GenerateResponse = void 0;
 const core = __importStar(require("../../core"));
+const GenerateResult_1 = require("./GenerateResult");
 exports.GenerateResponse = core.serialization.object({
-    results: core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).GenerateResult; }))),
+    results: core.serialization.list(GenerateResult_1.GenerateResult),
 });

package/serialization/types/GenerateResult.d.ts

@@ -4,10 +4,12 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { GenerateResultData } from "./GenerateResultData";
+import { GenerateResultError } from "./GenerateResultError";
 export declare const GenerateResult: core.serialization.ObjectSchema<serializers.GenerateResult.Raw, Vellum.GenerateResult>;
 export declare namespace GenerateResult {
     interface Raw {
-        data?: serializers.GenerateResultData.Raw | null;
-        error?: serializers.GenerateResultError.Raw | null;
+        data?: GenerateResultData.Raw | null;
+        error?: GenerateResultError.Raw | null;
     }
 }

package/serialization/types/GenerateResult.js

@@ -25,19 +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.GenerateResult = void 0;
 const core = __importStar(require("../../core"));
+const GenerateResultData_1 = require("./GenerateResultData");
+const GenerateResultError_1 = require("./GenerateResultError");
 exports.GenerateResult = core.serialization.object({
-    data: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).GenerateResultData; })).optional(),
-    error: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).GenerateResultError; })).optional(),
+    data: GenerateResultData_1.GenerateResultData.optional(),
+    error: GenerateResultError_1.GenerateResultError.optional(),
 });

package/serialization/types/GenerateResultData.d.ts

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

package/serialization/types/GenerateResultData.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.GenerateResultData = void 0;
 const core = __importStar(require("../../core"));
+const EnrichedNormalizedCompletion_1 = require("./EnrichedNormalizedCompletion");
 exports.GenerateResultData = core.serialization.object({
-    completions: core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).EnrichedNormalizedCompletion; }))),
+    completions: core.serialization.list(EnrichedNormalizedCompletion_1.EnrichedNormalizedCompletion),
 });

package/serialization/types/GenerateStreamResponse.d.ts

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

package/serialization/types/GenerateStreamResponse.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.GenerateStreamResponse = void 0;
 const core = __importStar(require("../../core"));
+const GenerateStreamResult_1 = require("./GenerateStreamResult");
 exports.GenerateStreamResponse = core.serialization.object({
-    delta: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).GenerateStreamResult; })),
+    delta: GenerateStreamResult_1.GenerateStreamResult,
 });

package/serialization/types/GenerateStreamResult.d.ts

@@ -4,11 +4,13 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { GenerateStreamResultData } from "./GenerateStreamResultData";
+import { GenerateResultError } from "./GenerateResultError";
 export declare const GenerateStreamResult: core.serialization.ObjectSchema<serializers.GenerateStreamResult.Raw, Vellum.GenerateStreamResult>;
 export declare namespace GenerateStreamResult {
     interface Raw {
         request_index: number;
-        data?: serializers.GenerateStreamResultData.Raw | null;
-        error?: serializers.GenerateResultError.Raw | null;
+        data?: GenerateStreamResultData.Raw | null;
+        error?: GenerateResultError.Raw | null;
     }
 }

package/serialization/types/GenerateStreamResult.js

@@ -25,20 +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.GenerateStreamResult = void 0;
 const core = __importStar(require("../../core"));
+const GenerateStreamResultData_1 = require("./GenerateStreamResultData");
+const GenerateResultError_1 = require("./GenerateResultError");
 exports.GenerateStreamResult = core.serialization.object({
     requestIndex: core.serialization.property("request_index", core.serialization.number()),
-    data: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).GenerateStreamResultData; })).optional(),
-    error: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).GenerateResultError; })).optional(),
+    data: GenerateStreamResultData_1.GenerateStreamResultData.optional(),
+    error: GenerateResultError_1.GenerateResultError.optional(),
 });

package/serialization/types/GenerateStreamResultData.d.ts

@@ -4,10 +4,11 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { EnrichedNormalizedCompletion } from "./EnrichedNormalizedCompletion";
 export declare const GenerateStreamResultData: core.serialization.ObjectSchema<serializers.GenerateStreamResultData.Raw, Vellum.GenerateStreamResultData>;
 export declare namespace GenerateStreamResultData {
     interface Raw {
         completion_index: number;
-        completion: serializers.EnrichedNormalizedCompletion.Raw;
+        completion: EnrichedNormalizedCompletion.Raw;
     }
 }

package/serialization/types/GenerateStreamResultData.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.GenerateStreamResultData = void 0;
 const core = __importStar(require("../../core"));
+const EnrichedNormalizedCompletion_1 = require("./EnrichedNormalizedCompletion");
 exports.GenerateStreamResultData = core.serialization.object({
     completionIndex: core.serialization.property("completion_index", core.serialization.number()),
-    completion: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).EnrichedNormalizedCompletion; })),
+    completion: EnrichedNormalizedCompletion_1.EnrichedNormalizedCompletion,
 });

package/serialization/types/ImageChatMessageContent.d.ts

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

package/serialization/types/ImageChatMessageContent.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.ImageChatMessageContent = void 0;
 const core = __importStar(require("../../core"));
+const VellumImage_1 = require("./VellumImage");
 exports.ImageChatMessageContent = core.serialization.object({
-    value: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).VellumImage; })),
+    value: VellumImage_1.VellumImage,
 });

package/serialization/types/ImageChatMessageContentRequest.d.ts

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