@skmtc/core 0.0.599 → 0.0.600

package/script/oas/union/toUnion.js

@@ -5,18 +5,26 @@ const Union_js_1 = require("./Union.js");
 const toDiscriminatorV3_js_1 = require("../discriminator/toDiscriminatorV3.js");
 const toSchemasV3_js_1 = require("../schema/toSchemasV3.js");
 const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
-const toUnion = ({ value, members, context }) => {
-    const { discriminator, title, description, nullable, example, ...skipped } = value;
+const toUnion = ({ value, members, parentType, context }) => {
+    const { discriminator, title, description, nullable, example, default: defaultValue, ...skipped } = value;
     const extensionFields = (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
         skipped,
-        context
+        parent: value,
+        context,
+        parentType: `schema:${parentType}`
     });
     return new Union_js_1.OasUnion({
         title,
         description,
         nullable,
+        default: defaultValue,
         discriminator: context.trace('discriminator', () => (0, toDiscriminatorV3_js_1.toDiscriminatorV3)({ discriminator, context })),
-        members: members.map((schema, index) => context.trace(`${index}`, () => (0, toSchemasV3_js_1.toSchemaV3)({ schema, context }))),
+        members: members.reduce((acc, item, index) => {
+            if (item === undefined || item === null) {
+                return acc;
+            }
+            return [...acc, context.trace(`${index}`, () => (0, toSchemasV3_js_1.toSchemaV3)({ schema: item, context }))];
+        }, []),
         example,
         extensionFields
     });

package/script/oas/union/union-types.d.ts

@@ -1,4 +1,4 @@
-import { z } from '@hono/zod-openapi';
+import * as v from 'valibot';
 import { type OasSchemaData } from '../schema/schema-types.js';
 import { type OasSchemaRefData } from '../ref/ref-types.js';
 import { type OasDiscriminatorData } from '../discriminator/discriminator-types.js';
@@ -10,5 +10,16 @@ export type OasUnionData = {
     members: (OasSchemaData | OasSchemaRefData)[];
     discriminator?: OasDiscriminatorData;
 };
-export declare const oasUnionData: z.ZodType<OasUnionData>;
+export declare const oasUnionData: v.ObjectSchema<{
+    readonly oasType: v.LiteralSchema<"schema", undefined>;
+    readonly type: v.LiteralSchema<"union", undefined>;
+    readonly title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly members: v.LazySchema<v.ArraySchema<v.UnionSchema<[v.GenericSchema<OasSchemaData>, v.GenericSchema<OasSchemaRefData>], undefined>, undefined>>;
+    readonly discriminator: v.OptionalSchema<v.ObjectSchema<{
+        readonly oasType: v.LiteralSchema<"discriminator", undefined>;
+        readonly propertyName: v.StringSchema<undefined>;
+        readonly mapping: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
 //# sourceMappingURL=union-types.d.ts.map

package/script/oas/union/union-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"union-types.d.ts","sourceRoot":"","sources":["../../../src/oas/union/union-types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAA;AACrC,OAAO,EAAE,KAAK,aAAa,EAAiB,MAAM,2BAA2B,CAAA;AAC7E,OAAO,EAAE,KAAK,gBAAgB,EAAoB,MAAM,qBAAqB,CAAA;AAC7E,OAAO,EACL,KAAK,oBAAoB,EAE1B,MAAM,yCAAyC,CAAA;AAEhD,MAAM,MAAM,YAAY,GAAG;IACzB,OAAO,EAAE,QAAQ,CAAA;IACjB,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE,CAAC,aAAa,GAAG,gBAAgB,CAAC,EAAE,CAAA;IAC7C,aAAa,CAAC,EAAE,oBAAoB,CAAA;CACrC,CAAA;AAED,eAAO,MAAM,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,YAAY,CAO/C,CAAA"}
+{"version":3,"file":"union-types.d.ts","sourceRoot":"","sources":["../../../src/oas/union/union-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,EAAE,KAAK,aAAa,EAAiB,MAAM,2BAA2B,CAAA;AAC7E,OAAO,EAAE,KAAK,gBAAgB,EAAoB,MAAM,qBAAqB,CAAA;AAC7E,OAAO,EACL,KAAK,oBAAoB,EAE1B,MAAM,yCAAyC,CAAA;AAEhD,MAAM,MAAM,YAAY,GAAG;IACzB,OAAO,EAAE,QAAQ,CAAA;IACjB,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE,CAAC,aAAa,GAAG,gBAAgB,CAAC,EAAE,CAAA;IAC7C,aAAa,CAAC,EAAE,oBAAoB,CAAA;CACrC,CAAA;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;aAOvB,CAAA"}

package/script/oas/union/union-types.js

@@ -1,15 +1,38 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.oasUnionData = void 0;
-const zod_openapi_1 = require("@hono/zod-openapi");
+const v = __importStar(require("valibot"));
 const schema_types_js_1 = require("../schema/schema-types.js");
 const ref_types_js_1 = require("../ref/ref-types.js");
 const discriminator_types_js_1 = require("../discriminator/discriminator-types.js");
-exports.oasUnionData = zod_openapi_1.z.object({
-    oasType: zod_openapi_1.z.literal('schema'),
-    type: zod_openapi_1.z.literal('union'),
-    title: zod_openapi_1.z.string().optional(),
-    description: zod_openapi_1.z.string().optional(),
-    members: zod_openapi_1.z.lazy(() => zod_openapi_1.z.array(zod_openapi_1.z.union([schema_types_js_1.oasSchemaData, ref_types_js_1.oasSchemaRefData]))),
-    discriminator: discriminator_types_js_1.oasDiscriminatorData.optional()
+exports.oasUnionData = v.object({
+    oasType: v.literal('schema'),
+    type: v.literal('union'),
+    title: v.optional(v.string()),
+    description: v.optional(v.string()),
+    members: v.lazy(() => v.array(v.union([schema_types_js_1.oasSchemaData, ref_types_js_1.oasSchemaRefData]))),
+    discriminator: v.optional(discriminator_types_js_1.oasDiscriminatorData)
 });

package/script/oas/unknown/toUnknown.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toUnknown.d.ts","sourceRoot":"","sources":["../../../src/oas/unknown/toUnknown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAGzC,KAAK,aAAa,GAAG;IACnB,KAAK,EAAE,SAAS,CAAC,oBAAoB,CAAA;IAErC,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED,eAAO,MAAM,SAAS,uBAAwB,aAAa,KAAG,UAc7D,CAAA"}
+{"version":3,"file":"toUnknown.d.ts","sourceRoot":"","sources":["../../../src/oas/unknown/toUnknown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAGzC,KAAK,aAAa,GAAG;IACnB,KAAK,EAAE,SAAS,CAAC,oBAAoB,CAAA;IAErC,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED,eAAO,MAAM,SAAS,uBAAwB,aAAa,KAAG,UAgB7D,CAAA"}

package/script/oas/unknown/toUnknown.js

@@ -7,7 +7,9 @@ const toUnknown = ({ value, context }) => {
     const { type: _type, title, description, example, ...skipped } = value;
     const extensionFields = (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
         skipped,
-        context
+        parent: value,
+        context,
+        parentType: 'schema:unknown'
     });
     return new Unknown_js_1.OasUnknown({
         title,

package/script/oas/unknown/unknown-types.d.ts

@@ -1,5 +1,11 @@
-import { z } from '@hono/zod-openapi';
-export declare const oasUnknownData: z.ZodType<OasUnknownData>;
+import * as v from 'valibot';
+export declare const oasUnknownData: v.ObjectSchema<{
+    readonly oasType: v.LiteralSchema<"schema", undefined>;
+    readonly title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly default: v.OptionalSchema<v.UnknownSchema, undefined>;
+    readonly type: v.LiteralSchema<"unknown", undefined>;
+}, undefined>;
 export type OasUnknownData = {
     oasType: 'schema';
     title?: string;

package/script/oas/unknown/unknown-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unknown-types.d.ts","sourceRoot":"","sources":["../../../src/oas/unknown/unknown-types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAA;AAErC,eAAO,MAAM,cAAc,EAAE,CAAC,CAAC,OAAO,CAAC,cAAc,CAMnD,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,QAAQ,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,IAAI,EAAE,SAAS,CAAA;CAChB,CAAA"}
+{"version":3,"file":"unknown-types.d.ts","sourceRoot":"","sources":["../../../src/oas/unknown/unknown-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,eAAO,MAAM,cAAc;;;;;;aAMzB,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,QAAQ,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,IAAI,EAAE,SAAS,CAAA;CAChB,CAAA"}

package/script/oas/unknown/unknown-types.js

@@ -1,11 +1,34 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.oasUnknownData = void 0;
-const zod_openapi_1 = require("@hono/zod-openapi");
-exports.oasUnknownData = zod_openapi_1.z.object({
-    oasType: zod_openapi_1.z.literal('schema'),
-    title: zod_openapi_1.z.string().optional(),
-    description: zod_openapi_1.z.string().optional(),
-    default: zod_openapi_1.z.unknown().optional(),
-    type: zod_openapi_1.z.literal('unknown')
+const v = __importStar(require("valibot"));
+exports.oasUnknownData = v.object({
+    oasType: v.literal('schema'),
+    title: v.optional(v.string()),
+    description: v.optional(v.string()),
+    default: v.optional(v.unknown()),
+    type: v.literal('unknown')
 });

package/script/types/EnrichmentRequest.d.ts

@@ -1,8 +1,8 @@
 import "../_dnt.polyfills.js";
-import type { z } from 'zod';
+import type * as v from 'valibot';
 export type EnrichmentRequest<EnrichmentType = undefined> = {
     prompt: string;
-    enrichmentSchema: z.ZodType<EnrichmentType>;
+    enrichmentSchema: v.BaseSchema<EnrichmentType, EnrichmentType, v.BaseIssue<unknown>>;
     content: string;
 };
 //# sourceMappingURL=EnrichmentRequest.d.ts.map

package/script/types/EnrichmentRequest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EnrichmentRequest.d.ts","sourceRoot":"","sources":["../../src/types/EnrichmentRequest.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,MAAM,MAAM,iBAAiB,CAAC,cAAc,GAAG,SAAS,IAAI;IAC1D,MAAM,EAAE,MAAM,CAAA;IACd,gBAAgB,EAAE,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,CAAA;IAC3C,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA"}
+{"version":3,"file":"EnrichmentRequest.d.ts","sourceRoot":"","sources":["../../src/types/EnrichmentRequest.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,KAAK,KAAK,CAAC,MAAM,SAAS,CAAA;AAEjC,MAAM,MAAM,iBAAiB,CAAC,cAAc,GAAG,SAAS,IAAI;IAC1D,MAAM,EAAE,MAAM,CAAA;IACd,gBAAgB,EAAE,CAAC,CAAC,UAAU,CAAC,cAAc,EAAE,cAAc,EAAE,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAA;IACpF,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA"}

package/script/types/Manifest.d.ts

@@ -1,40 +1,26 @@
 import "../_dnt.polyfills.js";
-import { z } from '@hono/zod-openapi';
 import { type ResultsItem } from './Results.js';
 import { type Preview } from './Preview.js';
 import { type SerializedSchemaOption } from './SchemaOptions.js';
+import * as v from 'valibot';
 export type ManifestEntry = {
     lines: number;
     characters: number;
     destinationPath: string;
 };
-export declare const manifestEntry: z.ZodObject<{
-    lines: z.ZodNumber;
-    characters: z.ZodNumber;
-    destinationPath: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    lines: number;
-    characters: number;
-    destinationPath: string;
-}, {
-    lines: number;
-    characters: number;
-    destinationPath: string;
-}>;
+export declare const manifestEntry: v.ObjectSchema<{
+    readonly lines: v.NumberSchema<undefined>;
+    readonly characters: v.NumberSchema<undefined>;
+    readonly destinationPath: v.StringSchema<undefined>;
+}, undefined>;
 export type PreviewItem = {
     name: string;
     exportPath: string;
 };
-export declare const previewItem: z.ZodObject<{
-    name: z.ZodString;
-    exportPath: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    exportPath: string;
-}, {
-    name: string;
-    exportPath: string;
-}>;
+export declare const previewItem: v.ObjectSchema<{
+    readonly name: v.StringSchema<undefined>;
+    readonly exportPath: v.StringSchema<undefined>;
+}, undefined>;
 export type ManifestContent = {
     deploymentId: string;
     traceId: string;
@@ -47,256 +33,52 @@ export type ManifestContent = {
     endAt: number;
     schemaOptions: SerializedSchemaOption[];
 };
-export declare const manifestContent: z.ZodObject<{
-    deploymentId: z.ZodString;
-    traceId: z.ZodString;
-    spanId: z.ZodString;
-    region: z.ZodOptional<z.ZodString>;
-    files: z.ZodRecord<z.ZodString, z.ZodObject<{
-        lines: z.ZodNumber;
-        characters: z.ZodNumber;
-        destinationPath: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        lines: number;
-        characters: number;
-        destinationPath: string;
-    }, {
-        lines: number;
-        characters: number;
-        destinationPath: string;
-    }>>;
-    previews: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
-        name: z.ZodString;
-        exportPath: z.ZodString;
-        group: z.ZodString;
-        route: z.ZodOptional<z.ZodString>;
-        input: z.ZodOptional<z.ZodObject<{
-            schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-            label: z.ZodString;
-            name: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            schema: Record<string, unknown>;
-            label: string;
-            name?: string | undefined;
-        }, {
-            schema: Record<string, unknown>;
-            label: string;
-            name?: string | undefined;
-        }>>;
-        formatter: z.ZodOptional<z.ZodObject<{
-            schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-            label: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            schema: Record<string, unknown>;
-            label: string;
-        }, {
-            schema: Record<string, unknown>;
-            label: string;
-        }>>;
-        source: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
-            type: z.ZodLiteral<"operation">;
-            generatorId: z.ZodString;
-            operationPath: z.ZodString;
-            operationMethod: z.ZodType<import("./Method.js").Method, z.ZodTypeDef, import("./Method.js").Method>;
-        }, "strip", z.ZodTypeAny, {
-            type: "operation";
-            generatorId: string;
-            operationPath: string;
-            operationMethod: import("./Method.js").Method;
-        }, {
-            type: "operation";
-            generatorId: string;
-            operationPath: string;
-            operationMethod: import("./Method.js").Method;
-        }>, z.ZodObject<{
-            type: z.ZodLiteral<"model">;
-            generatorId: z.ZodString;
-            refName: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            type: "model";
-            generatorId: string;
-            refName: string;
-        }, {
-            type: "model";
-            generatorId: string;
-            refName: string;
-        }>]>;
-    }, "strip", z.ZodTypeAny, {
-        name: string;
-        exportPath: string;
-        group: string;
-        source: {
-            type: "operation";
-            generatorId: string;
-            operationPath: string;
-            operationMethod: import("./Method.js").Method;
-        } | {
-            type: "model";
-            generatorId: string;
-            refName: string;
-        };
-        route?: string | undefined;
-        input?: {
-            schema: Record<string, unknown>;
-            label: string;
-            name?: string | undefined;
-        } | undefined;
-        formatter?: {
-            schema: Record<string, unknown>;
-            label: string;
-        } | undefined;
-    }, {
-        name: string;
-        exportPath: string;
-        group: string;
-        source: {
-            type: "operation";
-            generatorId: string;
-            operationPath: string;
-            operationMethod: import("./Method.js").Method;
-        } | {
-            type: "model";
-            generatorId: string;
-            refName: string;
-        };
-        route?: string | undefined;
-        input?: {
-            schema: Record<string, unknown>;
-            label: string;
-            name?: string | undefined;
-        } | undefined;
-        formatter?: {
-            schema: Record<string, unknown>;
-            label: string;
-        } | undefined;
-    }>>>;
-    results: z.ZodType<ResultsItem, z.ZodTypeDef, ResultsItem>;
-    startAt: z.ZodNumber;
-    endAt: z.ZodNumber;
-    schemaOptions: z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<["input", "formatter"]>;
-        name: z.ZodString;
-        exportPath: z.ZodString;
-        matchBy: z.ZodObject<{
-            schema: z.ZodType<import("./SchemaOptions.js").SerializedSchema, z.ZodTypeDef, import("./SchemaOptions.js").SerializedSchema>;
-            name: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            schema: import("./SchemaOptions.js").SerializedSchema;
-            name?: string | undefined;
-        }, {
-            schema: import("./SchemaOptions.js").SerializedSchema;
-            name?: string | undefined;
-        }>;
-    }, "strip", z.ZodTypeAny, {
-        name: string;
-        type: "input" | "formatter";
-        exportPath: string;
-        matchBy: {
-            schema: import("./SchemaOptions.js").SerializedSchema;
-            name?: string | undefined;
-        };
-    }, {
-        name: string;
-        type: "input" | "formatter";
-        exportPath: string;
-        matchBy: {
-            schema: import("./SchemaOptions.js").SerializedSchema;
-            name?: string | undefined;
-        };
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    deploymentId: string;
-    traceId: string;
-    spanId: string;
-    files: Record<string, {
-        lines: number;
-        characters: number;
-        destinationPath: string;
-    }>;
-    previews: Record<string, Record<string, {
-        name: string;
-        exportPath: string;
-        group: string;
-        source: {
-            type: "operation";
-            generatorId: string;
-            operationPath: string;
-            operationMethod: import("./Method.js").Method;
-        } | {
-            type: "model";
-            generatorId: string;
-            refName: string;
-        };
-        route?: string | undefined;
-        input?: {
-            schema: Record<string, unknown>;
-            label: string;
-            name?: string | undefined;
-        } | undefined;
-        formatter?: {
-            schema: Record<string, unknown>;
-            label: string;
-        } | undefined;
-    }>>;
-    results: ResultsItem;
-    startAt: number;
-    endAt: number;
-    schemaOptions: {
-        name: string;
-        type: "input" | "formatter";
-        exportPath: string;
-        matchBy: {
-            schema: import("./SchemaOptions.js").SerializedSchema;
-            name?: string | undefined;
-        };
-    }[];
-    region?: string | undefined;
-}, {
-    deploymentId: string;
-    traceId: string;
-    spanId: string;
-    files: Record<string, {
-        lines: number;
-        characters: number;
-        destinationPath: string;
-    }>;
-    previews: Record<string, Record<string, {
-        name: string;
-        exportPath: string;
-        group: string;
-        source: {
-            type: "operation";
-            generatorId: string;
-            operationPath: string;
-            operationMethod: import("./Method.js").Method;
-        } | {
-            type: "model";
-            generatorId: string;
-            refName: string;
-        };
-        route?: string | undefined;
-        input?: {
-            schema: Record<string, unknown>;
-            label: string;
-            name?: string | undefined;
-        } | undefined;
-        formatter?: {
-            schema: Record<string, unknown>;
-            label: string;
-        } | undefined;
-    }>>;
-    results: ResultsItem;
-    startAt: number;
-    endAt: number;
-    schemaOptions: {
-        name: string;
-        type: "input" | "formatter";
-        exportPath: string;
-        matchBy: {
-            schema: import("./SchemaOptions.js").SerializedSchema;
-            name?: string | undefined;
-        };
-    }[];
-    region?: string | undefined;
-}>;
+export declare const manifestContent: v.ObjectSchema<{
+    readonly deploymentId: v.StringSchema<undefined>;
+    readonly traceId: v.StringSchema<undefined>;
+    readonly spanId: v.StringSchema<undefined>;
+    readonly region: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly files: v.RecordSchema<v.StringSchema<undefined>, v.ObjectSchema<{
+        readonly lines: v.NumberSchema<undefined>;
+        readonly characters: v.NumberSchema<undefined>;
+        readonly destinationPath: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly previews: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.ObjectSchema<{
+        readonly name: v.StringSchema<undefined>;
+        readonly exportPath: v.StringSchema<undefined>;
+        readonly group: v.StringSchema<undefined>;
+        readonly route: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly input: v.OptionalSchema<v.ObjectSchema<{
+            readonly schema: v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>;
+            readonly label: v.StringSchema<undefined>;
+            readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly formatter: v.OptionalSchema<v.ObjectSchema<{
+            readonly schema: v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>;
+            readonly label: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+        readonly source: v.VariantSchema<"type", [v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"operation", undefined>;
+            readonly generatorId: v.StringSchema<undefined>;
+            readonly operationPath: v.StringSchema<undefined>;
+            readonly operationMethod: v.UnionSchema<[v.LiteralSchema<"get", undefined>, v.LiteralSchema<"put", undefined>, v.LiteralSchema<"post", undefined>, v.LiteralSchema<"delete", undefined>, v.LiteralSchema<"options", undefined>, v.LiteralSchema<"head", undefined>, v.LiteralSchema<"patch", undefined>], undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"model", undefined>;
+            readonly generatorId: v.StringSchema<undefined>;
+            readonly refName: v.StringSchema<undefined>;
+        }, undefined>], undefined>;
+    }, undefined>, undefined>, undefined>;
+    readonly results: v.GenericSchema<ResultsItem>;
+    readonly startAt: v.NumberSchema<undefined>;
+    readonly endAt: v.NumberSchema<undefined>;
+    readonly schemaOptions: v.ArraySchema<v.ObjectSchema<{
+        readonly type: v.UnionSchema<[v.LiteralSchema<"input", undefined>, v.LiteralSchema<"formatter", undefined>], undefined>;
+        readonly name: v.StringSchema<undefined>;
+        readonly exportPath: v.StringSchema<undefined>;
+        readonly matchBy: v.ObjectSchema<{
+            readonly schema: v.GenericSchema<import("./SchemaOptions.js").SerializedSchema>;
+            readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
 //# sourceMappingURL=Manifest.d.ts.map

package/script/types/Manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Manifest.d.ts","sourceRoot":"","sources":["../../src/types/Manifest.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAA;AACrC,OAAO,EAAsC,KAAK,WAAW,EAAE,MAAM,cAAc,CAAA;AACnF,OAAO,EAAW,KAAK,OAAO,EAAE,MAAM,cAAc,CAAA;AACpD,OAAO,EAA0B,KAAK,sBAAsB,EAAE,MAAM,oBAAoB,CAAA;AACxF,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,EAAE,MAAM,CAAA;IAClB,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;EAMC,CAAA;AAE3B,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,eAAO,MAAM,WAAW;;;;;;;;;EAKC,CAAA;AACzB,MAAM,MAAM,eAAe,GAAG;IAC5B,YAAY,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IACpC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACjD,OAAO,EAAE,WAAW,CAAA;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,aAAa,EAAE,sBAAsB,EAAE,CAAA;CACxC,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAaC,CAAA"}
+{"version":3,"file":"Manifest.d.ts","sourceRoot":"","sources":["../../src/types/Manifest.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,EAAe,KAAK,WAAW,EAAE,MAAM,cAAc,CAAA;AAC5D,OAAO,EAAW,KAAK,OAAO,EAAE,MAAM,cAAc,CAAA;AACpD,OAAO,EAA0B,KAAK,sBAAsB,EAAE,MAAM,oBAAoB,CAAA;AACxF,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,EAAE,MAAM,CAAA;IAClB,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,eAAO,MAAM,aAAa;;;;aAIxB,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,eAAO,MAAM,WAAW;;;aAGtB,CAAA;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,YAAY,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IACpC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACjD,OAAO,EAAE,WAAW,CAAA;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,aAAa,EAAE,sBAAsB,EAAE,CAAA;CACxC,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAW1B,CAAA"}