vellum-ai 0.3.13 → 0.3.15

package/dist/serialization/types/PromptOutput.js

@@ -25,24 +25,19 @@ 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.PromptOutput = void 0;
 const core = __importStar(require("../../core"));
+const StringVariableValue_1 = require("./StringVariableValue");
+const JsonVariableValue_1 = require("./JsonVariableValue");
+const ErrorVariableValue_1 = require("./ErrorVariableValue");
+const FunctionCallVariableValue_1 = require("./FunctionCallVariableValue");
 exports.PromptOutput = core.serialization
     .union("type", {
-    STRING: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).StringVariableValue; })),
-    JSON: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).JsonVariableValue; })),
-    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; })),
+    STRING: StringVariableValue_1.StringVariableValue,
+    JSON: JsonVariableValue_1.JsonVariableValue,
+    ERROR: ErrorVariableValue_1.ErrorVariableValue,
+    FUNCTION_CALL: FunctionCallVariableValue_1.FunctionCallVariableValue,
 })
     .transform({
     transform: (value) => value,

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

@@ -4,11 +4,12 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { BlockTypeEnum } from "./BlockTypeEnum";
 export declare const PromptTemplateBlock: core.serialization.ObjectSchema<serializers.PromptTemplateBlock.Raw, Vellum.PromptTemplateBlock>;
 export declare namespace PromptTemplateBlock {
     interface Raw {
         id: string;
-        block_type: serializers.BlockTypeEnum.Raw;
+        block_type: BlockTypeEnum.Raw;
         properties: serializers.PromptTemplateBlockProperties.Raw;
     }
 }

package/dist/serialization/types/PromptTemplateBlock.js

@@ -37,8 +37,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PromptTemplateBlock = void 0;
 const core = __importStar(require("../../core"));
+const BlockTypeEnum_1 = require("./BlockTypeEnum");
 exports.PromptTemplateBlock = core.serialization.object({
     id: core.serialization.string(),
-    blockType: core.serialization.property("block_type", core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).BlockTypeEnum; }))),
+    blockType: core.serialization.property("block_type", BlockTypeEnum_1.BlockTypeEnum),
     properties: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).PromptTemplateBlockProperties; })),
 });

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

@@ -4,14 +4,16 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { ChatMessageRole } from "./ChatMessageRole";
+import { VellumVariableType } from "./VellumVariableType";
 export declare const PromptTemplateBlockProperties: core.serialization.ObjectSchema<serializers.PromptTemplateBlockProperties.Raw, Vellum.PromptTemplateBlockProperties>;
 export declare namespace PromptTemplateBlockProperties {
     interface Raw {
-        chat_role?: serializers.ChatMessageRole.Raw | null;
+        chat_role?: ChatMessageRole.Raw | null;
         chat_message_unterminated?: boolean | null;
         chat_source?: string | null;
         template?: string | null;
-        template_type?: serializers.VellumVariableType.Raw | null;
+        template_type?: VellumVariableType.Raw | null;
         function_name?: string | null;
         function_description?: string | null;
         function_parameters?: Record<string, unknown> | null;

package/dist/serialization/types/PromptTemplateBlockProperties.js

@@ -37,12 +37,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PromptTemplateBlockProperties = void 0;
 const core = __importStar(require("../../core"));
+const ChatMessageRole_1 = require("./ChatMessageRole");
+const VellumVariableType_1 = require("./VellumVariableType");
 exports.PromptTemplateBlockProperties = core.serialization.object({
-    chatRole: core.serialization.property("chat_role", core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ChatMessageRole; })).optional()),
+    chatRole: core.serialization.property("chat_role", ChatMessageRole_1.ChatMessageRole.optional()),
     chatMessageUnterminated: core.serialization.property("chat_message_unterminated", core.serialization.boolean().optional()),
     chatSource: core.serialization.property("chat_source", core.serialization.string().optional()),
     template: core.serialization.string().optional(),
-    templateType: core.serialization.property("template_type", core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).VellumVariableType; })).optional()),
+    templateType: core.serialization.property("template_type", VellumVariableType_1.VellumVariableType.optional()),
     functionName: core.serialization.property("function_name", core.serialization.string().optional()),
     functionDescription: core.serialization.property("function_description", core.serialization.string().optional()),
     functionParameters: core.serialization.property("function_parameters", core.serialization.record(core.serialization.string(), core.serialization.unknown()).optional()),

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

@@ -4,14 +4,16 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { ChatMessageRole } from "./ChatMessageRole";
+import { VellumVariableType } from "./VellumVariableType";
 export declare const PromptTemplateBlockPropertiesRequest: core.serialization.ObjectSchema<serializers.PromptTemplateBlockPropertiesRequest.Raw, Vellum.PromptTemplateBlockPropertiesRequest>;
 export declare namespace PromptTemplateBlockPropertiesRequest {
     interface Raw {
-        chat_role?: serializers.ChatMessageRole.Raw | null;
+        chat_role?: ChatMessageRole.Raw | null;
         chat_message_unterminated?: boolean | null;
         chat_source?: string | null;
         template?: string | null;
-        template_type?: serializers.VellumVariableType.Raw | null;
+        template_type?: VellumVariableType.Raw | null;
         function_name?: string | null;
         function_description?: string | null;
         function_parameters?: Record<string, unknown> | null;

package/dist/serialization/types/PromptTemplateBlockPropertiesRequest.js

@@ -37,12 +37,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PromptTemplateBlockPropertiesRequest = void 0;
 const core = __importStar(require("../../core"));
+const ChatMessageRole_1 = require("./ChatMessageRole");
+const VellumVariableType_1 = require("./VellumVariableType");
 exports.PromptTemplateBlockPropertiesRequest = core.serialization.object({
-    chatRole: core.serialization.property("chat_role", core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ChatMessageRole; })).optional()),
+    chatRole: core.serialization.property("chat_role", ChatMessageRole_1.ChatMessageRole.optional()),
     chatMessageUnterminated: core.serialization.property("chat_message_unterminated", core.serialization.boolean().optional()),
     chatSource: core.serialization.property("chat_source", core.serialization.string().optional()),
     template: core.serialization.string().optional(),
-    templateType: core.serialization.property("template_type", core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).VellumVariableType; })).optional()),
+    templateType: core.serialization.property("template_type", VellumVariableType_1.VellumVariableType.optional()),
     functionName: core.serialization.property("function_name", core.serialization.string().optional()),
     functionDescription: core.serialization.property("function_description", core.serialization.string().optional()),
     functionParameters: core.serialization.property("function_parameters", core.serialization.record(core.serialization.string(), core.serialization.unknown()).optional()),

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

@@ -4,11 +4,12 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { BlockTypeEnum } from "./BlockTypeEnum";
 export declare const PromptTemplateBlockRequest: core.serialization.ObjectSchema<serializers.PromptTemplateBlockRequest.Raw, Vellum.PromptTemplateBlockRequest>;
 export declare namespace PromptTemplateBlockRequest {
     interface Raw {
         id: string;
-        block_type: serializers.BlockTypeEnum.Raw;
+        block_type: BlockTypeEnum.Raw;
         properties: serializers.PromptTemplateBlockPropertiesRequest.Raw;
     }
 }

package/dist/serialization/types/PromptTemplateBlockRequest.js

@@ -37,8 +37,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PromptTemplateBlockRequest = void 0;
 const core = __importStar(require("../../core"));
+const BlockTypeEnum_1 = require("./BlockTypeEnum");
 exports.PromptTemplateBlockRequest = core.serialization.object({
     id: core.serialization.string(),
-    blockType: core.serialization.property("block_type", core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).BlockTypeEnum; }))),
+    blockType: core.serialization.property("block_type", BlockTypeEnum_1.BlockTypeEnum),
     properties: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).PromptTemplateBlockPropertiesRequest; })),
 });

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

@@ -4,10 +4,12 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { PromptTemplateBlockDataRequest } from "./PromptTemplateBlockDataRequest";
+import { RegisteredPromptInputVariableRequest } from "./RegisteredPromptInputVariableRequest";
 export declare const RegisterPromptPromptInfoRequest: core.serialization.ObjectSchema<serializers.RegisterPromptPromptInfoRequest.Raw, Vellum.RegisterPromptPromptInfoRequest>;
 export declare namespace RegisterPromptPromptInfoRequest {
     interface Raw {
-        prompt_block_data: serializers.PromptTemplateBlockDataRequest.Raw;
-        input_variables: serializers.RegisteredPromptInputVariableRequest.Raw[];
+        prompt_block_data: PromptTemplateBlockDataRequest.Raw;
+        input_variables: RegisteredPromptInputVariableRequest.Raw[];
     }
 }

package/dist/serialization/types/RegisterPromptPromptInfoRequest.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.RegisterPromptPromptInfoRequest = void 0;
 const core = __importStar(require("../../core"));
+const PromptTemplateBlockDataRequest_1 = require("./PromptTemplateBlockDataRequest");
+const RegisteredPromptInputVariableRequest_1 = require("./RegisteredPromptInputVariableRequest");
 exports.RegisterPromptPromptInfoRequest = core.serialization.object({
-    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("..")))).PromptTemplateBlockDataRequest; }))),
-    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("..")))).RegisteredPromptInputVariableRequest; })))),
+    promptBlockData: core.serialization.property("prompt_block_data", PromptTemplateBlockDataRequest_1.PromptTemplateBlockDataRequest),
+    inputVariables: core.serialization.property("input_variables", core.serialization.list(RegisteredPromptInputVariableRequest_1.RegisteredPromptInputVariableRequest)),
 });

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

@@ -4,14 +4,19 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { RegisterPromptPrompt } from "./RegisterPromptPrompt";
+import { RegisteredPromptSandboxSnapshot } from "./RegisteredPromptSandboxSnapshot";
+import { RegisteredPromptSandbox } from "./RegisteredPromptSandbox";
+import { RegisteredPromptModelVersion } from "./RegisteredPromptModelVersion";
+import { RegisteredPromptDeployment } from "./RegisteredPromptDeployment";
 export declare const RegisterPromptResponse: core.serialization.ObjectSchema<serializers.RegisterPromptResponse.Raw, Vellum.RegisterPromptResponse>;
 export declare namespace RegisterPromptResponse {
     interface Raw {
-        prompt: serializers.RegisterPromptPrompt.Raw;
-        sandbox_snapshot: serializers.RegisteredPromptSandboxSnapshot.Raw;
-        sandbox: serializers.RegisteredPromptSandbox.Raw;
-        model_version: serializers.RegisteredPromptModelVersion.Raw;
+        prompt: RegisterPromptPrompt.Raw;
+        sandbox_snapshot: RegisteredPromptSandboxSnapshot.Raw;
+        sandbox: RegisteredPromptSandbox.Raw;
+        model_version: RegisteredPromptModelVersion.Raw;
         prompt_version_id: string;
-        deployment: serializers.RegisteredPromptDeployment.Raw;
+        deployment: RegisteredPromptDeployment.Raw;
     }
 }

package/dist/serialization/types/RegisterPromptResponse.js

@@ -25,23 +25,19 @@ 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.RegisterPromptResponse = void 0;
 const core = __importStar(require("../../core"));
+const RegisterPromptPrompt_1 = require("./RegisterPromptPrompt");
+const RegisteredPromptSandboxSnapshot_1 = require("./RegisteredPromptSandboxSnapshot");
+const RegisteredPromptSandbox_1 = require("./RegisteredPromptSandbox");
+const RegisteredPromptModelVersion_1 = require("./RegisteredPromptModelVersion");
+const RegisteredPromptDeployment_1 = require("./RegisteredPromptDeployment");
 exports.RegisterPromptResponse = core.serialization.object({
-    prompt: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).RegisterPromptPrompt; })),
-    sandboxSnapshot: core.serialization.property("sandbox_snapshot", core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).RegisteredPromptSandboxSnapshot; }))),
-    sandbox: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).RegisteredPromptSandbox; })),
-    modelVersion: core.serialization.property("model_version", core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).RegisteredPromptModelVersion; }))),
+    prompt: RegisterPromptPrompt_1.RegisterPromptPrompt,
+    sandboxSnapshot: core.serialization.property("sandbox_snapshot", RegisteredPromptSandboxSnapshot_1.RegisteredPromptSandboxSnapshot),
+    sandbox: RegisteredPromptSandbox_1.RegisteredPromptSandbox,
+    modelVersion: core.serialization.property("model_version", RegisteredPromptModelVersion_1.RegisteredPromptModelVersion),
     promptVersionId: core.serialization.property("prompt_version_id", core.serialization.string()),
-    deployment: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).RegisteredPromptDeployment; })),
+    deployment: RegisteredPromptDeployment_1.RegisteredPromptDeployment,
 });

package/dist/serialization/types/RegisteredPromptInputVariableRequest.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 RegisteredPromptInputVariableRequest: core.serialization.ObjectSchema<serializers.RegisteredPromptInputVariableRequest.Raw, Vellum.RegisteredPromptInputVariableRequest>;
 export declare namespace RegisteredPromptInputVariableRequest {
     interface Raw {
         key: string;
         id?: string | null;
-        type?: serializers.VellumVariableType.Raw | null;
+        type?: VellumVariableType.Raw | null;
     }
 }

package/dist/serialization/types/RegisteredPromptInputVariableRequest.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.RegisteredPromptInputVariableRequest = void 0;
 const core = __importStar(require("../../core"));
+const VellumVariableType_1 = require("./VellumVariableType");
 exports.RegisteredPromptInputVariableRequest = core.serialization.object({
     key: core.serialization.string(),
     id: core.serialization.string().optional(),
-    type: core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).VellumVariableType; })).optional(),
+    type: VellumVariableType_1.VellumVariableType.optional(),
 });

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

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

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

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

@@ -4,12 +4,14 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { PromptExecutionMeta } from "./PromptExecutionMeta";
+import { VellumError } from "./VellumError";
 export declare const RejectedExecutePromptResponse: core.serialization.ObjectSchema<serializers.RejectedExecutePromptResponse.Raw, Vellum.RejectedExecutePromptResponse>;
 export declare namespace RejectedExecutePromptResponse {
     interface Raw {
-        meta?: serializers.PromptExecutionMeta.Raw | null;
+        meta?: PromptExecutionMeta.Raw | null;
         raw?: Record<string, unknown> | null;
         execution_id: string;
-        error: serializers.VellumError.Raw;
+        error: VellumError.Raw;
     }
 }

package/dist/serialization/types/RejectedExecutePromptResponse.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.RejectedExecutePromptResponse = void 0;
 const core = __importStar(require("../../core"));
+const PromptExecutionMeta_1 = require("./PromptExecutionMeta");
+const VellumError_1 = require("./VellumError");
 exports.RejectedExecutePromptResponse = core.serialization.object({
-    meta: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).PromptExecutionMeta; })).optional(),
+    meta: PromptExecutionMeta_1.PromptExecutionMeta.optional(),
     raw: core.serialization.record(core.serialization.string(), core.serialization.unknown()).optional(),
     executionId: core.serialization.property("execution_id", core.serialization.string()),
-    error: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).VellumError; })),
+    error: VellumError_1.VellumError,
 });

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

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

package/dist/serialization/types/RejectedExecuteWorkflowWorkflowResultEvent.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.RejectedExecuteWorkflowWorkflowResultEvent = void 0;
 const core = __importStar(require("../../core"));
+const WorkflowEventError_1 = require("./WorkflowEventError");
 exports.RejectedExecuteWorkflowWorkflowResultEvent = core.serialization.object({
     id: core.serialization.string(),
     ts: core.serialization.date(),
-    error: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowEventError; })),
+    error: WorkflowEventError_1.WorkflowEventError,
 });

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

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

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

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

package/dist/serialization/types/RejectedPromptExecutionMeta.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.RejectedPromptExecutionMeta = void 0;
 const core = __importStar(require("../../core"));
+const FinishReasonEnum_1 = require("./FinishReasonEnum");
 exports.RejectedPromptExecutionMeta = core.serialization.object({
     latency: core.serialization.number().optional(),
-    finishReason: core.serialization.property("finish_reason", core.serialization.lazy(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).FinishReasonEnum; })).optional()),
+    finishReason: core.serialization.property("finish_reason", FinishReasonEnum_1.FinishReasonEnum.optional()),
 });

package/dist/serialization/types/RejectedWorkflowNodeResultEvent.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 { WorkflowEventError } from "./WorkflowEventError";
 export declare const RejectedWorkflowNodeResultEvent: core.serialization.ObjectSchema<serializers.RejectedWorkflowNodeResultEvent.Raw, Vellum.RejectedWorkflowNodeResultEvent>;
 export declare namespace RejectedWorkflowNodeResultEvent {
     interface Raw {
@@ -11,8 +13,8 @@ export declare namespace RejectedWorkflowNodeResultEvent {
         node_id: string;
         node_result_id: string;
         ts?: string | null;
-        data?: serializers.WorkflowNodeResultData.Raw | null;
+        data?: WorkflowNodeResultData.Raw | null;
         source_execution_id?: string | null;
-        error: serializers.WorkflowEventError.Raw;
+        error: WorkflowEventError.Raw;
     }
 }

package/dist/serialization/types/RejectedWorkflowNodeResultEvent.js

@@ -25,24 +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.RejectedWorkflowNodeResultEvent = void 0;
 const core = __importStar(require("../../core"));
+const WorkflowNodeResultData_1 = require("./WorkflowNodeResultData");
+const WorkflowEventError_1 = require("./WorkflowEventError");
 exports.RejectedWorkflowNodeResultEvent = 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()),
-    error: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).WorkflowEventError; })),
+    error: WorkflowEventError_1.WorkflowEventError,
 });

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

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

package/dist/serialization/types/SandboxScenario.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.SandboxScenario = void 0;
 const core = __importStar(require("../../core"));
+const ScenarioInput_1 = require("./ScenarioInput");
 exports.SandboxScenario = 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("..")))).ScenarioInput; }))),
+    inputs: core.serialization.list(ScenarioInput_1.ScenarioInput),
     id: core.serialization.string(),
 });