vellum-ai 0.3.14 → 0.3.15

package/dist/serialization/types/TerminalNodeErrorResult.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.TerminalNodeErrorResult = void 0;
 const core = __importStar(require("../../core"));
+const VellumError_1 = require("./VellumError");
 exports.TerminalNodeErrorResult = core.serialization.object({
     id: core.serialization.string().optional(),
     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/TerminalNodeFunctionCallResult.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 TerminalNodeFunctionCallResult: core.serialization.ObjectSchema<serializers.TerminalNodeFunctionCallResult.Raw, Vellum.TerminalNodeFunctionCallResult>;
 export declare namespace TerminalNodeFunctionCallResult {
     interface Raw {
         id?: string | null;
         name: string;
-        value?: serializers.FunctionCall.Raw | null;
+        value?: FunctionCall.Raw | null;
     }
 }

package/dist/serialization/types/TerminalNodeFunctionCallResult.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.TerminalNodeFunctionCallResult = void 0;
 const core = __importStar(require("../../core"));
+const FunctionCall_1 = require("./FunctionCall");
 exports.TerminalNodeFunctionCallResult = core.serialization.object({
     id: core.serialization.string().optional(),
     name: 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/TerminalNodeResult.d.ts

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

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

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

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

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

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

@@ -4,31 +4,39 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { TerminalNodeStringResult } from "./TerminalNodeStringResult";
+import { TerminalNodeNumberResult } from "./TerminalNodeNumberResult";
+import { TerminalNodeJsonResult } from "./TerminalNodeJsonResult";
+import { TerminalNodeChatHistoryResult } from "./TerminalNodeChatHistoryResult";
+import { TerminalNodeSearchResultsResult } from "./TerminalNodeSearchResultsResult";
+import { TerminalNodeArrayResult } from "./TerminalNodeArrayResult";
+import { TerminalNodeFunctionCallResult } from "./TerminalNodeFunctionCallResult";
+import { TerminalNodeErrorResult } from "./TerminalNodeErrorResult";
 export declare const TerminalNodeResultOutput: core.serialization.Schema<serializers.TerminalNodeResultOutput.Raw, Vellum.TerminalNodeResultOutput>;
 export declare namespace TerminalNodeResultOutput {
     type Raw = TerminalNodeResultOutput.String | TerminalNodeResultOutput.Number | TerminalNodeResultOutput.Json | TerminalNodeResultOutput.ChatHistory | TerminalNodeResultOutput.SearchResults | TerminalNodeResultOutput.Array | TerminalNodeResultOutput.FunctionCall | TerminalNodeResultOutput.Error;
-    interface String extends serializers.TerminalNodeStringResult.Raw {
+    interface String extends TerminalNodeStringResult.Raw {
         type: "STRING";
     }
-    interface Number extends serializers.TerminalNodeNumberResult.Raw {
+    interface Number extends TerminalNodeNumberResult.Raw {
         type: "NUMBER";
     }
-    interface Json extends serializers.TerminalNodeJsonResult.Raw {
+    interface Json extends TerminalNodeJsonResult.Raw {
         type: "JSON";
     }
-    interface ChatHistory extends serializers.TerminalNodeChatHistoryResult.Raw {
+    interface ChatHistory extends TerminalNodeChatHistoryResult.Raw {
         type: "CHAT_HISTORY";
     }
-    interface SearchResults extends serializers.TerminalNodeSearchResultsResult.Raw {
+    interface SearchResults extends TerminalNodeSearchResultsResult.Raw {
         type: "SEARCH_RESULTS";
     }
-    interface Array extends serializers.TerminalNodeArrayResult.Raw {
+    interface Array extends TerminalNodeArrayResult.Raw {
         type: "ARRAY";
     }
-    interface FunctionCall extends serializers.TerminalNodeFunctionCallResult.Raw {
+    interface FunctionCall extends TerminalNodeFunctionCallResult.Raw {
         type: "FUNCTION_CALL";
     }
-    interface Error extends serializers.TerminalNodeErrorResult.Raw {
+    interface Error extends TerminalNodeErrorResult.Raw {
         type: "ERROR";
     }
 }

package/dist/serialization/types/TerminalNodeResultOutput.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.TerminalNodeResultOutput = void 0;
 const core = __importStar(require("../../core"));
+const TerminalNodeStringResult_1 = require("./TerminalNodeStringResult");
+const TerminalNodeNumberResult_1 = require("./TerminalNodeNumberResult");
+const TerminalNodeJsonResult_1 = require("./TerminalNodeJsonResult");
+const TerminalNodeChatHistoryResult_1 = require("./TerminalNodeChatHistoryResult");
+const TerminalNodeSearchResultsResult_1 = require("./TerminalNodeSearchResultsResult");
+const TerminalNodeArrayResult_1 = require("./TerminalNodeArrayResult");
+const TerminalNodeFunctionCallResult_1 = require("./TerminalNodeFunctionCallResult");
+const TerminalNodeErrorResult_1 = require("./TerminalNodeErrorResult");
 exports.TerminalNodeResultOutput = core.serialization
     .union("type", {
-    STRING: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TerminalNodeStringResult; })),
-    NUMBER: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TerminalNodeNumberResult; })),
-    JSON: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TerminalNodeJsonResult; })),
-    CHAT_HISTORY: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TerminalNodeChatHistoryResult; })),
-    SEARCH_RESULTS: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TerminalNodeSearchResultsResult; })),
-    ARRAY: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TerminalNodeArrayResult; })),
-    FUNCTION_CALL: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TerminalNodeFunctionCallResult; })),
-    ERROR: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TerminalNodeErrorResult; })),
+    STRING: TerminalNodeStringResult_1.TerminalNodeStringResult,
+    NUMBER: TerminalNodeNumberResult_1.TerminalNodeNumberResult,
+    JSON: TerminalNodeJsonResult_1.TerminalNodeJsonResult,
+    CHAT_HISTORY: TerminalNodeChatHistoryResult_1.TerminalNodeChatHistoryResult,
+    SEARCH_RESULTS: TerminalNodeSearchResultsResult_1.TerminalNodeSearchResultsResult,
+    ARRAY: TerminalNodeArrayResult_1.TerminalNodeArrayResult,
+    FUNCTION_CALL: TerminalNodeFunctionCallResult_1.TerminalNodeFunctionCallResult,
+    ERROR: TerminalNodeErrorResult_1.TerminalNodeErrorResult,
 })
     .transform({
     transform: (value) => value,

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

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

package/dist/serialization/types/TerminalNodeSearchResultsResult.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.TerminalNodeSearchResultsResult = void 0;
 const core = __importStar(require("../../core"));
+const SearchResult_1 = require("./SearchResult");
 exports.TerminalNodeSearchResultsResult = core.serialization.object({
     id: core.serialization.string().optional(),
     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("..")))).SearchResult; })))
-        .optional(),
+    value: core.serialization.list(SearchResult_1.SearchResult).optional(),
 });

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

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

package/dist/serialization/types/TestCaseChatHistoryVariableValue.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.TestCaseChatHistoryVariableValue = void 0;
 const core = __importStar(require("../../core"));
+const ChatMessage_1 = require("./ChatMessage");
 exports.TestCaseChatHistoryVariableValue = core.serialization.object({
     variableId: core.serialization.property("variable_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("..")))).ChatMessage; })))
-        .optional(),
+    value: core.serialization.list(ChatMessage_1.ChatMessage).optional(),
 });

package/dist/serialization/types/TestCaseErrorVariableValue.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 TestCaseErrorVariableValue: core.serialization.ObjectSchema<serializers.TestCaseErrorVariableValue.Raw, Vellum.TestCaseErrorVariableValue>;
 export declare namespace TestCaseErrorVariableValue {
     interface Raw {
         variable_id: string;
-        value?: serializers.VellumError.Raw | null;
+        value?: VellumError.Raw | null;
     }
 }

package/dist/serialization/types/TestCaseErrorVariableValue.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.TestCaseErrorVariableValue = void 0;
 const core = __importStar(require("../../core"));
+const VellumError_1 = require("./VellumError");
 exports.TestCaseErrorVariableValue = core.serialization.object({
     variableId: core.serialization.property("variable_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/TestCaseSearchResultsVariableValue.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 TestCaseSearchResultsVariableValue: core.serialization.ObjectSchema<serializers.TestCaseSearchResultsVariableValue.Raw, Vellum.TestCaseSearchResultsVariableValue>;
 export declare namespace TestCaseSearchResultsVariableValue {
     interface Raw {
         variable_id: string;
-        value?: serializers.SearchResult.Raw[] | null;
+        value?: SearchResult.Raw[] | null;
     }
 }

package/dist/serialization/types/TestCaseSearchResultsVariableValue.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.TestCaseSearchResultsVariableValue = void 0;
 const core = __importStar(require("../../core"));
+const SearchResult_1 = require("./SearchResult");
 exports.TestCaseSearchResultsVariableValue = core.serialization.object({
     variableId: core.serialization.property("variable_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/TestCaseVariableValue.d.ts

@@ -4,25 +4,31 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { TestCaseStringVariableValue } from "./TestCaseStringVariableValue";
+import { TestCaseNumberVariableValue } from "./TestCaseNumberVariableValue";
+import { TestCaseJsonVariableValue } from "./TestCaseJsonVariableValue";
+import { TestCaseChatHistoryVariableValue } from "./TestCaseChatHistoryVariableValue";
+import { TestCaseSearchResultsVariableValue } from "./TestCaseSearchResultsVariableValue";
+import { TestCaseErrorVariableValue } from "./TestCaseErrorVariableValue";
 export declare const TestCaseVariableValue: core.serialization.Schema<serializers.TestCaseVariableValue.Raw, Vellum.TestCaseVariableValue>;
 export declare namespace TestCaseVariableValue {
     type Raw = TestCaseVariableValue.String | TestCaseVariableValue.Number | TestCaseVariableValue.Json | TestCaseVariableValue.ChatHistory | TestCaseVariableValue.SearchResults | TestCaseVariableValue.Error;
-    interface String extends serializers.TestCaseStringVariableValue.Raw {
+    interface String extends TestCaseStringVariableValue.Raw {
         type: "STRING";
     }
-    interface Number extends serializers.TestCaseNumberVariableValue.Raw {
+    interface Number extends TestCaseNumberVariableValue.Raw {
         type: "NUMBER";
     }
-    interface Json extends serializers.TestCaseJsonVariableValue.Raw {
+    interface Json extends TestCaseJsonVariableValue.Raw {
         type: "JSON";
     }
-    interface ChatHistory extends serializers.TestCaseChatHistoryVariableValue.Raw {
+    interface ChatHistory extends TestCaseChatHistoryVariableValue.Raw {
         type: "CHAT_HISTORY";
     }
-    interface SearchResults extends serializers.TestCaseSearchResultsVariableValue.Raw {
+    interface SearchResults extends TestCaseSearchResultsVariableValue.Raw {
         type: "SEARCH_RESULTS";
     }
-    interface Error extends serializers.TestCaseErrorVariableValue.Raw {
+    interface Error extends TestCaseErrorVariableValue.Raw {
         type: "ERROR";
     }
 }

package/dist/serialization/types/TestCaseVariableValue.js

@@ -25,26 +25,23 @@ 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.TestCaseVariableValue = void 0;
 const core = __importStar(require("../../core"));
+const TestCaseStringVariableValue_1 = require("./TestCaseStringVariableValue");
+const TestCaseNumberVariableValue_1 = require("./TestCaseNumberVariableValue");
+const TestCaseJsonVariableValue_1 = require("./TestCaseJsonVariableValue");
+const TestCaseChatHistoryVariableValue_1 = require("./TestCaseChatHistoryVariableValue");
+const TestCaseSearchResultsVariableValue_1 = require("./TestCaseSearchResultsVariableValue");
+const TestCaseErrorVariableValue_1 = require("./TestCaseErrorVariableValue");
 exports.TestCaseVariableValue = core.serialization
     .union("type", {
-    STRING: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TestCaseStringVariableValue; })),
-    NUMBER: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TestCaseNumberVariableValue; })),
-    JSON: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TestCaseJsonVariableValue; })),
-    CHAT_HISTORY: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TestCaseChatHistoryVariableValue; })),
-    SEARCH_RESULTS: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TestCaseSearchResultsVariableValue; })),
-    ERROR: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TestCaseErrorVariableValue; })),
+    STRING: TestCaseStringVariableValue_1.TestCaseStringVariableValue,
+    NUMBER: TestCaseNumberVariableValue_1.TestCaseNumberVariableValue,
+    JSON: TestCaseJsonVariableValue_1.TestCaseJsonVariableValue,
+    CHAT_HISTORY: TestCaseChatHistoryVariableValue_1.TestCaseChatHistoryVariableValue,
+    SEARCH_RESULTS: TestCaseSearchResultsVariableValue_1.TestCaseSearchResultsVariableValue,
+    ERROR: TestCaseErrorVariableValue_1.TestCaseErrorVariableValue,
 })
     .transform({
     transform: (value) => value,

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

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

package/dist/serialization/types/TestSuiteRunDeploymentReleaseTagExecConfig.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.TestSuiteRunDeploymentReleaseTagExecConfig = void 0;
 const core = __importStar(require("../../core"));
+const TestSuiteRunDeploymentReleaseTagExecConfigData_1 = require("./TestSuiteRunDeploymentReleaseTagExecConfigData");
 exports.TestSuiteRunDeploymentReleaseTagExecConfig = core.serialization.object({
-    data: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TestSuiteRunDeploymentReleaseTagExecConfigData; })),
+    data: TestSuiteRunDeploymentReleaseTagExecConfigData_1.TestSuiteRunDeploymentReleaseTagExecConfigData,
     testCaseIds: core.serialization.property("test_case_ids", core.serialization.list(core.serialization.string()).optional()),
 });

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

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

package/dist/serialization/types/TestSuiteRunDeploymentReleaseTagExecConfigRequest.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.TestSuiteRunDeploymentReleaseTagExecConfigRequest = void 0;
 const core = __importStar(require("../../core"));
+const TestSuiteRunDeploymentReleaseTagExecConfigDataRequest_1 = require("./TestSuiteRunDeploymentReleaseTagExecConfigDataRequest");
 exports.TestSuiteRunDeploymentReleaseTagExecConfigRequest = core.serialization.object({
-    data: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TestSuiteRunDeploymentReleaseTagExecConfigDataRequest; })),
+    data: TestSuiteRunDeploymentReleaseTagExecConfigDataRequest_1.TestSuiteRunDeploymentReleaseTagExecConfigDataRequest,
     testCaseIds: core.serialization.property("test_case_ids", core.serialization.list(core.serialization.string()).optional()),
 });

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

@@ -4,13 +4,15 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { TestSuiteRunDeploymentReleaseTagExecConfig } from "./TestSuiteRunDeploymentReleaseTagExecConfig";
+import { TestSuiteRunWorkflowReleaseTagExecConfig } from "./TestSuiteRunWorkflowReleaseTagExecConfig";
 export declare const TestSuiteRunExecConfig: core.serialization.Schema<serializers.TestSuiteRunExecConfig.Raw, Vellum.TestSuiteRunExecConfig>;
 export declare namespace TestSuiteRunExecConfig {
     type Raw = TestSuiteRunExecConfig.DeploymentReleaseTag | TestSuiteRunExecConfig.WorkflowReleaseTag;
-    interface DeploymentReleaseTag extends serializers.TestSuiteRunDeploymentReleaseTagExecConfig.Raw {
+    interface DeploymentReleaseTag extends TestSuiteRunDeploymentReleaseTagExecConfig.Raw {
         type: "DEPLOYMENT_RELEASE_TAG";
     }
-    interface WorkflowReleaseTag extends serializers.TestSuiteRunWorkflowReleaseTagExecConfig.Raw {
+    interface WorkflowReleaseTag extends TestSuiteRunWorkflowReleaseTagExecConfig.Raw {
         type: "WORKFLOW_RELEASE_TAG";
     }
 }

package/dist/serialization/types/TestSuiteRunExecConfig.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.TestSuiteRunExecConfig = void 0;
 const core = __importStar(require("../../core"));
+const TestSuiteRunDeploymentReleaseTagExecConfig_1 = require("./TestSuiteRunDeploymentReleaseTagExecConfig");
+const TestSuiteRunWorkflowReleaseTagExecConfig_1 = require("./TestSuiteRunWorkflowReleaseTagExecConfig");
 exports.TestSuiteRunExecConfig = core.serialization
     .union("type", {
-    DEPLOYMENT_RELEASE_TAG: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TestSuiteRunDeploymentReleaseTagExecConfig; })),
-    WORKFLOW_RELEASE_TAG: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TestSuiteRunWorkflowReleaseTagExecConfig; })),
+    DEPLOYMENT_RELEASE_TAG: TestSuiteRunDeploymentReleaseTagExecConfig_1.TestSuiteRunDeploymentReleaseTagExecConfig,
+    WORKFLOW_RELEASE_TAG: TestSuiteRunWorkflowReleaseTagExecConfig_1.TestSuiteRunWorkflowReleaseTagExecConfig,
 })
     .transform({
     transform: (value) => value,

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

@@ -4,13 +4,15 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { TestSuiteRunDeploymentReleaseTagExecConfigRequest } from "./TestSuiteRunDeploymentReleaseTagExecConfigRequest";
+import { TestSuiteRunWorkflowReleaseTagExecConfigRequest } from "./TestSuiteRunWorkflowReleaseTagExecConfigRequest";
 export declare const TestSuiteRunExecConfigRequest: core.serialization.Schema<serializers.TestSuiteRunExecConfigRequest.Raw, Vellum.TestSuiteRunExecConfigRequest>;
 export declare namespace TestSuiteRunExecConfigRequest {
     type Raw = TestSuiteRunExecConfigRequest.DeploymentReleaseTag | TestSuiteRunExecConfigRequest.WorkflowReleaseTag;
-    interface DeploymentReleaseTag extends serializers.TestSuiteRunDeploymentReleaseTagExecConfigRequest.Raw {
+    interface DeploymentReleaseTag extends TestSuiteRunDeploymentReleaseTagExecConfigRequest.Raw {
         type: "DEPLOYMENT_RELEASE_TAG";
     }
-    interface WorkflowReleaseTag extends serializers.TestSuiteRunWorkflowReleaseTagExecConfigRequest.Raw {
+    interface WorkflowReleaseTag extends TestSuiteRunWorkflowReleaseTagExecConfigRequest.Raw {
         type: "WORKFLOW_RELEASE_TAG";
     }
 }