vellum-ai 0.3.13 → 0.3.15

package/serialization/types/TestSuiteRunExecutionSearchResultsOutput.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.TestSuiteRunExecutionSearchResultsOutput = void 0;
 const core = __importStar(require("../../core"));
+const SearchResult_1 = require("./SearchResult");
 exports.TestSuiteRunExecutionSearchResultsOutput = core.serialization.object({
     outputVariableId: core.serialization.property("output_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/serialization/types/TestSuiteRunMetricErrorOutput.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 TestSuiteRunMetricErrorOutput: core.serialization.ObjectSchema<serializers.TestSuiteRunMetricErrorOutput.Raw, Vellum.TestSuiteRunMetricErrorOutput>;
 export declare namespace TestSuiteRunMetricErrorOutput {
     interface Raw {
-        value: serializers.VellumError.Raw;
+        value: VellumError.Raw;
         name: string;
     }
 }

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

package/serialization/types/TestSuiteRunMetricOutput.d.ts

@@ -4,13 +4,15 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { TestSuiteRunMetricNumberOutput } from "./TestSuiteRunMetricNumberOutput";
+import { TestSuiteRunMetricErrorOutput } from "./TestSuiteRunMetricErrorOutput";
 export declare const TestSuiteRunMetricOutput: core.serialization.Schema<serializers.TestSuiteRunMetricOutput.Raw, Vellum.TestSuiteRunMetricOutput>;
 export declare namespace TestSuiteRunMetricOutput {
     type Raw = TestSuiteRunMetricOutput.Number | TestSuiteRunMetricOutput.Error;
-    interface Number extends serializers.TestSuiteRunMetricNumberOutput.Raw {
+    interface Number extends TestSuiteRunMetricNumberOutput.Raw {
         type: "NUMBER";
     }
-    interface Error extends serializers.TestSuiteRunMetricErrorOutput.Raw {
+    interface Error extends TestSuiteRunMetricErrorOutput.Raw {
         type: "ERROR";
     }
 }

package/serialization/types/TestSuiteRunMetricOutput.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.TestSuiteRunMetricOutput = void 0;
 const core = __importStar(require("../../core"));
+const TestSuiteRunMetricNumberOutput_1 = require("./TestSuiteRunMetricNumberOutput");
+const TestSuiteRunMetricErrorOutput_1 = require("./TestSuiteRunMetricErrorOutput");
 exports.TestSuiteRunMetricOutput = core.serialization
     .union("type", {
-    NUMBER: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TestSuiteRunMetricNumberOutput; })),
-    ERROR: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TestSuiteRunMetricErrorOutput; })),
+    NUMBER: TestSuiteRunMetricNumberOutput_1.TestSuiteRunMetricNumberOutput,
+    ERROR: TestSuiteRunMetricErrorOutput_1.TestSuiteRunMetricErrorOutput,
 })
     .transform({
     transform: (value) => value,

package/serialization/types/TestSuiteRunRead.d.ts

@@ -4,13 +4,16 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { TestSuiteRunTestSuite } from "./TestSuiteRunTestSuite";
+import { TestSuiteRunState } from "./TestSuiteRunState";
+import { TestSuiteRunExecConfig } from "./TestSuiteRunExecConfig";
 export declare const TestSuiteRunRead: core.serialization.ObjectSchema<serializers.TestSuiteRunRead.Raw, Vellum.TestSuiteRunRead>;
 export declare namespace TestSuiteRunRead {
     interface Raw {
         id: string;
         created: string;
-        test_suite: serializers.TestSuiteRunTestSuite.Raw;
-        state?: serializers.TestSuiteRunState.Raw | null;
-        exec_config?: serializers.TestSuiteRunExecConfig.Raw | null;
+        test_suite: TestSuiteRunTestSuite.Raw;
+        state: TestSuiteRunState.Raw;
+        exec_config?: TestSuiteRunExecConfig.Raw | null;
     }
 }

package/serialization/types/TestSuiteRunRead.js

@@ -25,22 +25,16 @@ 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.TestSuiteRunRead = void 0;
 const core = __importStar(require("../../core"));
+const TestSuiteRunTestSuite_1 = require("./TestSuiteRunTestSuite");
+const TestSuiteRunState_1 = require("./TestSuiteRunState");
+const TestSuiteRunExecConfig_1 = require("./TestSuiteRunExecConfig");
 exports.TestSuiteRunRead = core.serialization.object({
     id: core.serialization.string(),
     created: core.serialization.date(),
-    testSuite: core.serialization.property("test_suite", core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TestSuiteRunTestSuite; }))),
-    state: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TestSuiteRunState; })).optional(),
-    execConfig: core.serialization.property("exec_config", core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TestSuiteRunExecConfig; })).optional()),
+    testSuite: core.serialization.property("test_suite", TestSuiteRunTestSuite_1.TestSuiteRunTestSuite),
+    state: TestSuiteRunState_1.TestSuiteRunState,
+    execConfig: core.serialization.property("exec_config", TestSuiteRunExecConfig_1.TestSuiteRunExecConfig.optional()),
 });

package/serialization/types/TestSuiteRunWorkflowReleaseTagExecConfig.d.ts

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

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

package/serialization/types/TestSuiteRunWorkflowReleaseTagExecConfigRequest.d.ts

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

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

package/serialization/types/TestSuiteTestCase.d.ts

@@ -4,12 +4,13 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { TestCaseVariableValue } from "./TestCaseVariableValue";
 export declare const TestSuiteTestCase: core.serialization.ObjectSchema<serializers.TestSuiteTestCase.Raw, Vellum.TestSuiteTestCase>;
 export declare namespace TestSuiteTestCase {
     interface Raw {
         id?: string | null;
         label?: string | null;
-        input_values: serializers.TestCaseVariableValue.Raw[];
-        evaluation_values: serializers.TestCaseVariableValue.Raw[];
+        input_values: TestCaseVariableValue.Raw[];
+        evaluation_values: TestCaseVariableValue.Raw[];
     }
 }

package/serialization/types/TestSuiteTestCase.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.TestSuiteTestCase = void 0;
 const core = __importStar(require("../../core"));
+const TestCaseVariableValue_1 = require("./TestCaseVariableValue");
 exports.TestSuiteTestCase = core.serialization.object({
     id: core.serialization.string().optional(),
     label: core.serialization.string().optional(),
-    inputValues: core.serialization.property("input_values", core.serialization.list(core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TestCaseVariableValue; })))),
-    evaluationValues: core.serialization.property("evaluation_values", core.serialization.list(core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TestCaseVariableValue; })))),
+    inputValues: core.serialization.property("input_values", core.serialization.list(TestCaseVariableValue_1.TestCaseVariableValue)),
+    evaluationValues: core.serialization.property("evaluation_values", core.serialization.list(TestCaseVariableValue_1.TestCaseVariableValue)),
 });

package/serialization/types/VellumError.d.ts

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

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

package/serialization/types/VellumErrorRequest.d.ts

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

package/serialization/types/VellumErrorRequest.js

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

package/serialization/types/VellumVariable.d.ts

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

package/serialization/types/VellumVariable.js

@@ -25,20 +25,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VellumVariable = void 0;
 const core = __importStar(require("../../core"));
+const VellumVariableType_1 = require("./VellumVariableType");
 exports.VellumVariable = core.serialization.object({
     id: core.serialization.string(),
     key: core.serialization.string(),
-    type: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).VellumVariableType; })),
+    type: VellumVariableType_1.VellumVariableType,
 });

package/serialization/types/WorkflowDeploymentRead.d.ts

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

package/serialization/types/WorkflowDeploymentRead.js

@@ -25,26 +25,20 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkflowDeploymentRead = void 0;
 const core = __importStar(require("../../core"));
+const EntityStatus_1 = require("./EntityStatus");
+const EnvironmentEnum_1 = require("./EnvironmentEnum");
+const VellumVariable_1 = require("./VellumVariable");
 exports.WorkflowDeploymentRead = core.serialization.object({
     id: core.serialization.string(),
     name: core.serialization.string(),
     label: core.serialization.string(),
-    status: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).EntityStatus; })).optional(),
-    environment: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).EnvironmentEnum; })).optional(),
+    status: EntityStatus_1.EntityStatus.optional(),
+    environment: EnvironmentEnum_1.EnvironmentEnum.optional(),
     created: core.serialization.date(),
     lastDeployedOn: core.serialization.property("last_deployed_on", core.serialization.date()),
-    inputVariables: core.serialization.property("input_variables", core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).VellumVariable; })))),
-    outputVariables: core.serialization.property("output_variables", core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).VellumVariable; })))),
+    inputVariables: core.serialization.property("input_variables", core.serialization.list(VellumVariable_1.VellumVariable)),
+    outputVariables: core.serialization.property("output_variables", core.serialization.list(VellumVariable_1.VellumVariable)),
 });

package/serialization/types/WorkflowEventError.d.ts

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

package/serialization/types/WorkflowEventError.js

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

package/serialization/types/WorkflowExecutionActualChatHistoryRequest.d.ts

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

package/serialization/types/WorkflowExecutionActualChatHistoryRequest.js

@@ -25,24 +25,14 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkflowExecutionActualChatHistoryRequest = void 0;
 const core = __importStar(require("../../core"));
+const ChatMessageRequest_1 = require("./ChatMessageRequest");
 exports.WorkflowExecutionActualChatHistoryRequest = core.serialization.object({
     outputId: core.serialization.property("output_id", core.serialization.string().optional()),
     outputKey: core.serialization.property("output_key", core.serialization.string().optional()),
     quality: core.serialization.number().optional(),
     timestamp: core.serialization.number().optional(),
-    desiredOutputValue: core.serialization.property("desired_output_value", core.serialization
-        .list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ChatMessageRequest; })))
-        .optional()),
+    desiredOutputValue: core.serialization.property("desired_output_value", core.serialization.list(ChatMessageRequest_1.ChatMessageRequest).optional()),
 });

package/serialization/types/WorkflowExecutionNodeResultEvent.d.ts

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

package/serialization/types/WorkflowExecutionNodeResultEvent.js

@@ -25,21 +25,13 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkflowExecutionNodeResultEvent = void 0;
 const core = __importStar(require("../../core"));
+const WorkflowNodeResultEvent_1 = require("./WorkflowNodeResultEvent");
 exports.WorkflowExecutionNodeResultEvent = core.serialization.object({
     executionId: core.serialization.property("execution_id", core.serialization.string()),
     runId: core.serialization.property("run_id", core.serialization.string().optional()),
     externalId: core.serialization.property("external_id", core.serialization.string().optional()),
-    data: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowNodeResultEvent; })),
+    data: WorkflowNodeResultEvent_1.WorkflowNodeResultEvent,
 });

package/serialization/types/WorkflowExecutionWorkflowResultEvent.d.ts

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

package/serialization/types/WorkflowExecutionWorkflowResultEvent.js

@@ -25,21 +25,13 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkflowExecutionWorkflowResultEvent = void 0;
 const core = __importStar(require("../../core"));
+const WorkflowResultEvent_1 = require("./WorkflowResultEvent");
 exports.WorkflowExecutionWorkflowResultEvent = core.serialization.object({
     executionId: core.serialization.property("execution_id", core.serialization.string()),
     runId: core.serialization.property("run_id", core.serialization.string().optional()),
     externalId: core.serialization.property("external_id", core.serialization.string().optional()),
-    data: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowResultEvent; })),
+    data: WorkflowResultEvent_1.WorkflowResultEvent,
 });