@skmtc/core 0.0.599 → 0.0.601

package/esm/types/Preview.d.ts

@@ -1,7 +1,7 @@
 import "../_dnt.polyfills.js";
-import { z } from '@hono/zod-openapi';
 import { type Method } from './Method.js';
 import type { OasSchema } from '../oas/schema/Schema.js';
+import * as v from 'valibot';
 /** @deprecated */
 export type InputOption = {
     schema: OasSchema;
@@ -9,35 +9,21 @@ export type InputOption = {
     name?: string;
 };
 /** @deprecated */
-export declare const inputOption: 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;
-}>;
+export declare const inputOption: 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>;
 /** @deprecated */
 export type FormatterOption = {
     schema: OasSchema;
     label: string;
 };
 /** @deprecated */
-export declare const formatterOption: 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;
-}>;
+export declare const formatterOption: v.ObjectSchema<{
+    readonly schema: v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>;
+    readonly label: v.StringSchema<undefined>;
+}, undefined>;
 export type OperationPreview = {
     type: 'operation';
     generatorId: string;
@@ -61,141 +47,43 @@ export type Preview = {
     formatter?: FormatterOption;
     source: OperationPreview | ModelPreview;
 };
-export declare const operationPreview: z.ZodObject<{
-    type: z.ZodLiteral<"operation">;
-    generatorId: z.ZodString;
-    operationPath: z.ZodString;
-    operationMethod: z.ZodType<Method, z.ZodTypeDef, Method>;
-}, "strip", z.ZodTypeAny, {
-    type: "operation";
-    generatorId: string;
-    operationPath: string;
-    operationMethod: Method;
-}, {
-    type: "operation";
-    generatorId: string;
-    operationPath: string;
-    operationMethod: Method;
-}>;
-export declare const modelPreview: 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;
-}>;
-export declare const preview: z.ZodObject<{
-    name: z.ZodString;
-    exportPath: z.ZodString;
-    group: z.ZodString;
+export declare const operationPreview: 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>;
+export declare const modelPreview: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"model", undefined>;
+    readonly generatorId: v.StringSchema<undefined>;
+    readonly refName: v.StringSchema<undefined>;
+}, undefined>;
+export declare const preview: v.ObjectSchema<{
+    readonly name: v.StringSchema<undefined>;
+    readonly exportPath: v.StringSchema<undefined>;
+    readonly group: v.StringSchema<undefined>;
     /** @deprecated */
-    route: z.ZodOptional<z.ZodString>;
+    readonly route: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
     /** @deprecated */
-    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;
-    }>>;
+    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>;
     /** @deprecated */
-    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<Method, z.ZodTypeDef, Method>;
-    }, "strip", z.ZodTypeAny, {
-        type: "operation";
-        generatorId: string;
-        operationPath: string;
-        operationMethod: Method;
-    }, {
-        type: "operation";
-        generatorId: string;
-        operationPath: string;
-        operationMethod: 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: 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: 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;
-}>;
+    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>;
 //# sourceMappingURL=Preview.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Preview.d.ts","sourceRoot":"","sources":["../../src/types/Preview.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAA;AACrC,OAAO,EAAU,KAAK,MAAM,EAAE,MAAM,aAAa,CAAA;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAExD,kBAAkB;AAClB,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,SAAS,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED,kBAAkB;AAClB,eAAO,MAAM,WAAW;;;;;;;;;;;;EAItB,CAAA;AAEF,kBAAkB;AAClB,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,SAAS,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,kBAAkB;AAClB,eAAO,MAAM,eAAe;;;;;;;;;EAG1B,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,WAAW,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;IACnB,aAAa,EAAE,MAAM,CAAA;IACrB,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,OAAO,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,OAAO,GAAG;IACpB,IAAI,EAAE,MAAM,CAAA;IACZ,kBAAkB;IAClB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,kBAAkB;IAClB,KAAK,CAAC,EAAE,WAAW,CAAA;IACnB,kBAAkB;IAClB,SAAS,CAAC,EAAE,eAAe,CAAA;IAC3B,MAAM,EAAE,gBAAgB,GAAG,YAAY,CAAA;CACxC,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;EAK3B,CAAA;AAEF,eAAO,MAAM,YAAY;;;;;;;;;;;;EAIvB,CAAA;AAEF,eAAO,MAAM,OAAO;;;;IAKhB,kBAAkB;;IAElB,kBAAkB;;;;;;;;;;;;;;IAElB,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAID,CAAA"}
+{"version":3,"file":"Preview.d.ts","sourceRoot":"","sources":["../../src/types/Preview.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,EAAU,KAAK,MAAM,EAAE,MAAM,aAAa,CAAA;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACxD,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,kBAAkB;AAClB,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,SAAS,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED,kBAAkB;AAClB,eAAO,MAAM,WAAW;;;;aAItB,CAAA;AAEF,kBAAkB;AAClB,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,SAAS,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,kBAAkB;AAClB,eAAO,MAAM,eAAe;;;aAG1B,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,WAAW,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;IACnB,aAAa,EAAE,MAAM,CAAA;IACrB,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,OAAO,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,OAAO,GAAG;IACpB,IAAI,EAAE,MAAM,CAAA;IACZ,kBAAkB;IAClB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,kBAAkB;IAClB,KAAK,CAAC,EAAE,WAAW,CAAA;IACnB,kBAAkB;IAClB,SAAS,CAAC,EAAE,eAAe,CAAA;IAC3B,MAAM,EAAE,gBAAgB,GAAG,YAAY,CAAA;CACxC,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;aAK3B,CAAA;AAEF,eAAO,MAAM,YAAY;;;;aAIvB,CAAA;AAEF,eAAO,MAAM,OAAO;;;;IAIlB,kBAAkB;;IAElB,kBAAkB;;;;;;IAElB,kBAAkB;;;;;;;;;;;;;;;aAGlB,CAAA"}

package/esm/types/Preview.js

@@ -1,39 +1,37 @@
 import "../_dnt.polyfills.js";
-import { z } from '@hono/zod-openapi';
 import { method } from './Method.js';
+import * as v from 'valibot';
 /** @deprecated */
-export const inputOption = z.object({
-    schema: z.record(z.unknown()),
-    label: z.string(),
-    name: z.string().optional()
+export const inputOption = v.object({
+    schema: v.record(v.string(), v.unknown()),
+    label: v.string(),
+    name: v.optional(v.string())
 });
 /** @deprecated */
-export const formatterOption = z.object({
-    schema: z.record(z.unknown()),
-    label: z.string()
+export const formatterOption = v.object({
+    schema: v.record(v.string(), v.unknown()),
+    label: v.string()
 });
-export const operationPreview = z.object({
-    type: z.literal('operation'),
-    generatorId: z.string(),
-    operationPath: z.string(),
+export const operationPreview = v.object({
+    type: v.literal('operation'),
+    generatorId: v.string(),
+    operationPath: v.string(),
     operationMethod: method
 });
-export const modelPreview = z.object({
-    type: z.literal('model'),
-    generatorId: z.string(),
-    refName: z.string()
+export const modelPreview = v.object({
+    type: v.literal('model'),
+    generatorId: v.string(),
+    refName: v.string()
 });
-export const preview = z
-    .object({
-    name: z.string(),
-    exportPath: z.string(),
-    group: z.string(),
+export const preview = v.object({
+    name: v.string(),
+    exportPath: v.string(),
+    group: v.string(),
     /** @deprecated */
-    route: z.string().optional(),
+    route: v.optional(v.string()),
     /** @deprecated */
-    input: inputOption.optional(),
+    input: v.optional(inputOption),
     /** @deprecated */
-    formatter: formatterOption.optional(),
-    source: z.discriminatedUnion('type', [operationPreview, modelPreview])
-})
-    .openapi('Preview');
+    formatter: v.optional(formatterOption),
+    source: v.variant('type', [operationPreview, modelPreview])
+});

package/esm/types/Results.d.ts

@@ -1,16 +1,10 @@
 import "../_dnt.polyfills.js";
-import { z } from '@hono/zod-openapi';
+import * as v from 'valibot';
 export type ResultType = 'success' | 'warning' | 'error' | 'notSelected' | 'notSupported';
 export type WarningError = 'warning' | 'error';
-export declare const resultType: z.ZodEnum<["success", "warning", "error", "notSelected", "notSupported"]>;
+export declare const resultType: v.UnionSchema<[v.LiteralSchema<"success", undefined>, v.LiteralSchema<"warning", undefined>, v.LiteralSchema<"error", undefined>, v.LiteralSchema<"notSelected", undefined>, v.LiteralSchema<"notSupported", undefined>], undefined>;
 export interface ResultsItem {
     [key: string]: ResultType | ResultsItem | Array<ResultsItem | null>;
 }
-export declare const resultsItem: z.ZodType<ResultsItem>;
-export declare const resultsItemJsonSchema: object & {
-    $schema?: string | undefined;
-    definitions?: {
-        [key: string]: object;
-    } | undefined;
-};
+export declare const resultsItem: v.GenericSchema<ResultsItem>;
 //# sourceMappingURL=Results.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Results.d.ts","sourceRoot":"","sources":["../../src/types/Results.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAA;AAGrC,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,aAAa,GAAG,cAAc,CAAA;AAEzF,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,OAAO,CAAA;AAE9C,eAAO,MAAM,UAAU,2EAAyE,CAAA;AAEhG,MAAM,WAAW,WAAW;IAC1B,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,KAAK,CAAC,WAAW,GAAG,IAAI,CAAC,CAAA;CACpE;AAED,eAAO,MAAM,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAE9C,CAAA;AAED,eAAO,MAAM,qBAAqB;;;;;CAIhC,CAAA"}
+{"version":3,"file":"Results.d.ts","sourceRoot":"","sources":["../../src/types/Results.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,aAAa,GAAG,cAAc,CAAA;AAEzF,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,OAAO,CAAA;AAE9C,eAAO,MAAM,UAAU,sOAMrB,CAAA;AAEF,MAAM,WAAW,WAAW;IAC1B,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,KAAK,CAAC,WAAW,GAAG,IAAI,CAAC,CAAA;CACpE;AAED,eAAO,MAAM,WAAW,EAAE,CAAC,CAAC,aAAa,CAAC,WAAW,CAGpD,CAAA"}

package/esm/types/Results.js

@@ -1,10 +1,10 @@
 import "../_dnt.polyfills.js";
-import { z } from '@hono/zod-openapi';
-import { zodToJsonSchema } from 'zod-to-json-schema';
-export const resultType = z.enum(['success', 'warning', 'error', 'notSelected', 'notSupported']);
-export const resultsItem = z.record(z.lazy(() => z.union([resultsItem, resultType, z.array(resultsItem.nullable())])));
-export const resultsItemJsonSchema = zodToJsonSchema(resultsItem, {
-    basePath: [`#/components/schemas/ResultsItem`],
-    target: 'openApi3',
-    strictUnions: true
-});
+import * as v from 'valibot';
+export const resultType = v.union([
+    v.literal('success'),
+    v.literal('warning'),
+    v.literal('error'),
+    v.literal('notSelected'),
+    v.literal('notSupported')
+]);
+export const resultsItem = v.record(v.string(), v.lazy(() => v.union([resultsItem, resultType, v.array(v.lazy(() => resultsItem))])));

package/esm/types/SchemaOptions.d.ts

@@ -1,6 +1,6 @@
 import "../_dnt.polyfills.js";
-import { z } from '@hono/zod-openapi';
 import type { OasSchema } from '../oas/schema/Schema.js';
+import * as v from 'valibot';
 export type SchemaOption = {
     type: 'input' | 'formatter';
     name: string;
@@ -10,38 +10,16 @@ export type SchemaOption = {
     };
     exportPath: string;
 };
-export declare const schemaOption: z.ZodObject<{
-    type: z.ZodEnum<["input", "formatter"]>;
-    name: z.ZodString;
-    matchBy: z.ZodObject<{
-        schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        name: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        schema: Record<string, unknown>;
-        name?: string | undefined;
-    }, {
-        schema: Record<string, unknown>;
-        name?: string | undefined;
-    }>;
-    exportPath: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    type: "input" | "formatter";
-    exportPath: string;
-    matchBy: {
-        schema: Record<string, unknown>;
-        name?: string | undefined;
-    };
-}, {
-    name: string;
-    type: "input" | "formatter";
-    exportPath: string;
-    matchBy: {
-        schema: Record<string, unknown>;
-        name?: string | undefined;
-    };
-}>;
-export declare const serializedSchema: z.ZodType<SerializedSchema>;
+export declare const schemaOption: v.ObjectSchema<{
+    readonly type: v.UnionSchema<[v.LiteralSchema<"input", undefined>, v.LiteralSchema<"formatter", undefined>], undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly matchBy: v.ObjectSchema<{
+        readonly schema: v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>;
+        readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>;
+    readonly exportPath: v.StringSchema<undefined>;
+}, undefined>;
+export declare const serializedSchema: v.GenericSchema<SerializedSchema>;
 export type SerializedSchema = {
     type: 'object';
     properties?: Record<string, SerializedSchema>;
@@ -59,37 +37,15 @@ export type SerializedSchema = {
 } | {
     type: 'boolean';
 };
-export declare const serializedSchemaOption: z.ZodObject<{
-    type: z.ZodEnum<["input", "formatter"]>;
-    name: z.ZodString;
-    exportPath: z.ZodString;
-    matchBy: z.ZodObject<{
-        schema: z.ZodType<SerializedSchema, z.ZodTypeDef, SerializedSchema>;
-        name: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        schema: SerializedSchema;
-        name?: string | undefined;
-    }, {
-        schema: SerializedSchema;
-        name?: string | undefined;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    type: "input" | "formatter";
-    exportPath: string;
-    matchBy: {
-        schema: SerializedSchema;
-        name?: string | undefined;
-    };
-}, {
-    name: string;
-    type: "input" | "formatter";
-    exportPath: string;
-    matchBy: {
-        schema: SerializedSchema;
-        name?: string | undefined;
-    };
-}>;
+export declare const serializedSchemaOption: 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<SerializedSchema>;
+        readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>;
+}, undefined>;
 export type SerializedSchemaOption = {
     type: 'input' | 'formatter';
     name: string;

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

@@ -1 +1 @@
-{"version":3,"file":"SchemaOptions.d.ts","sourceRoot":"","sources":["../../src/types/SchemaOptions.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAA;AACrC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAExD,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,OAAO,GAAG,WAAW,CAAA;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE;QACP,MAAM,EAAE,SAAS,CAAA;QACjB,IAAI,CAAC,EAAE,MAAM,CAAA;KACd,CAAA;IACD,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQvB,CAAA;AAEF,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,OAAO,CAAC,gBAAgB,CAwBvD,CAAA;AAEF,MAAM,MAAM,gBAAgB,GACxB;IACE,IAAI,EAAE,QAAQ,CAAA;IACd,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAA;CAC9C,GACD;IACE,IAAI,EAAE,QAAQ,CAAA;CACf,GACD;IACE,IAAI,EAAE,QAAQ,CAAA;CACf,GACD;IACE,IAAI,EAAE,SAAS,CAAA;CAChB,GACD;IACE,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,gBAAgB,CAAA;CACxB,GACD;IACE,IAAI,EAAE,SAAS,CAAA;CAChB,GACD;IACE,IAAI,EAAE,SAAS,CAAA;CAChB,CAAA;AAEL,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQjC,CAAA;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,EAAE,OAAO,GAAG,WAAW,CAAA;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE;QACP,MAAM,EAAE,gBAAgB,CAAA;QACxB,IAAI,CAAC,EAAE,MAAM,CAAA;KACd,CAAA;CACF,CAAA"}
+{"version":3,"file":"SchemaOptions.d.ts","sourceRoot":"","sources":["../../src/types/SchemaOptions.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACxD,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,OAAO,GAAG,WAAW,CAAA;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE;QACP,MAAM,EAAE,SAAS,CAAA;QACjB,IAAI,CAAC,EAAE,MAAM,CAAA;KACd,CAAA;IACD,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,eAAO,MAAM,YAAY;;;;;;;;aAQvB,CAAA;AAEF,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,aAAa,CAAC,gBAAgB,CA6B7D,CAAA;AAEF,MAAM,MAAM,gBAAgB,GACxB;IACE,IAAI,EAAE,QAAQ,CAAA;IACd,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAA;CAC9C,GACD;IACE,IAAI,EAAE,QAAQ,CAAA;CACf,GACD;IACE,IAAI,EAAE,QAAQ,CAAA;CACf,GACD;IACE,IAAI,EAAE,SAAS,CAAA;CAChB,GACD;IACE,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,gBAAgB,CAAA;CACxB,GACD;IACE,IAAI,EAAE,SAAS,CAAA;CAChB,GACD;IACE,IAAI,EAAE,SAAS,CAAA;CAChB,CAAA;AAEL,eAAO,MAAM,sBAAsB;;;;;;;;aAQjC,CAAA;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,EAAE,OAAO,GAAG,WAAW,CAAA;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE;QACP,MAAM,EAAE,gBAAgB,CAAA;QACxB,IAAI,CAAC,EAAE,MAAM,CAAA;KACd,CAAA;CACF,CAAA"}

package/esm/types/SchemaOptions.js

@@ -1,45 +1,45 @@
 import "../_dnt.polyfills.js";
-import { z } from '@hono/zod-openapi';
-export const schemaOption = z.object({
-    type: z.enum(['input', 'formatter']),
-    name: z.string(),
-    matchBy: z.object({
-        schema: z.record(z.unknown()),
-        name: z.string().optional()
+import * as v from 'valibot';
+export const schemaOption = v.object({
+    type: v.union([v.literal('input'), v.literal('formatter')]),
+    name: v.string(),
+    matchBy: v.object({
+        schema: v.record(v.string(), v.unknown()),
+        name: v.optional(v.string())
     }),
-    exportPath: z.string()
+    exportPath: v.string()
 });
-export const serializedSchema = z.union([
-    z.object({
-        type: z.literal('object'),
-        properties: z.lazy(() => z.record(serializedSchema)).optional()
+export const serializedSchema = v.union([
+    v.object({
+        type: v.literal('object'),
+        properties: v.optional(v.record(v.string(), v.lazy(() => serializedSchema)))
     }),
-    z.object({
-        type: z.literal('string')
+    v.object({
+        type: v.literal('string')
     }),
-    z.object({
-        type: z.literal('number')
+    v.object({
+        type: v.literal('number')
     }),
-    z.object({
-        type: z.literal('boolean')
+    v.object({
+        type: v.literal('boolean')
     }),
-    z.object({
-        type: z.literal('array'),
-        items: z.lazy(() => serializedSchema)
+    v.object({
+        type: v.literal('array'),
+        items: v.lazy(() => serializedSchema)
     }),
-    z.object({
-        type: z.literal('integer')
+    v.object({
+        type: v.literal('integer')
     }),
-    z.object({
-        type: z.literal('integer')
+    v.object({
+        type: v.literal('integer')
     })
 ]);
-export const serializedSchemaOption = z.object({
-    type: z.enum(['input', 'formatter']),
-    name: z.string(),
-    exportPath: z.string(),
-    matchBy: z.object({
+export const serializedSchemaOption = v.object({
+    type: v.union([v.literal('input'), v.literal('formatter')]),
+    name: v.string(),
+    exportPath: v.string(),
+    matchBy: v.object({
         schema: serializedSchema,
-        name: z.string().optional()
+        name: v.optional(v.string())
     })
 });