vellum-ai 0.3.14 → 0.3.16

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

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

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

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

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

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

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

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

package/dist/serialization/types/NodeOutputCompiledSearchResultsValue.js

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

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

@@ -4,31 +4,39 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { NodeOutputCompiledStringValue } from "./NodeOutputCompiledStringValue";
+import { NodeOutputCompiledNumberValue } from "./NodeOutputCompiledNumberValue";
+import { NodeOutputCompiledJsonValue } from "./NodeOutputCompiledJsonValue";
+import { NodeOutputCompiledChatHistoryValue } from "./NodeOutputCompiledChatHistoryValue";
+import { NodeOutputCompiledSearchResultsValue } from "./NodeOutputCompiledSearchResultsValue";
+import { NodeOutputCompiledErrorValue } from "./NodeOutputCompiledErrorValue";
+import { NodeOutputCompiledArrayValue } from "./NodeOutputCompiledArrayValue";
+import { NodeOutputCompiledFunctionValue } from "./NodeOutputCompiledFunctionValue";
 export declare const NodeOutputCompiledValue: core.serialization.Schema<serializers.NodeOutputCompiledValue.Raw, Vellum.NodeOutputCompiledValue>;
 export declare namespace NodeOutputCompiledValue {
     type Raw = NodeOutputCompiledValue.String | NodeOutputCompiledValue.Number | NodeOutputCompiledValue.Json | NodeOutputCompiledValue.ChatHistory | NodeOutputCompiledValue.SearchResults | NodeOutputCompiledValue.Error | NodeOutputCompiledValue.Array | NodeOutputCompiledValue.FunctionCall;
-    interface String extends serializers.NodeOutputCompiledStringValue.Raw {
+    interface String extends NodeOutputCompiledStringValue.Raw {
         type: "STRING";
     }
-    interface Number extends serializers.NodeOutputCompiledNumberValue.Raw {
+    interface Number extends NodeOutputCompiledNumberValue.Raw {
         type: "NUMBER";
     }
-    interface Json extends serializers.NodeOutputCompiledJsonValue.Raw {
+    interface Json extends NodeOutputCompiledJsonValue.Raw {
         type: "JSON";
     }
-    interface ChatHistory extends serializers.NodeOutputCompiledChatHistoryValue.Raw {
+    interface ChatHistory extends NodeOutputCompiledChatHistoryValue.Raw {
         type: "CHAT_HISTORY";
     }
-    interface SearchResults extends serializers.NodeOutputCompiledSearchResultsValue.Raw {
+    interface SearchResults extends NodeOutputCompiledSearchResultsValue.Raw {
         type: "SEARCH_RESULTS";
     }
-    interface Error extends serializers.NodeOutputCompiledErrorValue.Raw {
+    interface Error extends NodeOutputCompiledErrorValue.Raw {
         type: "ERROR";
     }
-    interface Array extends serializers.NodeOutputCompiledArrayValue.Raw {
+    interface Array extends NodeOutputCompiledArrayValue.Raw {
         type: "ARRAY";
     }
-    interface FunctionCall extends serializers.NodeOutputCompiledFunctionValue.Raw {
+    interface FunctionCall extends NodeOutputCompiledFunctionValue.Raw {
         type: "FUNCTION_CALL";
     }
 }

package/dist/serialization/types/NodeOutputCompiledValue.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.NodeOutputCompiledValue = void 0;
 const core = __importStar(require("../../core"));
+const NodeOutputCompiledStringValue_1 = require("./NodeOutputCompiledStringValue");
+const NodeOutputCompiledNumberValue_1 = require("./NodeOutputCompiledNumberValue");
+const NodeOutputCompiledJsonValue_1 = require("./NodeOutputCompiledJsonValue");
+const NodeOutputCompiledChatHistoryValue_1 = require("./NodeOutputCompiledChatHistoryValue");
+const NodeOutputCompiledSearchResultsValue_1 = require("./NodeOutputCompiledSearchResultsValue");
+const NodeOutputCompiledErrorValue_1 = require("./NodeOutputCompiledErrorValue");
+const NodeOutputCompiledArrayValue_1 = require("./NodeOutputCompiledArrayValue");
+const NodeOutputCompiledFunctionValue_1 = require("./NodeOutputCompiledFunctionValue");
 exports.NodeOutputCompiledValue = core.serialization
     .union("type", {
-    STRING: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NodeOutputCompiledStringValue; })),
-    NUMBER: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NodeOutputCompiledNumberValue; })),
-    JSON: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NodeOutputCompiledJsonValue; })),
-    CHAT_HISTORY: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NodeOutputCompiledChatHistoryValue; })),
-    SEARCH_RESULTS: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NodeOutputCompiledSearchResultsValue; })),
-    ERROR: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NodeOutputCompiledErrorValue; })),
-    ARRAY: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NodeOutputCompiledArrayValue; })),
-    FUNCTION_CALL: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NodeOutputCompiledFunctionValue; })),
+    STRING: NodeOutputCompiledStringValue_1.NodeOutputCompiledStringValue,
+    NUMBER: NodeOutputCompiledNumberValue_1.NodeOutputCompiledNumberValue,
+    JSON: NodeOutputCompiledJsonValue_1.NodeOutputCompiledJsonValue,
+    CHAT_HISTORY: NodeOutputCompiledChatHistoryValue_1.NodeOutputCompiledChatHistoryValue,
+    SEARCH_RESULTS: NodeOutputCompiledSearchResultsValue_1.NodeOutputCompiledSearchResultsValue,
+    ERROR: NodeOutputCompiledErrorValue_1.NodeOutputCompiledErrorValue,
+    ARRAY: NodeOutputCompiledArrayValue_1.NodeOutputCompiledArrayValue,
+    FUNCTION_CALL: NodeOutputCompiledFunctionValue_1.NodeOutputCompiledFunctionValue,
 })
     .transform({
     transform: (value) => value,

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

@@ -4,10 +4,11 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { NormalizedTokenLogProbs } from "./NormalizedTokenLogProbs";
 export declare const NormalizedLogProbs: core.serialization.ObjectSchema<serializers.NormalizedLogProbs.Raw, Vellum.NormalizedLogProbs>;
 export declare namespace NormalizedLogProbs {
     interface Raw {
-        tokens: serializers.NormalizedTokenLogProbs.Raw[];
+        tokens: NormalizedTokenLogProbs.Raw[];
         likelihood?: number | null;
     }
 }

package/dist/serialization/types/NormalizedLogProbs.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.NormalizedLogProbs = void 0;
 const core = __importStar(require("../../core"));
+const NormalizedTokenLogProbs_1 = require("./NormalizedTokenLogProbs");
 exports.NormalizedLogProbs = core.serialization.object({
-    tokens: core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NormalizedTokenLogProbs; }))),
+    tokens: core.serialization.list(NormalizedTokenLogProbs_1.NormalizedTokenLogProbs),
     likelihood: core.serialization.number().optional(),
 });

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

@@ -4,12 +4,13 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { DocumentIndexRead } from "./DocumentIndexRead";
 export declare const PaginatedDocumentIndexReadList: core.serialization.ObjectSchema<serializers.PaginatedDocumentIndexReadList.Raw, Vellum.PaginatedDocumentIndexReadList>;
 export declare namespace PaginatedDocumentIndexReadList {
     interface Raw {
         count?: number | null;
         next?: string | null;
         previous?: string | null;
-        results?: serializers.DocumentIndexRead.Raw[] | null;
+        results?: DocumentIndexRead.Raw[] | null;
     }
 }

package/dist/serialization/types/PaginatedDocumentIndexReadList.js

@@ -25,23 +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.PaginatedDocumentIndexReadList = void 0;
 const core = __importStar(require("../../core"));
+const DocumentIndexRead_1 = require("./DocumentIndexRead");
 exports.PaginatedDocumentIndexReadList = core.serialization.object({
     count: core.serialization.number().optional(),
     next: core.serialization.string().optional(),
     previous: core.serialization.string().optional(),
-    results: core.serialization
-        .list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).DocumentIndexRead; })))
-        .optional(),
+    results: core.serialization.list(DocumentIndexRead_1.DocumentIndexRead).optional(),
 });

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

@@ -4,12 +4,13 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { SlimDeploymentRead } from "./SlimDeploymentRead";
 export declare const PaginatedSlimDeploymentReadList: core.serialization.ObjectSchema<serializers.PaginatedSlimDeploymentReadList.Raw, Vellum.PaginatedSlimDeploymentReadList>;
 export declare namespace PaginatedSlimDeploymentReadList {
     interface Raw {
         count?: number | null;
         next?: string | null;
         previous?: string | null;
-        results?: serializers.SlimDeploymentRead.Raw[] | null;
+        results?: SlimDeploymentRead.Raw[] | null;
     }
 }

package/dist/serialization/types/PaginatedSlimDeploymentReadList.js

@@ -25,23 +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.PaginatedSlimDeploymentReadList = void 0;
 const core = __importStar(require("../../core"));
+const SlimDeploymentRead_1 = require("./SlimDeploymentRead");
 exports.PaginatedSlimDeploymentReadList = core.serialization.object({
     count: core.serialization.number().optional(),
     next: core.serialization.string().optional(),
     previous: core.serialization.string().optional(),
-    results: core.serialization
-        .list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).SlimDeploymentRead; })))
-        .optional(),
+    results: core.serialization.list(SlimDeploymentRead_1.SlimDeploymentRead).optional(),
 });

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

@@ -4,12 +4,13 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { SlimDocument } from "./SlimDocument";
 export declare const PaginatedSlimDocumentList: core.serialization.ObjectSchema<serializers.PaginatedSlimDocumentList.Raw, Vellum.PaginatedSlimDocumentList>;
 export declare namespace PaginatedSlimDocumentList {
     interface Raw {
         count?: number | null;
         next?: string | null;
         previous?: string | null;
-        results?: serializers.SlimDocument.Raw[] | null;
+        results?: SlimDocument.Raw[] | null;
     }
 }

package/dist/serialization/types/PaginatedSlimDocumentList.js

@@ -25,23 +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.PaginatedSlimDocumentList = void 0;
 const core = __importStar(require("../../core"));
+const SlimDocument_1 = require("./SlimDocument");
 exports.PaginatedSlimDocumentList = core.serialization.object({
     count: core.serialization.number().optional(),
     next: core.serialization.string().optional(),
     previous: core.serialization.string().optional(),
-    results: core.serialization
-        .list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).SlimDocument; })))
-        .optional(),
+    results: core.serialization.list(SlimDocument_1.SlimDocument).optional(),
 });

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

@@ -4,12 +4,13 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { SlimWorkflowDeployment } from "./SlimWorkflowDeployment";
 export declare const PaginatedSlimWorkflowDeploymentList: core.serialization.ObjectSchema<serializers.PaginatedSlimWorkflowDeploymentList.Raw, Vellum.PaginatedSlimWorkflowDeploymentList>;
 export declare namespace PaginatedSlimWorkflowDeploymentList {
     interface Raw {
         count?: number | null;
         next?: string | null;
         previous?: string | null;
-        results?: serializers.SlimWorkflowDeployment.Raw[] | null;
+        results?: SlimWorkflowDeployment.Raw[] | null;
     }
 }

package/dist/serialization/types/PaginatedSlimWorkflowDeploymentList.js

@@ -25,23 +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.PaginatedSlimWorkflowDeploymentList = void 0;
 const core = __importStar(require("../../core"));
+const SlimWorkflowDeployment_1 = require("./SlimWorkflowDeployment");
 exports.PaginatedSlimWorkflowDeploymentList = core.serialization.object({
     count: core.serialization.number().optional(),
     next: core.serialization.string().optional(),
     previous: core.serialization.string().optional(),
-    results: core.serialization
-        .list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).SlimWorkflowDeployment; })))
-        .optional(),
+    results: core.serialization.list(SlimWorkflowDeployment_1.SlimWorkflowDeployment).optional(),
 });

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

@@ -4,12 +4,13 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { TestSuiteRunExecution } from "./TestSuiteRunExecution";
 export declare const PaginatedTestSuiteRunExecutionList: core.serialization.ObjectSchema<serializers.PaginatedTestSuiteRunExecutionList.Raw, Vellum.PaginatedTestSuiteRunExecutionList>;
 export declare namespace PaginatedTestSuiteRunExecutionList {
     interface Raw {
-        count?: number | null;
+        count: number;
         next?: string | null;
         previous?: string | null;
-        results?: serializers.TestSuiteRunExecution.Raw[] | null;
+        results: TestSuiteRunExecution.Raw[];
     }
 }

package/dist/serialization/types/PaginatedTestSuiteRunExecutionList.js

@@ -25,23 +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.PaginatedTestSuiteRunExecutionList = void 0;
 const core = __importStar(require("../../core"));
+const TestSuiteRunExecution_1 = require("./TestSuiteRunExecution");
 exports.PaginatedTestSuiteRunExecutionList = core.serialization.object({
-    count: core.serialization.number().optional(),
+    count: core.serialization.number(),
     next: core.serialization.string().optional(),
     previous: core.serialization.string().optional(),
-    results: core.serialization
-        .list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TestSuiteRunExecution; })))
-        .optional(),
+    results: core.serialization.list(TestSuiteRunExecution_1.TestSuiteRunExecution),
 });

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

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

package/dist/serialization/types/PromptDeploymentInputRequest.js

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

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

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

package/dist/serialization/types/PromptExecutionMeta.js

@@ -25,22 +25,14 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PromptExecutionMeta = void 0;
 const core = __importStar(require("../../core"));
+const FinishReasonEnum_1 = require("./FinishReasonEnum");
 exports.PromptExecutionMeta = core.serialization.object({
     modelName: core.serialization.property("model_name", core.serialization.string().optional()),
     latency: core.serialization.number().optional(),
     deploymentReleaseTag: core.serialization.property("deployment_release_tag", core.serialization.string().optional()),
     promptVersionId: core.serialization.property("prompt_version_id", core.serialization.string().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/dist/serialization/types/PromptNodeResult.d.ts

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

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

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

@@ -4,19 +4,23 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { StringVariableValue } from "./StringVariableValue";
+import { JsonVariableValue } from "./JsonVariableValue";
+import { ErrorVariableValue } from "./ErrorVariableValue";
+import { FunctionCallVariableValue } from "./FunctionCallVariableValue";
 export declare const PromptOutput: core.serialization.Schema<serializers.PromptOutput.Raw, Vellum.PromptOutput>;
 export declare namespace PromptOutput {
     type Raw = PromptOutput.String | PromptOutput.Json | PromptOutput.Error | PromptOutput.FunctionCall;
-    interface String extends serializers.StringVariableValue.Raw {
+    interface String extends StringVariableValue.Raw {
         type: "STRING";
     }
-    interface Json extends serializers.JsonVariableValue.Raw {
+    interface Json extends JsonVariableValue.Raw {
         type: "JSON";
     }
-    interface Error extends serializers.ErrorVariableValue.Raw {
+    interface Error extends ErrorVariableValue.Raw {
         type: "ERROR";
     }
-    interface FunctionCall extends serializers.FunctionCallVariableValue.Raw {
+    interface FunctionCall extends FunctionCallVariableValue.Raw {
         type: "FUNCTION_CALL";
     }
 }