@skmtc/core 0.0.599 → 0.0.601

package/esm/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/esm/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"}

package/esm/types/Manifest.js

@@ -1,32 +1,26 @@
 import "../_dnt.polyfills.js";
-import { z } from '@hono/zod-openapi';
-import { resultsItem, resultsItemJsonSchema } from './Results.js';
+import { resultsItem } from './Results.js';
 import { preview } from './Preview.js';
 import { serializedSchemaOption } from './SchemaOptions.js';
-export const manifestEntry = z
-    .object({
-    lines: z.number(),
-    characters: z.number(),
-    destinationPath: z.string()
-})
-    .openapi('ManifestEntry');
-export const previewItem = z
-    .object({
-    name: z.string(),
-    exportPath: z.string()
-})
-    .openapi('PreviewItem');
-export const manifestContent = z
-    .object({
-    deploymentId: z.string(),
-    traceId: z.string(),
-    spanId: z.string(),
-    region: z.string().optional(),
-    files: z.record(manifestEntry),
-    previews: z.record(z.record(preview)),
-    results: resultsItem.openapi('ResultsItem', resultsItemJsonSchema),
-    startAt: z.number(),
-    endAt: z.number(),
-    schemaOptions: z.array(serializedSchemaOption)
-})
-    .openapi('ManifestContent');
+import * as v from 'valibot';
+export const manifestEntry = v.object({
+    lines: v.number(),
+    characters: v.number(),
+    destinationPath: v.string()
+});
+export const previewItem = v.object({
+    name: v.string(),
+    exportPath: v.string()
+});
+export const manifestContent = v.object({
+    deploymentId: v.string(),
+    traceId: v.string(),
+    spanId: v.string(),
+    region: v.optional(v.string()),
+    files: v.record(v.string(), manifestEntry),
+    previews: v.record(v.string(), v.record(v.string(), preview)),
+    results: resultsItem,
+    startAt: v.number(),
+    endAt: v.number(),
+    schemaOptions: v.array(serializedSchemaOption)
+});

package/esm/types/Method.d.ts

@@ -1,11 +1,9 @@
 import "../_dnt.polyfills.js";
-import { z } from '@hono/zod-openapi';
+import * as v from 'valibot';
 export declare const methodValues: readonly ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
 export declare const methodValuesNoTrace: string[];
-export declare const method: z.ZodType<Method>;
+export declare const method: 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>;
 export type Method = 'get' | 'put' | 'post' | 'delete' | 'options' | 'head' | 'patch' | 'trace';
-type Methods = Method[];
-export declare const methods: z.ZodType<Methods>;
+export declare const methods: v.ArraySchema<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>;
 export declare const isMethod: (arg: unknown) => arg is Method;
-export {};
 //# sourceMappingURL=Method.d.ts.map

package/esm/types/Method.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Method.d.ts","sourceRoot":"","sources":["../../src/types/Method.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAA;AAErC,eAAO,MAAM,YAAY,gFASf,CAAA;AAEV,eAAO,MAAM,mBAAmB,UAA+D,CAAA;AAE/F,eAAO,MAAM,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAEjB,CAAA;AAEpB,MAAM,MAAM,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAA;AAE/F,KAAK,OAAO,GAAG,MAAM,EAAE,CAAA;AAEvB,eAAO,MAAM,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAmB,CAAA;AAE1D,eAAO,MAAM,QAAQ,QAAS,OAAO,KAAG,GAAG,IAAI,MAE9C,CAAA"}
+{"version":3,"file":"Method.d.ts","sourceRoot":"","sources":["../../src/types/Method.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,eAAO,MAAM,YAAY,gFASf,CAAA;AAEV,eAAO,MAAM,mBAAmB,UAA+D,CAAA;AAE/F,eAAO,MAAM,MAAM,4RAQjB,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAA;AAI/F,eAAO,MAAM,OAAO,sTAAkB,CAAA;AAEtC,eAAO,MAAM,QAAQ,QAAS,OAAO,KAAG,GAAG,IAAI,MAE9C,CAAA"}

package/esm/types/Method.js

@@ -1,5 +1,5 @@
 import "../_dnt.polyfills.js";
-import { z } from '@hono/zod-openapi';
+import * as v from 'valibot';
 export const methodValues = [
     'get',
     'put',
@@ -11,10 +11,16 @@ export const methodValues = [
     'trace'
 ];
 export const methodValuesNoTrace = ['get', 'put', 'post', 'delete', 'options', 'head', 'patch'];
-export const method = z
-    .enum(['get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace'])
-    .openapi('Method');
-export const methods = z.array(method);
+export const method = v.union([
+    v.literal('get'),
+    v.literal('put'),
+    v.literal('post'),
+    v.literal('delete'),
+    v.literal('options'),
+    v.literal('head'),
+    v.literal('patch')
+]);
+export const methods = v.array(method);
 export const isMethod = (arg) => {
-    return method.safeParse(arg).success;
+    return v.safeParse(method, arg).success;
 };