vellum-ai 0.3.14 → 0.3.16

package/dist/serialization/types/DeploymentRead.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.DeploymentRead = void 0;
 const core = __importStar(require("../../core"));
+const EntityStatus_1 = require("./EntityStatus");
+const EnvironmentEnum_1 = require("./EnvironmentEnum");
+const VellumVariable_1 = require("./VellumVariable");
 exports.DeploymentRead = core.serialization.object({
     id: core.serialization.string(),
     created: core.serialization.date(),
     label: core.serialization.string(),
     name: 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(),
     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; })))),
+    inputVariables: core.serialization.property("input_variables", core.serialization.list(VellumVariable_1.VellumVariable)),
     activeModelVersionIds: core.serialization.property("active_model_version_ids", core.serialization.list(core.serialization.string())),
 });

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

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

package/dist/serialization/types/DocumentDocumentToDocumentIndex.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.DocumentDocumentToDocumentIndex = void 0;
 const core = __importStar(require("../../core"));
+const IndexingStateEnum_1 = require("./IndexingStateEnum");
 exports.DocumentDocumentToDocumentIndex = core.serialization.object({
     id: core.serialization.string(),
     documentIndexId: core.serialization.property("document_index_id", core.serialization.string()),
-    indexingState: core.serialization.property("indexing_state", core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).IndexingStateEnum; })).optional()),
+    indexingState: core.serialization.property("indexing_state", IndexingStateEnum_1.IndexingStateEnum.optional()),
 });

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

@@ -4,6 +4,8 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { EntityStatus } from "./EntityStatus";
+import { EnvironmentEnum } from "./EnvironmentEnum";
 export declare const DocumentIndexRead: core.serialization.ObjectSchema<serializers.DocumentIndexRead.Raw, Vellum.DocumentIndexRead>;
 export declare namespace DocumentIndexRead {
     interface Raw {
@@ -11,8 +13,8 @@ export declare namespace DocumentIndexRead {
         created: string;
         label: string;
         name: string;
-        status?: serializers.EntityStatus.Raw | null;
-        environment?: serializers.EnvironmentEnum.Raw | null;
+        status?: EntityStatus.Raw | null;
+        environment?: EnvironmentEnum.Raw | null;
         indexing_config: Record<string, unknown>;
     }
 }

package/dist/serialization/types/DocumentIndexRead.js

@@ -25,24 +25,17 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DocumentIndexRead = void 0;
 const core = __importStar(require("../../core"));
+const EntityStatus_1 = require("./EntityStatus");
+const EnvironmentEnum_1 = require("./EnvironmentEnum");
 exports.DocumentIndexRead = core.serialization.object({
     id: core.serialization.string(),
     created: core.serialization.date(),
     label: core.serialization.string(),
     name: 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(),
     indexingConfig: core.serialization.property("indexing_config", core.serialization.record(core.serialization.string(), core.serialization.unknown())),
 });

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

@@ -4,6 +4,9 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { ProcessingStateEnum } from "./ProcessingStateEnum";
+import { DocumentStatus } from "./DocumentStatus";
+import { DocumentDocumentToDocumentIndex } from "./DocumentDocumentToDocumentIndex";
 export declare const DocumentRead: core.serialization.ObjectSchema<serializers.DocumentRead.Raw, Vellum.DocumentRead>;
 export declare namespace DocumentRead {
     interface Raw {
@@ -11,11 +14,11 @@ export declare namespace DocumentRead {
         external_id?: string | null;
         last_uploaded_at: string;
         label: string;
-        processing_state?: serializers.ProcessingStateEnum.Raw | null;
-        status?: serializers.DocumentStatus.Raw | null;
+        processing_state?: ProcessingStateEnum.Raw | null;
+        status?: DocumentStatus.Raw | null;
         original_file_url?: string | null;
         processed_file_url?: string | null;
-        document_to_document_indexes: serializers.DocumentDocumentToDocumentIndex.Raw[];
+        document_to_document_indexes: DocumentDocumentToDocumentIndex.Raw[];
         metadata?: Record<string, unknown> | null;
     }
 }

package/dist/serialization/types/DocumentRead.js

@@ -25,27 +25,21 @@ 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.DocumentRead = void 0;
 const core = __importStar(require("../../core"));
+const ProcessingStateEnum_1 = require("./ProcessingStateEnum");
+const DocumentStatus_1 = require("./DocumentStatus");
+const DocumentDocumentToDocumentIndex_1 = require("./DocumentDocumentToDocumentIndex");
 exports.DocumentRead = core.serialization.object({
     id: core.serialization.string(),
     externalId: core.serialization.property("external_id", core.serialization.string().optional()),
     lastUploadedAt: core.serialization.property("last_uploaded_at", core.serialization.date()),
     label: core.serialization.string(),
-    processingState: core.serialization.property("processing_state", core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ProcessingStateEnum; })).optional()),
-    status: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).DocumentStatus; })).optional(),
+    processingState: core.serialization.property("processing_state", ProcessingStateEnum_1.ProcessingStateEnum.optional()),
+    status: DocumentStatus_1.DocumentStatus.optional(),
     originalFileUrl: core.serialization.property("original_file_url", core.serialization.string().optional()),
     processedFileUrl: core.serialization.property("processed_file_url", core.serialization.string().optional()),
-    documentToDocumentIndexes: core.serialization.property("document_to_document_indexes", core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).DocumentDocumentToDocumentIndex; })))),
+    documentToDocumentIndexes: core.serialization.property("document_to_document_indexes", core.serialization.list(DocumentDocumentToDocumentIndex_1.DocumentDocumentToDocumentIndex)),
     metadata: core.serialization.record(core.serialization.string(), core.serialization.unknown()).optional(),
 });

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

@@ -4,17 +4,20 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { FinishReasonEnum } from "./FinishReasonEnum";
+import { NormalizedLogProbs } from "./NormalizedLogProbs";
+import { VellumVariableType } from "./VellumVariableType";
 export declare const EnrichedNormalizedCompletion: core.serialization.ObjectSchema<serializers.EnrichedNormalizedCompletion.Raw, Vellum.EnrichedNormalizedCompletion>;
 export declare namespace EnrichedNormalizedCompletion {
     interface Raw {
         id: string;
         external_id?: string | null;
         text: string;
-        finish_reason?: serializers.FinishReasonEnum.Raw | null;
-        logprobs?: serializers.NormalizedLogProbs.Raw | null;
+        finish_reason?: FinishReasonEnum.Raw | null;
+        logprobs?: NormalizedLogProbs.Raw | null;
         model_version_id: string;
         prompt_version_id: string;
-        type?: serializers.VellumVariableType.Raw | null;
+        type?: VellumVariableType.Raw | null;
         deployment_release_tag: string;
         model_name: string;
     }

package/dist/serialization/types/EnrichedNormalizedCompletion.js

@@ -25,27 +25,21 @@ 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.EnrichedNormalizedCompletion = void 0;
 const core = __importStar(require("../../core"));
+const FinishReasonEnum_1 = require("./FinishReasonEnum");
+const NormalizedLogProbs_1 = require("./NormalizedLogProbs");
+const VellumVariableType_1 = require("./VellumVariableType");
 exports.EnrichedNormalizedCompletion = core.serialization.object({
     id: core.serialization.string(),
     externalId: core.serialization.property("external_id", core.serialization.string().optional()),
     text: core.serialization.string(),
-    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()),
-    logprobs: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NormalizedLogProbs; })).optional(),
+    finishReason: core.serialization.property("finish_reason", FinishReasonEnum_1.FinishReasonEnum.optional()),
+    logprobs: NormalizedLogProbs_1.NormalizedLogProbs.optional(),
     modelVersionId: core.serialization.property("model_version_id", core.serialization.string()),
     promptVersionId: core.serialization.property("prompt_version_id", core.serialization.string()),
-    type: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).VellumVariableType; })).optional(),
+    type: VellumVariableType_1.VellumVariableType.optional(),
     deploymentReleaseTag: core.serialization.property("deployment_release_tag", core.serialization.string()),
     modelName: core.serialization.property("model_name", core.serialization.string()),
 });

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

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

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

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

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

package/dist/serialization/types/ExecutePromptEvent.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.ExecutePromptEvent = void 0;
 const core = __importStar(require("../../core"));
+const InitiatedExecutePromptEvent_1 = require("./InitiatedExecutePromptEvent");
+const StreamingExecutePromptEvent_1 = require("./StreamingExecutePromptEvent");
+const FulfilledExecutePromptEvent_1 = require("./FulfilledExecutePromptEvent");
+const RejectedExecutePromptEvent_1 = require("./RejectedExecutePromptEvent");
 exports.ExecutePromptEvent = core.serialization
     .union("state", {
-    INITIATED: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).InitiatedExecutePromptEvent; })),
-    STREAMING: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).StreamingExecutePromptEvent; })),
-    FULFILLED: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).FulfilledExecutePromptEvent; })),
-    REJECTED: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).RejectedExecutePromptEvent; })),
+    INITIATED: InitiatedExecutePromptEvent_1.InitiatedExecutePromptEvent,
+    STREAMING: StreamingExecutePromptEvent_1.StreamingExecutePromptEvent,
+    FULFILLED: FulfilledExecutePromptEvent_1.FulfilledExecutePromptEvent,
+    REJECTED: RejectedExecutePromptEvent_1.RejectedExecutePromptEvent,
 })
     .transform({
     transform: (value) => value,

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

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

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

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

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

package/dist/serialization/types/ExecuteWorkflowResponse.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.ExecuteWorkflowResponse = void 0;
 const core = __importStar(require("../../core"));
+const ExecuteWorkflowWorkflowResultEvent_1 = require("./ExecuteWorkflowWorkflowResultEvent");
 exports.ExecuteWorkflowResponse = 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("..")))).ExecuteWorkflowWorkflowResultEvent; })),
+    data: ExecuteWorkflowWorkflowResultEvent_1.ExecuteWorkflowWorkflowResultEvent,
 });

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

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

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

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

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

package/dist/serialization/types/ExecutionChatHistoryVellumValue.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.ExecutionChatHistoryVellumValue = void 0;
 const core = __importStar(require("../../core"));
+const ChatMessage_1 = require("./ChatMessage");
 exports.ExecutionChatHistoryVellumValue = core.serialization.object({
     id: core.serialization.string(),
     name: core.serialization.string(),
-    value: core.serialization
-        .list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ChatMessage; })))
-        .optional(),
+    value: core.serialization.list(ChatMessage_1.ChatMessage).optional(),
 });

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

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

package/dist/serialization/types/ExecutionErrorVellumValue.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.ExecutionErrorVellumValue = void 0;
 const core = __importStar(require("../../core"));
+const VellumError_1 = require("./VellumError");
 exports.ExecutionErrorVellumValue = core.serialization.object({
     id: core.serialization.string(),
     name: core.serialization.string(),
-    value: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).VellumError; })).optional(),
+    value: VellumError_1.VellumError.optional(),
 });

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

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