vellum-ai 0.3.14 → 0.3.16

package/dist/serialization/resources/registeredPrompts/client/requests/RegisterPromptRequestRequest.d.ts

@@ -4,15 +4,18 @@
 import * as serializers from "../../../..";
 import * as Vellum from "../../../../../api";
 import * as core from "../../../../../core";
+import { RegisterPromptPromptInfoRequest } from "../../../../types/RegisterPromptPromptInfoRequest";
+import { ProviderEnum } from "../../../../types/ProviderEnum";
+import { RegisterPromptModelParametersRequest } from "../../../../types/RegisterPromptModelParametersRequest";
 export declare const RegisterPromptRequestRequest: core.serialization.Schema<serializers.RegisterPromptRequestRequest.Raw, Vellum.RegisterPromptRequestRequest>;
 export declare namespace RegisterPromptRequestRequest {
     interface Raw {
         label: string;
         name: string;
-        prompt: serializers.RegisterPromptPromptInfoRequest.Raw;
-        provider?: serializers.ProviderEnum.Raw | null;
+        prompt: RegisterPromptPromptInfoRequest.Raw;
+        provider?: ProviderEnum.Raw | null;
         model: string;
-        parameters: serializers.RegisterPromptModelParametersRequest.Raw;
+        parameters: RegisterPromptModelParametersRequest.Raw;
         meta?: Record<string, unknown> | null;
     }
 }

package/dist/serialization/resources/registeredPrompts/client/requests/RegisterPromptRequestRequest.js

@@ -25,24 +25,18 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RegisterPromptRequestRequest = void 0;
 const core = __importStar(require("../../../../../core"));
+const RegisterPromptPromptInfoRequest_1 = require("../../../../types/RegisterPromptPromptInfoRequest");
+const ProviderEnum_1 = require("../../../../types/ProviderEnum");
+const RegisterPromptModelParametersRequest_1 = require("../../../../types/RegisterPromptModelParametersRequest");
 exports.RegisterPromptRequestRequest = core.serialization.object({
     label: core.serialization.string(),
     name: core.serialization.string(),
-    prompt: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("../../../..")))).RegisterPromptPromptInfoRequest; })),
-    provider: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("../../../..")))).ProviderEnum; })).optional(),
+    prompt: RegisterPromptPromptInfoRequest_1.RegisterPromptPromptInfoRequest,
+    provider: ProviderEnum_1.ProviderEnum.optional(),
     model: core.serialization.string(),
-    parameters: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("../../../..")))).RegisterPromptModelParametersRequest; })),
+    parameters: RegisterPromptModelParametersRequest_1.RegisterPromptModelParametersRequest,
     meta: core.serialization.record(core.serialization.string(), core.serialization.unknown()).optional(),
 });

package/dist/serialization/resources/sandboxes/client/requests/UpsertSandboxScenarioRequestRequest.d.ts

@@ -4,11 +4,12 @@
 import * as serializers from "../../../..";
 import * as Vellum from "../../../../../api";
 import * as core from "../../../../../core";
+import { ScenarioInputRequest } from "../../../../types/ScenarioInputRequest";
 export declare const UpsertSandboxScenarioRequestRequest: core.serialization.Schema<serializers.UpsertSandboxScenarioRequestRequest.Raw, Vellum.UpsertSandboxScenarioRequestRequest>;
 export declare namespace UpsertSandboxScenarioRequestRequest {
     interface Raw {
         label?: string | null;
-        inputs: serializers.ScenarioInputRequest.Raw[];
+        inputs: ScenarioInputRequest.Raw[];
         scenario_id?: string | null;
     }
 }

package/dist/serialization/resources/sandboxes/client/requests/UpsertSandboxScenarioRequestRequest.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.UpsertSandboxScenarioRequestRequest = void 0;
 const core = __importStar(require("../../../../../core"));
+const ScenarioInputRequest_1 = require("../../../../types/ScenarioInputRequest");
 exports.UpsertSandboxScenarioRequestRequest = core.serialization.object({
     label: core.serialization.string().optional(),
-    inputs: core.serialization.list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("../../../..")))).ScenarioInputRequest; }))),
+    inputs: core.serialization.list(ScenarioInputRequest_1.ScenarioInputRequest),
     scenarioId: core.serialization.property("scenario_id", core.serialization.string().optional()),
 });

package/dist/serialization/resources/testSuiteRuns/client/requests/TestSuiteRunCreateRequest.d.ts

@@ -4,10 +4,11 @@
 import * as serializers from "../../../..";
 import * as Vellum from "../../../../../api";
 import * as core from "../../../../../core";
+import { TestSuiteRunExecConfigRequest } from "../../../../types/TestSuiteRunExecConfigRequest";
 export declare const TestSuiteRunCreateRequest: core.serialization.Schema<serializers.TestSuiteRunCreateRequest.Raw, Vellum.TestSuiteRunCreateRequest>;
 export declare namespace TestSuiteRunCreateRequest {
     interface Raw {
-        test_suite_id?: string | null;
-        exec_config: serializers.TestSuiteRunExecConfigRequest.Raw;
+        test_suite_id: string;
+        exec_config: TestSuiteRunExecConfigRequest.Raw;
     }
 }

package/dist/serialization/resources/testSuiteRuns/client/requests/TestSuiteRunCreateRequest.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.TestSuiteRunCreateRequest = void 0;
 const core = __importStar(require("../../../../../core"));
+const TestSuiteRunExecConfigRequest_1 = require("../../../../types/TestSuiteRunExecConfigRequest");
 exports.TestSuiteRunCreateRequest = core.serialization.object({
-    testSuiteId: core.serialization.property("test_suite_id", core.serialization.string().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("../../../..")))).TestSuiteRunExecConfigRequest; }))),
+    testSuiteId: core.serialization.property("test_suite_id", core.serialization.string()),
+    execConfig: core.serialization.property("exec_config", TestSuiteRunExecConfigRequest_1.TestSuiteRunExecConfigRequest),
 });

package/dist/serialization/resources/testSuites/client/requests/UpsertTestSuiteTestCaseRequest.d.ts

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

package/dist/serialization/resources/testSuites/client/requests/UpsertTestSuiteTestCaseRequest.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.UpsertTestSuiteTestCaseRequest = void 0;
 const core = __importStar(require("../../../../../core"));
+const NamedTestCaseVariableValueRequest_1 = require("../../../../types/NamedTestCaseVariableValueRequest");
 exports.UpsertTestSuiteTestCaseRequest = core.serialization.object({
     upsertTestSuiteTestCaseRequestId: core.serialization.property("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("../../../..")))).NamedTestCaseVariableValueRequest; })))),
-    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("../../../..")))).NamedTestCaseVariableValueRequest; })))),
+    inputValues: core.serialization.property("input_values", core.serialization.list(NamedTestCaseVariableValueRequest_1.NamedTestCaseVariableValueRequest)),
+    evaluationValues: core.serialization.property("evaluation_values", core.serialization.list(NamedTestCaseVariableValueRequest_1.NamedTestCaseVariableValueRequest)),
 });

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

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

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

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

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

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

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

@@ -4,16 +4,19 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { StringChatMessageContent } from "./StringChatMessageContent";
+import { FunctionCallChatMessageContent } from "./FunctionCallChatMessageContent";
+import { ImageChatMessageContent } from "./ImageChatMessageContent";
 export declare const ArrayChatMessageContentItem: core.serialization.Schema<serializers.ArrayChatMessageContentItem.Raw, Vellum.ArrayChatMessageContentItem>;
 export declare namespace ArrayChatMessageContentItem {
     type Raw = ArrayChatMessageContentItem.String | ArrayChatMessageContentItem.FunctionCall | ArrayChatMessageContentItem.Image;
-    interface String extends serializers.StringChatMessageContent.Raw {
+    interface String extends StringChatMessageContent.Raw {
         type: "STRING";
     }
-    interface FunctionCall extends serializers.FunctionCallChatMessageContent.Raw {
+    interface FunctionCall extends FunctionCallChatMessageContent.Raw {
         type: "FUNCTION_CALL";
     }
-    interface Image extends serializers.ImageChatMessageContent.Raw {
+    interface Image extends ImageChatMessageContent.Raw {
         type: "IMAGE";
     }
 }

package/dist/serialization/types/ArrayChatMessageContentItem.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.ArrayChatMessageContentItem = void 0;
 const core = __importStar(require("../../core"));
+const StringChatMessageContent_1 = require("./StringChatMessageContent");
+const FunctionCallChatMessageContent_1 = require("./FunctionCallChatMessageContent");
+const ImageChatMessageContent_1 = require("./ImageChatMessageContent");
 exports.ArrayChatMessageContentItem = core.serialization
     .union("type", {
-    STRING: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).StringChatMessageContent; })),
-    FUNCTION_CALL: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).FunctionCallChatMessageContent; })),
-    IMAGE: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ImageChatMessageContent; })),
+    STRING: StringChatMessageContent_1.StringChatMessageContent,
+    FUNCTION_CALL: FunctionCallChatMessageContent_1.FunctionCallChatMessageContent,
+    IMAGE: ImageChatMessageContent_1.ImageChatMessageContent,
 })
     .transform({
     transform: (value) => value,

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

@@ -4,16 +4,19 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { StringChatMessageContentRequest } from "./StringChatMessageContentRequest";
+import { FunctionCallChatMessageContentRequest } from "./FunctionCallChatMessageContentRequest";
+import { ImageChatMessageContentRequest } from "./ImageChatMessageContentRequest";
 export declare const ArrayChatMessageContentItemRequest: core.serialization.Schema<serializers.ArrayChatMessageContentItemRequest.Raw, Vellum.ArrayChatMessageContentItemRequest>;
 export declare namespace ArrayChatMessageContentItemRequest {
     type Raw = ArrayChatMessageContentItemRequest.String | ArrayChatMessageContentItemRequest.FunctionCall | ArrayChatMessageContentItemRequest.Image;
-    interface String extends serializers.StringChatMessageContentRequest.Raw {
+    interface String extends StringChatMessageContentRequest.Raw {
         type: "STRING";
     }
-    interface FunctionCall extends serializers.FunctionCallChatMessageContentRequest.Raw {
+    interface FunctionCall extends FunctionCallChatMessageContentRequest.Raw {
         type: "FUNCTION_CALL";
     }
-    interface Image extends serializers.ImageChatMessageContentRequest.Raw {
+    interface Image extends ImageChatMessageContentRequest.Raw {
         type: "IMAGE";
     }
 }

package/dist/serialization/types/ArrayChatMessageContentItemRequest.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.ArrayChatMessageContentItemRequest = void 0;
 const core = __importStar(require("../../core"));
+const StringChatMessageContentRequest_1 = require("./StringChatMessageContentRequest");
+const FunctionCallChatMessageContentRequest_1 = require("./FunctionCallChatMessageContentRequest");
+const ImageChatMessageContentRequest_1 = require("./ImageChatMessageContentRequest");
 exports.ArrayChatMessageContentItemRequest = core.serialization
     .union("type", {
-    STRING: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).StringChatMessageContentRequest; })),
-    FUNCTION_CALL: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).FunctionCallChatMessageContentRequest; })),
-    IMAGE: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ImageChatMessageContentRequest; })),
+    STRING: StringChatMessageContentRequest_1.StringChatMessageContentRequest,
+    FUNCTION_CALL: FunctionCallChatMessageContentRequest_1.FunctionCallChatMessageContentRequest,
+    IMAGE: ImageChatMessageContentRequest_1.ImageChatMessageContentRequest,
 })
     .transform({
     transform: (value) => value,

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

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

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

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

@@ -4,31 +4,39 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { StringVariableValue } from "./StringVariableValue";
+import { NumberVariableValue } from "./NumberVariableValue";
+import { JsonVariableValue } from "./JsonVariableValue";
+import { ChatHistoryVariableValue } from "./ChatHistoryVariableValue";
+import { SearchResultsVariableValue } from "./SearchResultsVariableValue";
+import { ErrorVariableValue } from "./ErrorVariableValue";
+import { FunctionCallVariableValue } from "./FunctionCallVariableValue";
+import { ImageVariableValue } from "./ImageVariableValue";
 export declare const ArrayVariableValueItem: core.serialization.Schema<serializers.ArrayVariableValueItem.Raw, Vellum.ArrayVariableValueItem>;
 export declare namespace ArrayVariableValueItem {
     type Raw = ArrayVariableValueItem.String | ArrayVariableValueItem.Number | ArrayVariableValueItem.Json | ArrayVariableValueItem.ChatHistory | ArrayVariableValueItem.SearchResults | ArrayVariableValueItem.Error | ArrayVariableValueItem.FunctionCall | ArrayVariableValueItem.Image;
-    interface String extends serializers.StringVariableValue.Raw {
+    interface String extends StringVariableValue.Raw {
         type: "STRING";
     }
-    interface Number extends serializers.NumberVariableValue.Raw {
+    interface Number extends NumberVariableValue.Raw {
         type: "NUMBER";
     }
-    interface Json extends serializers.JsonVariableValue.Raw {
+    interface Json extends JsonVariableValue.Raw {
         type: "JSON";
     }
-    interface ChatHistory extends serializers.ChatHistoryVariableValue.Raw {
+    interface ChatHistory extends ChatHistoryVariableValue.Raw {
         type: "CHAT_HISTORY";
     }
-    interface SearchResults extends serializers.SearchResultsVariableValue.Raw {
+    interface SearchResults extends SearchResultsVariableValue.Raw {
         type: "SEARCH_RESULTS";
     }
-    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";
     }
-    interface Image extends serializers.ImageVariableValue.Raw {
+    interface Image extends ImageVariableValue.Raw {
         type: "IMAGE";
     }
 }

package/dist/serialization/types/ArrayVariableValueItem.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.ArrayVariableValueItem = void 0;
 const core = __importStar(require("../../core"));
+const StringVariableValue_1 = require("./StringVariableValue");
+const NumberVariableValue_1 = require("./NumberVariableValue");
+const JsonVariableValue_1 = require("./JsonVariableValue");
+const ChatHistoryVariableValue_1 = require("./ChatHistoryVariableValue");
+const SearchResultsVariableValue_1 = require("./SearchResultsVariableValue");
+const ErrorVariableValue_1 = require("./ErrorVariableValue");
+const FunctionCallVariableValue_1 = require("./FunctionCallVariableValue");
+const ImageVariableValue_1 = require("./ImageVariableValue");
 exports.ArrayVariableValueItem = core.serialization
     .union("type", {
-    STRING: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).StringVariableValue; })),
-    NUMBER: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).NumberVariableValue; })),
-    JSON: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).JsonVariableValue; })),
-    CHAT_HISTORY: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ChatHistoryVariableValue; })),
-    SEARCH_RESULTS: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).SearchResultsVariableValue; })),
-    ERROR: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ErrorVariableValue; })),
-    FUNCTION_CALL: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).FunctionCallVariableValue; })),
-    IMAGE: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ImageVariableValue; })),
+    STRING: StringVariableValue_1.StringVariableValue,
+    NUMBER: NumberVariableValue_1.NumberVariableValue,
+    JSON: JsonVariableValue_1.JsonVariableValue,
+    CHAT_HISTORY: ChatHistoryVariableValue_1.ChatHistoryVariableValue,
+    SEARCH_RESULTS: SearchResultsVariableValue_1.SearchResultsVariableValue,
+    ERROR: ErrorVariableValue_1.ErrorVariableValue,
+    FUNCTION_CALL: FunctionCallVariableValue_1.FunctionCallVariableValue,
+    IMAGE: ImageVariableValue_1.ImageVariableValue,
 })
     .transform({
     transform: (value) => value,

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

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

package/dist/serialization/types/ChatHistoryInputRequest.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.ChatHistoryInputRequest = void 0;
 const core = __importStar(require("../../core"));
+const ChatMessageRequest_1 = require("./ChatMessageRequest");
 exports.ChatHistoryInputRequest = core.serialization.object({
     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("..")))).ChatMessageRequest; }))),
+    value: core.serialization.list(ChatMessageRequest_1.ChatMessageRequest),
 });

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

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

package/dist/serialization/types/ChatHistoryVariableValue.js

@@ -25,20 +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.ChatHistoryVariableValue = void 0;
 const core = __importStar(require("../../core"));
+const ChatMessage_1 = require("./ChatMessage");
 exports.ChatHistoryVariableValue = core.serialization.object({
-    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/ChatMessage.d.ts

@@ -4,12 +4,14 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { ChatMessageRole } from "./ChatMessageRole";
+import { ChatMessageContent } from "./ChatMessageContent";
 export declare const ChatMessage: core.serialization.ObjectSchema<serializers.ChatMessage.Raw, Vellum.ChatMessage>;
 export declare namespace ChatMessage {
     interface Raw {
         text?: string | null;
-        role: serializers.ChatMessageRole.Raw;
-        content?: serializers.ChatMessageContent.Raw | null;
+        role: ChatMessageRole.Raw;
+        content?: ChatMessageContent.Raw | null;
         source?: string | null;
     }
 }

package/dist/serialization/types/ChatMessage.js

@@ -25,21 +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.ChatMessage = void 0;
 const core = __importStar(require("../../core"));
+const ChatMessageRole_1 = require("./ChatMessageRole");
+const ChatMessageContent_1 = require("./ChatMessageContent");
 exports.ChatMessage = core.serialization.object({
     text: core.serialization.string().optional(),
-    role: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ChatMessageRole; })),
-    content: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ChatMessageContent; })).optional(),
+    role: ChatMessageRole_1.ChatMessageRole,
+    content: ChatMessageContent_1.ChatMessageContent.optional(),
     source: core.serialization.string().optional(),
 });