vellum-ai 0.3.14 → 0.3.15

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

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

@@ -4,10 +4,12 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { GenerateResultData } from "./GenerateResultData";
+import { GenerateResultError } from "./GenerateResultError";
 export declare const GenerateResult: core.serialization.ObjectSchema<serializers.GenerateResult.Raw, Vellum.GenerateResult>;
 export declare namespace GenerateResult {
     interface Raw {
-        data?: serializers.GenerateResultData.Raw | null;
-        error?: serializers.GenerateResultError.Raw | null;
+        data?: GenerateResultData.Raw | null;
+        error?: GenerateResultError.Raw | null;
     }
 }

package/dist/serialization/types/GenerateResult.js

@@ -25,19 +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.GenerateResult = void 0;
 const core = __importStar(require("../../core"));
+const GenerateResultData_1 = require("./GenerateResultData");
+const GenerateResultError_1 = require("./GenerateResultError");
 exports.GenerateResult = core.serialization.object({
-    data: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).GenerateResultData; })).optional(),
-    error: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).GenerateResultError; })).optional(),
+    data: GenerateResultData_1.GenerateResultData.optional(),
+    error: GenerateResultError_1.GenerateResultError.optional(),
 });

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

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

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

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

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

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

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

@@ -4,11 +4,13 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { GenerateStreamResultData } from "./GenerateStreamResultData";
+import { GenerateResultError } from "./GenerateResultError";
 export declare const GenerateStreamResult: core.serialization.ObjectSchema<serializers.GenerateStreamResult.Raw, Vellum.GenerateStreamResult>;
 export declare namespace GenerateStreamResult {
     interface Raw {
         request_index: number;
-        data?: serializers.GenerateStreamResultData.Raw | null;
-        error?: serializers.GenerateResultError.Raw | null;
+        data?: GenerateStreamResultData.Raw | null;
+        error?: GenerateResultError.Raw | null;
     }
 }

package/dist/serialization/types/GenerateStreamResult.js

@@ -25,20 +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.GenerateStreamResult = void 0;
 const core = __importStar(require("../../core"));
+const GenerateStreamResultData_1 = require("./GenerateStreamResultData");
+const GenerateResultError_1 = require("./GenerateResultError");
 exports.GenerateStreamResult = core.serialization.object({
     requestIndex: core.serialization.property("request_index", core.serialization.number()),
-    data: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).GenerateStreamResultData; })).optional(),
-    error: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).GenerateResultError; })).optional(),
+    data: GenerateStreamResultData_1.GenerateStreamResultData.optional(),
+    error: GenerateResultError_1.GenerateResultError.optional(),
 });

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

@@ -4,10 +4,11 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { EnrichedNormalizedCompletion } from "./EnrichedNormalizedCompletion";
 export declare const GenerateStreamResultData: core.serialization.ObjectSchema<serializers.GenerateStreamResultData.Raw, Vellum.GenerateStreamResultData>;
 export declare namespace GenerateStreamResultData {
     interface Raw {
         completion_index: number;
-        completion: serializers.EnrichedNormalizedCompletion.Raw;
+        completion: EnrichedNormalizedCompletion.Raw;
     }
 }

package/dist/serialization/types/GenerateStreamResultData.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.GenerateStreamResultData = void 0;
 const core = __importStar(require("../../core"));
+const EnrichedNormalizedCompletion_1 = require("./EnrichedNormalizedCompletion");
 exports.GenerateStreamResultData = core.serialization.object({
     completionIndex: core.serialization.property("completion_index", core.serialization.number()),
-    completion: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).EnrichedNormalizedCompletion; })),
+    completion: EnrichedNormalizedCompletion_1.EnrichedNormalizedCompletion,
 });

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

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

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

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

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

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

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

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

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

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

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

package/dist/serialization/types/InitiatedExecutePromptEvent.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.InitiatedExecutePromptEvent = void 0;
 const core = __importStar(require("../../core"));
+const InitiatedPromptExecutionMeta_1 = require("./InitiatedPromptExecutionMeta");
 exports.InitiatedExecutePromptEvent = core.serialization.object({
-    meta: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).InitiatedPromptExecutionMeta; })).optional(),
+    meta: InitiatedPromptExecutionMeta_1.InitiatedPromptExecutionMeta.optional(),
     executionId: core.serialization.property("execution_id", core.serialization.string()),
 });

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

@@ -4,6 +4,8 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { WorkflowNodeResultData } from "./WorkflowNodeResultData";
+import { NodeInputVariableCompiledValue } from "./NodeInputVariableCompiledValue";
 export declare const InitiatedWorkflowNodeResultEvent: core.serialization.ObjectSchema<serializers.InitiatedWorkflowNodeResultEvent.Raw, Vellum.InitiatedWorkflowNodeResultEvent>;
 export declare namespace InitiatedWorkflowNodeResultEvent {
     interface Raw {
@@ -11,8 +13,8 @@ export declare namespace InitiatedWorkflowNodeResultEvent {
         node_id: string;
         node_result_id: string;
         ts?: string | null;
-        data?: serializers.WorkflowNodeResultData.Raw | null;
+        data?: WorkflowNodeResultData.Raw | null;
         source_execution_id?: string | null;
-        input_values?: serializers.NodeInputVariableCompiledValue.Raw[] | null;
+        input_values?: NodeInputVariableCompiledValue.Raw[] | null;
     }
 }

package/dist/serialization/types/InitiatedWorkflowNodeResultEvent.js

@@ -25,26 +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.InitiatedWorkflowNodeResultEvent = void 0;
 const core = __importStar(require("../../core"));
+const WorkflowNodeResultData_1 = require("./WorkflowNodeResultData");
+const NodeInputVariableCompiledValue_1 = require("./NodeInputVariableCompiledValue");
 exports.InitiatedWorkflowNodeResultEvent = core.serialization.object({
     id: core.serialization.string(),
     nodeId: core.serialization.property("node_id", core.serialization.string()),
     nodeResultId: core.serialization.property("node_result_id", core.serialization.string()),
     ts: core.serialization.date().optional(),
-    data: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowNodeResultData; })).optional(),
+    data: WorkflowNodeResultData_1.WorkflowNodeResultData.optional(),
     sourceExecutionId: core.serialization.property("source_execution_id", 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("..")))).NodeInputVariableCompiledValue; })))
-        .optional()),
+    inputValues: core.serialization.property("input_values", core.serialization.list(NodeInputVariableCompiledValue_1.NodeInputVariableCompiledValue).optional()),
 });

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

@@ -4,14 +4,16 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { MetadataFilterRuleCombinator } from "./MetadataFilterRuleCombinator";
+import { LogicalOperator } from "./LogicalOperator";
 export declare const MetadataFilterConfigRequest: core.serialization.ObjectSchema<serializers.MetadataFilterConfigRequest.Raw, Vellum.MetadataFilterConfigRequest>;
 export declare namespace MetadataFilterConfigRequest {
     interface Raw {
-        combinator?: serializers.MetadataFilterRuleCombinator.Raw | null;
+        combinator?: MetadataFilterRuleCombinator.Raw | null;
         negated?: boolean | null;
         rules?: serializers.MetadataFilterRuleRequest.Raw[] | null;
         field?: string | null;
-        operator?: serializers.LogicalOperator.Raw | null;
+        operator?: LogicalOperator.Raw | null;
         value?: string | null;
     }
 }

package/dist/serialization/types/MetadataFilterConfigRequest.js

@@ -37,13 +37,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MetadataFilterConfigRequest = void 0;
 const core = __importStar(require("../../core"));
+const MetadataFilterRuleCombinator_1 = require("./MetadataFilterRuleCombinator");
+const LogicalOperator_1 = require("./LogicalOperator");
 exports.MetadataFilterConfigRequest = core.serialization.object({
-    combinator: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).MetadataFilterRuleCombinator; })).optional(),
+    combinator: MetadataFilterRuleCombinator_1.MetadataFilterRuleCombinator.optional(),
     negated: core.serialization.boolean().optional(),
     rules: core.serialization
         .list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).MetadataFilterRuleRequest; })))
         .optional(),
     field: core.serialization.string().optional(),
-    operator: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).LogicalOperator; })).optional(),
+    operator: LogicalOperator_1.LogicalOperator.optional(),
     value: core.serialization.string().optional(),
 });

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

@@ -4,14 +4,16 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { MetadataFilterRuleCombinator } from "./MetadataFilterRuleCombinator";
+import { LogicalOperator } from "./LogicalOperator";
 export declare const MetadataFilterRuleRequest: core.serialization.ObjectSchema<serializers.MetadataFilterRuleRequest.Raw, Vellum.MetadataFilterRuleRequest>;
 export declare namespace MetadataFilterRuleRequest {
     interface Raw {
-        combinator?: serializers.MetadataFilterRuleCombinator.Raw | null;
+        combinator?: MetadataFilterRuleCombinator.Raw | null;
         negated?: boolean | null;
         rules?: serializers.MetadataFilterRuleRequest.Raw[] | null;
         field?: string | null;
-        operator?: serializers.LogicalOperator.Raw | null;
+        operator?: LogicalOperator.Raw | null;
         value?: string | null;
     }
 }

package/dist/serialization/types/MetadataFilterRuleRequest.js

@@ -37,13 +37,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MetadataFilterRuleRequest = void 0;
 const core = __importStar(require("../../core"));
+const MetadataFilterRuleCombinator_1 = require("./MetadataFilterRuleCombinator");
+const LogicalOperator_1 = require("./LogicalOperator");
 exports.MetadataFilterRuleRequest = core.serialization.object({
-    combinator: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).MetadataFilterRuleCombinator; })).optional(),
+    combinator: MetadataFilterRuleCombinator_1.MetadataFilterRuleCombinator.optional(),
     negated: core.serialization.boolean().optional(),
     rules: core.serialization
         .list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).MetadataFilterRuleRequest; })))
         .optional(),
     field: core.serialization.string().optional(),
-    operator: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).LogicalOperator; })).optional(),
+    operator: LogicalOperator_1.LogicalOperator.optional(),
     value: core.serialization.string().optional(),
 });

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

@@ -4,11 +4,12 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { ModelVersionSandboxSnapshot } from "./ModelVersionSandboxSnapshot";
 export declare const ModelVersionBuildConfig: core.serialization.ObjectSchema<serializers.ModelVersionBuildConfig.Raw, Vellum.ModelVersionBuildConfig>;
 export declare namespace ModelVersionBuildConfig {
     interface Raw {
         base_model: string;
-        sandbox_snapshot?: serializers.ModelVersionSandboxSnapshot.Raw | null;
+        sandbox_snapshot?: ModelVersionSandboxSnapshot.Raw | null;
         prompt_version_id?: string | null;
     }
 }

package/dist/serialization/types/ModelVersionBuildConfig.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.ModelVersionBuildConfig = void 0;
 const core = __importStar(require("../../core"));
+const ModelVersionSandboxSnapshot_1 = require("./ModelVersionSandboxSnapshot");
 exports.ModelVersionBuildConfig = core.serialization.object({
     baseModel: core.serialization.property("base_model", core.serialization.string()),
-    sandboxSnapshot: core.serialization.property("sandbox_snapshot", core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ModelVersionSandboxSnapshot; })).optional()),
+    sandboxSnapshot: core.serialization.property("sandbox_snapshot", ModelVersionSandboxSnapshot_1.ModelVersionSandboxSnapshot.optional()),
     promptVersionId: core.serialization.property("prompt_version_id", core.serialization.string().optional()),
 });

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

@@ -4,13 +4,16 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { ModelVersionExecConfigParameters } from "./ModelVersionExecConfigParameters";
+import { VellumVariable } from "./VellumVariable";
+import { PromptTemplateBlockData } from "./PromptTemplateBlockData";
 export declare const ModelVersionExecConfig: core.serialization.ObjectSchema<serializers.ModelVersionExecConfig.Raw, Vellum.ModelVersionExecConfig>;
 export declare namespace ModelVersionExecConfig {
     interface Raw {
-        parameters: serializers.ModelVersionExecConfigParameters.Raw;
-        input_variables: serializers.VellumVariable.Raw[];
+        parameters: ModelVersionExecConfigParameters.Raw;
+        input_variables: VellumVariable.Raw[];
         prompt_template?: string | null;
-        prompt_block_data?: serializers.PromptTemplateBlockData.Raw | null;
+        prompt_block_data?: PromptTemplateBlockData.Raw | null;
         prompt_syntax_version?: number | null;
     }
 }

package/dist/serialization/types/ModelVersionExecConfig.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.ModelVersionExecConfig = void 0;
 const core = __importStar(require("../../core"));
+const ModelVersionExecConfigParameters_1 = require("./ModelVersionExecConfigParameters");
+const VellumVariable_1 = require("./VellumVariable");
+const PromptTemplateBlockData_1 = require("./PromptTemplateBlockData");
 exports.ModelVersionExecConfig = core.serialization.object({
-    parameters: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ModelVersionExecConfigParameters; })),
-    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; })))),
+    parameters: ModelVersionExecConfigParameters_1.ModelVersionExecConfigParameters,
+    inputVariables: core.serialization.property("input_variables", core.serialization.list(VellumVariable_1.VellumVariable)),
     promptTemplate: core.serialization.property("prompt_template", core.serialization.string().optional()),
-    promptBlockData: core.serialization.property("prompt_block_data", core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).PromptTemplateBlockData; })).optional()),
+    promptBlockData: core.serialization.property("prompt_block_data", PromptTemplateBlockData_1.PromptTemplateBlockData.optional()),
     promptSyntaxVersion: core.serialization.property("prompt_syntax_version", core.serialization.number().optional()),
 });

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

@@ -4,16 +4,20 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { ProviderEnum } from "./ProviderEnum";
+import { ModelVersionBuildConfig } from "./ModelVersionBuildConfig";
+import { ModelVersionExecConfig } from "./ModelVersionExecConfig";
+import { ModelVersionReadStatusEnum } from "./ModelVersionReadStatusEnum";
 export declare const ModelVersionRead: core.serialization.ObjectSchema<serializers.ModelVersionRead.Raw, Vellum.ModelVersionRead>;
 export declare namespace ModelVersionRead {
     interface Raw {
         id: string;
         created: string;
         label: string;
-        provider: serializers.ProviderEnum.Raw;
+        provider: ProviderEnum.Raw;
         external_id: string;
-        build_config: serializers.ModelVersionBuildConfig.Raw;
-        exec_config: serializers.ModelVersionExecConfig.Raw;
-        status?: serializers.ModelVersionReadStatusEnum.Raw | null;
+        build_config: ModelVersionBuildConfig.Raw;
+        exec_config: ModelVersionExecConfig.Raw;
+        status?: ModelVersionReadStatusEnum.Raw | null;
     }
 }