vellum-ai 0.3.13 → 0.3.15

package/serialization/types/PaginatedDocumentIndexReadList.js

@@ -25,23 +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.PaginatedDocumentIndexReadList = void 0;
 const core = __importStar(require("../../core"));
+const DocumentIndexRead_1 = require("./DocumentIndexRead");
 exports.PaginatedDocumentIndexReadList = core.serialization.object({
     count: core.serialization.number().optional(),
     next: core.serialization.string().optional(),
     previous: core.serialization.string().optional(),
-    results: core.serialization
-        .list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).DocumentIndexRead; })))
-        .optional(),
+    results: core.serialization.list(DocumentIndexRead_1.DocumentIndexRead).optional(),
 });

package/serialization/types/PaginatedSlimDeploymentReadList.d.ts

@@ -4,12 +4,13 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { SlimDeploymentRead } from "./SlimDeploymentRead";
 export declare const PaginatedSlimDeploymentReadList: core.serialization.ObjectSchema<serializers.PaginatedSlimDeploymentReadList.Raw, Vellum.PaginatedSlimDeploymentReadList>;
 export declare namespace PaginatedSlimDeploymentReadList {
     interface Raw {
         count?: number | null;
         next?: string | null;
         previous?: string | null;
-        results?: serializers.SlimDeploymentRead.Raw[] | null;
+        results?: SlimDeploymentRead.Raw[] | null;
     }
 }

package/serialization/types/PaginatedSlimDeploymentReadList.js

@@ -25,23 +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.PaginatedSlimDeploymentReadList = void 0;
 const core = __importStar(require("../../core"));
+const SlimDeploymentRead_1 = require("./SlimDeploymentRead");
 exports.PaginatedSlimDeploymentReadList = core.serialization.object({
     count: core.serialization.number().optional(),
     next: core.serialization.string().optional(),
     previous: core.serialization.string().optional(),
-    results: core.serialization
-        .list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).SlimDeploymentRead; })))
-        .optional(),
+    results: core.serialization.list(SlimDeploymentRead_1.SlimDeploymentRead).optional(),
 });

package/serialization/types/PaginatedSlimDocumentList.d.ts

@@ -4,12 +4,13 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { SlimDocument } from "./SlimDocument";
 export declare const PaginatedSlimDocumentList: core.serialization.ObjectSchema<serializers.PaginatedSlimDocumentList.Raw, Vellum.PaginatedSlimDocumentList>;
 export declare namespace PaginatedSlimDocumentList {
     interface Raw {
         count?: number | null;
         next?: string | null;
         previous?: string | null;
-        results?: serializers.SlimDocument.Raw[] | null;
+        results?: SlimDocument.Raw[] | null;
     }
 }

package/serialization/types/PaginatedSlimDocumentList.js

@@ -25,23 +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.PaginatedSlimDocumentList = void 0;
 const core = __importStar(require("../../core"));
+const SlimDocument_1 = require("./SlimDocument");
 exports.PaginatedSlimDocumentList = core.serialization.object({
     count: core.serialization.number().optional(),
     next: core.serialization.string().optional(),
     previous: core.serialization.string().optional(),
-    results: core.serialization
-        .list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).SlimDocument; })))
-        .optional(),
+    results: core.serialization.list(SlimDocument_1.SlimDocument).optional(),
 });

package/serialization/types/PaginatedSlimWorkflowDeploymentList.d.ts

@@ -4,12 +4,13 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { SlimWorkflowDeployment } from "./SlimWorkflowDeployment";
 export declare const PaginatedSlimWorkflowDeploymentList: core.serialization.ObjectSchema<serializers.PaginatedSlimWorkflowDeploymentList.Raw, Vellum.PaginatedSlimWorkflowDeploymentList>;
 export declare namespace PaginatedSlimWorkflowDeploymentList {
     interface Raw {
         count?: number | null;
         next?: string | null;
         previous?: string | null;
-        results?: serializers.SlimWorkflowDeployment.Raw[] | null;
+        results?: SlimWorkflowDeployment.Raw[] | null;
     }
 }

package/serialization/types/PaginatedSlimWorkflowDeploymentList.js

@@ -25,23 +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.PaginatedSlimWorkflowDeploymentList = void 0;
 const core = __importStar(require("../../core"));
+const SlimWorkflowDeployment_1 = require("./SlimWorkflowDeployment");
 exports.PaginatedSlimWorkflowDeploymentList = core.serialization.object({
     count: core.serialization.number().optional(),
     next: core.serialization.string().optional(),
     previous: core.serialization.string().optional(),
-    results: core.serialization
-        .list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).SlimWorkflowDeployment; })))
-        .optional(),
+    results: core.serialization.list(SlimWorkflowDeployment_1.SlimWorkflowDeployment).optional(),
 });

package/serialization/types/PaginatedTestSuiteRunExecutionList.d.ts

@@ -4,12 +4,13 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { TestSuiteRunExecution } from "./TestSuiteRunExecution";
 export declare const PaginatedTestSuiteRunExecutionList: core.serialization.ObjectSchema<serializers.PaginatedTestSuiteRunExecutionList.Raw, Vellum.PaginatedTestSuiteRunExecutionList>;
 export declare namespace PaginatedTestSuiteRunExecutionList {
     interface Raw {
-        count?: number | null;
+        count: number;
         next?: string | null;
         previous?: string | null;
-        results?: serializers.TestSuiteRunExecution.Raw[] | null;
+        results: TestSuiteRunExecution.Raw[];
     }
 }

package/serialization/types/PaginatedTestSuiteRunExecutionList.js

@@ -25,23 +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.PaginatedTestSuiteRunExecutionList = void 0;
 const core = __importStar(require("../../core"));
+const TestSuiteRunExecution_1 = require("./TestSuiteRunExecution");
 exports.PaginatedTestSuiteRunExecutionList = core.serialization.object({
-    count: core.serialization.number().optional(),
+    count: core.serialization.number(),
     next: core.serialization.string().optional(),
     previous: core.serialization.string().optional(),
-    results: core.serialization
-        .list(core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).TestSuiteRunExecution; })))
-        .optional(),
+    results: core.serialization.list(TestSuiteRunExecution_1.TestSuiteRunExecution),
 });

package/serialization/types/PromptDeploymentInputRequest.d.ts

@@ -4,16 +4,19 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { StringInputRequest } from "./StringInputRequest";
+import { JsonInputRequest } from "./JsonInputRequest";
+import { ChatHistoryInputRequest } from "./ChatHistoryInputRequest";
 export declare const PromptDeploymentInputRequest: core.serialization.Schema<serializers.PromptDeploymentInputRequest.Raw, Vellum.PromptDeploymentInputRequest>;
 export declare namespace PromptDeploymentInputRequest {
     type Raw = PromptDeploymentInputRequest.String | PromptDeploymentInputRequest.Json | PromptDeploymentInputRequest.ChatHistory;
-    interface String extends serializers.StringInputRequest.Raw {
+    interface String extends StringInputRequest.Raw {
         type: "STRING";
     }
-    interface Json extends serializers.JsonInputRequest.Raw {
+    interface Json extends JsonInputRequest.Raw {
         type: "JSON";
     }
-    interface ChatHistory extends serializers.ChatHistoryInputRequest.Raw {
+    interface ChatHistory extends ChatHistoryInputRequest.Raw {
         type: "CHAT_HISTORY";
     }
 }

package/serialization/types/PromptDeploymentInputRequest.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.PromptDeploymentInputRequest = void 0;
 const core = __importStar(require("../../core"));
+const StringInputRequest_1 = require("./StringInputRequest");
+const JsonInputRequest_1 = require("./JsonInputRequest");
+const ChatHistoryInputRequest_1 = require("./ChatHistoryInputRequest");
 exports.PromptDeploymentInputRequest = core.serialization
     .union("type", {
-    STRING: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).StringInputRequest; })),
-    JSON: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).JsonInputRequest; })),
-    CHAT_HISTORY: core.serialization.lazyObject(() => __awaiter(void 0, void 0, void 0, function* () { return (yield Promise.resolve().then(() => __importStar(require("..")))).ChatHistoryInputRequest; })),
+    STRING: StringInputRequest_1.StringInputRequest,
+    JSON: JsonInputRequest_1.JsonInputRequest,
+    CHAT_HISTORY: ChatHistoryInputRequest_1.ChatHistoryInputRequest,
 })
     .transform({
     transform: (value) => value,

package/serialization/types/PromptExecutionMeta.d.ts

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

package/serialization/types/PromptExecutionMeta.js

@@ -25,22 +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.PromptExecutionMeta = void 0;
 const core = __importStar(require("../../core"));
+const FinishReasonEnum_1 = require("./FinishReasonEnum");
 exports.PromptExecutionMeta = core.serialization.object({
     modelName: core.serialization.property("model_name", core.serialization.string().optional()),
     latency: core.serialization.number().optional(),
     deploymentReleaseTag: core.serialization.property("deployment_release_tag", core.serialization.string().optional()),
     promptVersionId: core.serialization.property("prompt_version_id", core.serialization.string().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/serialization/types/PromptNodeResult.d.ts

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

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

package/serialization/types/PromptOutput.d.ts

@@ -4,19 +4,23 @@
 import * as serializers from "..";
 import * as Vellum from "../../api";
 import * as core from "../../core";
+import { StringVariableValue } from "./StringVariableValue";
+import { JsonVariableValue } from "./JsonVariableValue";
+import { ErrorVariableValue } from "./ErrorVariableValue";
+import { FunctionCallVariableValue } from "./FunctionCallVariableValue";
 export declare const PromptOutput: core.serialization.Schema<serializers.PromptOutput.Raw, Vellum.PromptOutput>;
 export declare namespace PromptOutput {
     type Raw = PromptOutput.String | PromptOutput.Json | PromptOutput.Error | PromptOutput.FunctionCall;
-    interface String extends serializers.StringVariableValue.Raw {
+    interface String extends StringVariableValue.Raw {
         type: "STRING";
     }
-    interface Json extends serializers.JsonVariableValue.Raw {
+    interface Json extends JsonVariableValue.Raw {
         type: "JSON";
     }
-    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";
     }
 }

package/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/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/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/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/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/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/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/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/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/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/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/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;
     }
 }