vona-module-a-openapi 5.0.29 → 5.0.31

package/dist/.metadata/index.d.ts

@@ -55,178 +55,17 @@ export interface IModuleSummerCache {
 /** config: begin */
 export * from '../config/config.ts';
 import type { config } from '../config/config.ts';
-export declare const locales: {
-    'en-us': {
-        ZodError_invalid_input: string;
-        ZodError_invalid_type_required: string;
-        ZodError_invalid_type_requiredDetail: string;
-        ZodError_invalid_literal: string;
-        ZodError_unrecognized_keys: string;
-        ZodError_invalid_union: string;
-        ZodError_invalid_union_discriminator: string;
-        ZodError_invalid_enum_value: string;
-        ZodError_invalid_arguments: string;
-        ZodError_invalid_return_type: string;
-        ZodError_invalid_date: string;
-        ZodError_invalid_string_includes: string;
-        ZodError_invalid_string_includes_position: string;
-        ZodError_invalid_string_startsWith: string;
-        ZodError_invalid_string_endsWith: string;
-        ZodError_invalid_string_validation: string;
-        ZodError_invalid_string: string;
-        ZodError_too_small_array_exact: string;
-        ZodError_too_small_array_inclusive: string;
-        ZodError_too_small_array_not_inclusive: string;
-        ZodError_too_small_string_exact: string;
-        ZodError_too_small_string_inclusive: string;
-        ZodError_too_small_string_not_inclusive: string;
-        ZodError_too_small_number_exact: string;
-        ZodError_too_small_number_inclusive: string;
-        ZodError_too_small_number_not_inclusive: string;
-        ZodError_too_small_set_exact: string;
-        ZodError_too_small_set_inclusive: string;
-        ZodError_too_small_set_not_inclusive: string;
-        ZodError_too_small_date_exact: string;
-        ZodError_too_small_date_inclusive: string;
-        ZodError_too_small_date_not_inclusive: string;
-        ZodError_too_big_array_exact: string;
-        ZodError_too_big_array_inclusive: string;
-        ZodError_too_big_array_not_inclusive: string;
-        ZodError_too_big_string_exact: string;
-        ZodError_too_big_string_inclusive: string;
-        ZodError_too_big_string_not_inclusive: string;
-        ZodError_too_big_number_exact: string;
-        ZodError_too_big_number_inclusive: string;
-        ZodError_too_big_number_not_inclusive: string;
-        ZodError_too_big_set_exact: string;
-        ZodError_too_big_set_inclusive: string;
-        ZodError_too_big_set_not_inclusive: string;
-        ZodError_too_big_date_exact: string;
-        ZodError_too_big_date_inclusive: string;
-        ZodError_too_big_date_not_inclusive: string;
-        ZodError_custom: string;
-        ZodError_invalid_intersection_types: string;
-        ZodError_not_multiple_of: string;
-        ZodError_not_finite: string;
-        ZodError_validations_email: string;
-        ZodError_validations_url: string;
-        ZodError_validations_uuid: string;
-        ZodError_validations_cuid: string;
-        ZodError_validations_regex: string;
-        ZodError_validations_datetime: string;
-        ZodError_types_function: string;
-        ZodError_types_number: string;
-        ZodError_types_string: string;
-        ZodError_types_nan: string;
-        ZodError_types_integer: string;
-        ZodError_types_float: string;
-        ZodError_types_boolean: string;
-        ZodError_types_date: string;
-        ZodError_types_bigint: string;
-        ZodError_types_undefined: string;
-        ZodError_types_symbol: string;
-        ZodError_types_null: string;
-        ZodError_types_array: string;
-        ZodError_types_object: string;
-        ZodError_types_unknown: string;
-        ZodError_types_promise: string;
-        ZodError_types_void: string;
-        ZodError_types_never: string;
-        ZodError_types_map: string;
-        ZodError_types_set: string;
-    };
-    'zh-cn': {
-        ZodError_invalid_input: string;
-        ZodError_invalid_type_required: string;
-        ZodError_invalid_type_requiredDetail: string;
-        ZodError_invalid_literal: string;
-        ZodError_unrecognized_keys: string;
-        ZodError_invalid_union: string;
-        ZodError_invalid_union_discriminator: string;
-        ZodError_invalid_enum_value: string;
-        ZodError_invalid_arguments: string;
-        ZodError_invalid_return_type: string;
-        ZodError_invalid_date: string;
-        ZodError_invalid_string_includes: string;
-        ZodError_invalid_string_includes_position: string;
-        ZodError_invalid_string_startsWith: string;
-        ZodError_invalid_string_endsWith: string;
-        ZodError_invalid_string_validation: string;
-        ZodError_invalid_string: string;
-        ZodError_too_small_array_exact: string;
-        ZodError_too_small_array_inclusive: string;
-        ZodError_too_small_array_not_inclusive: string;
-        ZodError_too_small_string_exact: string;
-        ZodError_too_small_string_inclusive: string;
-        ZodError_too_small_string_not_inclusive: string;
-        ZodError_too_small_number_exact: string;
-        ZodError_too_small_number_inclusive: string;
-        ZodError_too_small_number_not_inclusive: string;
-        ZodError_too_small_set_exact: string;
-        ZodError_too_small_set_inclusive: string;
-        ZodError_too_small_set_not_inclusive: string;
-        ZodError_too_small_date_exact: string;
-        ZodError_too_small_date_inclusive: string;
-        ZodError_too_small_date_not_inclusive: string;
-        ZodError_too_big_array_exact: string;
-        ZodError_too_big_array_inclusive: string;
-        ZodError_too_big_array_not_inclusive: string;
-        ZodError_too_big_string_exact: string;
-        ZodError_too_big_string_inclusive: string;
-        ZodError_too_big_string_not_inclusive: string;
-        ZodError_too_big_number_exact: string;
-        ZodError_too_big_number_inclusive: string;
-        ZodError_too_big_number_not_inclusive: string;
-        ZodError_too_big_set_exact: string;
-        ZodError_too_big_set_inclusive: string;
-        ZodError_too_big_set_not_inclusive: string;
-        ZodError_too_big_date_exact: string;
-        ZodError_too_big_date_inclusive: string;
-        ZodError_too_big_date_not_inclusive: string;
-        ZodError_custom: string;
-        ZodError_invalid_intersection_types: string;
-        ZodError_not_multiple_of: string;
-        ZodError_not_finite: string;
-        ZodError_validations_email: string;
-        ZodError_validations_url: string;
-        ZodError_validations_uuid: string;
-        ZodError_validations_cuid: string;
-        ZodError_validations_regex: string;
-        ZodError_validations_datetime: string;
-        ZodError_types_function: string;
-        ZodError_types_number: string;
-        ZodError_types_string: string;
-        ZodError_types_nan: string;
-        ZodError_types_integer: string;
-        ZodError_types_float: string;
-        ZodError_types_boolean: string;
-        ZodError_types_date: string;
-        ZodError_types_bigint: string;
-        ZodError_types_undefined: string;
-        ZodError_types_symbol: string;
-        ZodError_types_null: string;
-        ZodError_types_array: string;
-        ZodError_types_object: string;
-        ZodError_types_unknown: string;
-        ZodError_types_promise: string;
-        ZodError_types_void: string;
-        ZodError_types_never: string;
-        ZodError_types_map: string;
-        ZodError_types_set: string;
-    };
-};
-/** locale: end */
+/** config: end */
 /** main: begin */
 export * from '../main.ts';
 /** main: end */
 /** scope: begin */
-import { BeanScopeBase, type BeanScopeUtil, type TypeModuleConfig, type TypeModuleLocales, type TypeLocaleBase } from 'vona';
+import { BeanScopeBase, type BeanScopeUtil, type TypeModuleConfig } from 'vona';
 export declare class ScopeModuleAOpenapi extends BeanScopeBase {
 }
 export interface ScopeModuleAOpenapi {
     util: BeanScopeUtil;
     config: TypeModuleConfig<typeof config>;
-    locale: TypeModuleLocales<(typeof locales)[TypeLocaleBase]>;
     service: IModuleService;
     summerCache: IModuleSummerCache;
 }
@@ -241,9 +80,5 @@ declare module 'vona' {
     interface IBeanScopeConfig {
         'a-openapi': ReturnType<typeof config>;
     }
-    interface IBeanScopeLocale {
-        'a-openapi': (typeof locales)[TypeLocaleBase];
-    }
 }
-export declare function $locale<K extends keyof (typeof locales)[TypeLocaleBase]>(key: K): `a-openapi::${K}`;
 /** scope: end */

package/dist/config/config.d.ts

@@ -1,5 +1,5 @@
-import type { OpenAPIObjectConfig as OpenAPIObjectConfigV30 } from '@asteasolutions/zod-to-openapi/dist/v3.0/openapi-generator.ts';
-import type { OpenAPIObjectConfigV31 } from '@asteasolutions/zod-to-openapi/dist/v3.1/openapi-generator.ts';
+import type { OpenAPIObjectConfig as OpenAPIObjectConfigV30 } from '@cabloy/zod-to-openapi/dist/v3.0/openapi-generator.ts';
+import type { OpenAPIObjectConfigV31 } from '@cabloy/zod-to-openapi/dist/v3.1/openapi-generator.ts';
 import type { VonaApplication } from 'vona';
 import type { TypeOpenApiVersion, TypeSecuritySchemes } from 'vona-module-a-openapiutils';
 export declare function config(_app: VonaApplication): {

package/dist/index.js

@@ -1,16 +1,16 @@
-import { registerMappedClassMetadataKey, appMetadata, appResource, cast, deepExtend, BeanInfo, BeanBase, LocaleModuleNameSeparator, HttpStatus, BeanSimple, BeanScopeBase, useApp } from 'vona';
-import { OpenApiGeneratorV3, OpenApiGeneratorV31, OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import { registerMappedClassMetadataKey, appMetadata, appResource, cast, deepExtend, BeanInfo, BeanBase, LocaleModuleNameSeparator, HttpStatus, BeanSimple, BeanScopeBase, useApp, beanFullNameFromOnionName } from 'vona';
 import * as ModuleInfo from '@cabloy/module-info';
 import { isClass, isEmptyObject, isNil } from '@cabloy/utils';
 import { toUpperCaseFirstChar } from '@cabloy/word-utils';
-import { getTypeName, ZodMetadata, coerceWithNil } from '@cabloy/zod-query';
+import { getInnerTypeName, coerceWithNil } from '@cabloy/zod-query';
+import { OpenApiGeneratorV3, OpenApiGeneratorV31, OpenAPIRegistry } from '@cabloy/zod-to-openapi';
 import { Service, Scope } from 'vona-module-a-bean';
 import { Caching } from 'vona-module-a-caching';
 import { SymbolDecoratorRule, SymbolDecoratorRuleColumn, SymbolOpenApiOptions } from 'vona-module-a-openapiutils';
 import { SymbolRequestMappingHandler } from 'vona-module-a-web';
 import { z } from 'zod';
+import { ZodMetadata } from '@cabloy/zod-openapi';
 import { SummerCache, BeanSummerCacheBase } from 'vona-module-a-summer';
-import { locales as locales$1, setErrorMapDefault, setErrorMapSchema } from '@cabloy/zod-errors-custom';
 import 'openapi3-ts/oas30';
 import 'openapi3-ts/oas31';
 
@@ -54,13 +54,15 @@ function mergeFieldsOpenapiMetadata(target) {
     const field = fields[key];
     if (!field) continue;
     const schemaCurrent = rules[key];
+    const metadataCurrent = schemaCurrent ? ZodMetadata.getOpenapiMetadata(schemaCurrent) : undefined;
     if (Object.prototype.hasOwnProperty.call(field, 'parseAsync')) {
       const schema = field;
-      rules[key] = schema.openapi(deepExtend({}, schemaCurrent?._def.openapi?.metadata, schema._def.openapi?.metadata));
+      const metadataCustom = ZodMetadata.getOpenapiMetadata(schema);
+      rules[key] = schema.openapi(deepExtend({}, metadataCurrent, metadataCustom));
     } else {
       // use deepExtend for sure strict
       if (schemaCurrent) {
-        rules[key] = schemaCurrent.openapi(deepExtend({}, schemaCurrent._def.openapi?.metadata, field));
+        rules[key] = schemaCurrent.openapi(deepExtend({}, metadataCurrent, field));
       } else {
         rules[key] = z.any().openapi(deepExtend({}, field));
       }
@@ -72,6 +74,7 @@ function prepareClassType(classType) {
 }
 
 function makeSchemaLikes(schemaLikes, typeInit) {
+  if (!Array.isArray(schemaLikes)) schemaLikes = [schemaLikes];
   // default schema
   let argSchema = $schema(typeInit);
   // loop
@@ -133,6 +136,10 @@ function $schema(classType, options) {
     // static
     const beanOptions = appResource.getBean(classType);
     if (beanOptions) {
+      const pipes = cast(beanOptions.options)?.pipes;
+      if (pipes) {
+        schema = makeSchemaLikes(pipes, schema);
+      }
       const openapi = cast(beanOptions.options)?.openapi;
       schema = schema.openapi(beanOptions.beanFullName, openapi);
     }
@@ -152,8 +159,8 @@ function _createSchemaLazy(schemaLikes) {
 }
 function _createSchemaObject(rules, options) {
   let schema = z.object(rules);
-  if (options?.passthrough) schema = schema.passthrough();
-  if (options?.strict) schema = schema.strict();
+  if (options?.loose) schema = z.looseObject(schema.shape);
+  if (options?.strict) schema = z.strictObject(schema.shape);
   return schema;
 }
 
@@ -381,6 +388,7 @@ let ServiceOpenapi = (_dec$2 = Service(), _dec2$2 = BeanInfo({
     const argsMapIsolate = {};
     let isUpload;
     for (const argMeta of argsMeta) {
+      if (!argMeta) continue;
       if (!__ArgumentTypes.includes(argMeta.type)) continue;
       if (['fields', 'field', 'files', 'file'].includes(argMeta.type)) {
         isUpload = true;
@@ -428,7 +436,7 @@ let ServiceOpenapi = (_dec$2 = Service(), _dec2$2 = BeanInfo({
         }
         if (!schema) continue;
         // check schema
-        if (getTypeName(schema) === 'ZodAny') {
+        if (getInnerTypeName(schema) === 'any') {
           throw new Error(`Invalid Openapi argument type: ${info.relativeName}:${controller.name}.${actionKey}#${argumentType}`);
         }
         // record
@@ -565,19 +573,6 @@ function config(_app) {
   };
 }
 
-var locale_en_us = locales$1['en-us'];
-
-var locale_zh_cn = locales$1['zh-cn'];
-
-function errorsAdapter(app) {
-  setErrorMapDefault((text, ...args) => {
-    return app.meta.text(text, ...args);
-  });
-  setErrorMapSchema((text, ...args) => {
-    return app.meta.text(text, ...args);
-  });
-}
-
 function schemaRefCustomAdapter(_app) {
   const registry = new OpenAPIRegistry();
   const generator31 = new OpenApiGeneratorV31(registry.definitions);
@@ -609,26 +604,19 @@ function _patchGenerator(generator) {
 class Main extends BeanSimple {
   async moduleLoading() {}
   async moduleLoaded() {
-    errorsAdapter(this.app);
     schemaRefCustomAdapter(this.app);
   }
   async configLoaded(_config) {}
 }
 
 var _dec, _dec2, _class;
-const locales = {
-  'en-us': locale_en_us,
-  'zh-cn': locale_zh_cn
-};
 let ScopeModuleAOpenapi = (_dec = Scope(), _dec2 = BeanInfo({
   module: "a-openapi"
 }), _dec(_class = _dec2(_class = class ScopeModuleAOpenapi extends BeanScopeBase {}) || _class) || _class);
-function $locale(key) {
-  return `a-openapi::${key}`;
-}
+
 /** scope: end */
 
-function Field$1(...schemaLikes) {
+function Field(...schemaLikes) {
   return function (target, prop) {
     // rules
     const rules = getTargetDecoratorRules(target);
@@ -721,7 +709,7 @@ function setHeader(field, val) {
   };
 }
 const Api = {
-  field: Field$1,
+  field: Field,
   httpCode,
   contentType,
   body,
@@ -733,107 +721,77 @@ const Api = {
   setHeader
 };
 
-function createPipesArgumentDecorator(paramType, extractValue) {
-  return function (field, ...schemaLikes) {
-    return function (target, prop, index) {
-      // not inherit
-      const argsMeta = appMetadata.getOwnMetadataArray(false, SymbolRouteHandlersArgumentsMeta, target, prop);
-      const hasParamField = typeof field === 'string';
-      const paramField = hasParamField ? field : undefined;
-      const paramSchemaLikes = hasParamField ? schemaLikes : [field, ...schemaLikes].filter(item => !!item);
-      const paramtypes = appMetadata.getMetadata('design:paramtypes', target, prop);
-      let metaType;
-      if (paramType === 'file') {
-        metaType = z.string().openapi({
-          format: 'binary'
-        });
-      } else if (paramType === 'files') {
-        metaType = z.array(z.string().openapi({
-          format: 'binary'
-        }));
-      } else {
-        metaType = paramtypes[index];
-      }
-      const argSchema = makeSchemaLikes(paramSchemaLikes, metaType);
-      argsMeta.push({
-        index,
-        type: paramType,
-        field: paramField,
-        pipes: [argSchema],
-        schema: argSchema,
-        extractValue
-      });
-    };
+function schemaEmail(params) {
+  return function (_schema) {
+    return z.email(params);
   };
 }
-
-function Param(property, ...schemaLikes) {
-  return createPipesArgumentDecorator('param')(property, ...schemaLikes);
-}
-function Query(property, ...schemaLikes) {
-  return createPipesArgumentDecorator('query')(property, ...schemaLikes);
-}
-function Body(property, ...schemaLikes) {
-  return createPipesArgumentDecorator('body')(property, ...schemaLikes);
-}
-function Headers(property, ...schemaLikes) {
-  return createPipesArgumentDecorator('headers')(property, ...schemaLikes);
+function schemaUrl(params) {
+  return function (_schema) {
+    return z.url(params);
+  };
 }
-function Fields(property, ...schemaLikes) {
-  return createPipesArgumentDecorator('fields')(property, ...schemaLikes);
+function schemaUuid(params) {
+  return function (_schema) {
+    return z.uuid(params);
+  };
 }
-function Field(property, ...schemaLikes) {
-  return createPipesArgumentDecorator('field')(property, ...schemaLikes);
+function schemaIPv4(params) {
+  return function (_schema) {
+    return z.ipv4(params);
+  };
 }
-function Files(property, ...schemaLikes) {
-  return createPipesArgumentDecorator('files')(property, ...schemaLikes);
+function schemaIPv6(params) {
+  return function (_schema) {
+    return z.ipv6(params);
+  };
 }
-function File(property, ...schemaLikes) {
-  return createPipesArgumentDecorator('file')(property, ...schemaLikes);
+function schemaMin(min, params) {
+  return function (schema) {
+    if (schema.type === 'string') {
+      return schema.min(min, params);
+    } else {
+      return schema.min(min, params);
+    }
+  };
 }
-function User(...schemaLikes) {
-  return createPipesArgumentDecorator('user')(undefined, ...schemaLikes);
+function schemaMax(max, params) {
+  return function (schema) {
+    if (schema.type === 'string') {
+      return schema.max(max, params);
+    } else {
+      return schema.max(max, params);
+    }
+  };
 }
-const Arg = {
-  param: Param,
-  query: Query,
-  body: Body,
-  headers: Headers,
-  fields: Fields,
-  field: Field,
-  files: Files,
-  file: File,
-  user: User
-};
-
-function schemaEmail(message) {
+function schemaTrim() {
   return function (schema) {
-    return schema.email(message);
+    return schema.trim();
   };
 }
-function schemaUrl(message) {
+function schemaToLowerCase() {
   return function (schema) {
-    return schema.url(message);
+    return schema.toLowerCase();
   };
 }
-function schemaUuid(message) {
+function schemaToUpperCase() {
   return function (schema) {
-    return schema.uuid(message);
+    return schema.toUpperCase();
   };
 }
-function schemaIp(options) {
+function schemaLowercase(params) {
   return function (schema) {
-    return schema.ip(options);
+    return schema.lowercase(params);
   };
 }
-function schemaMin(min, message) {
+function schemaUppercase(params) {
   return function (schema) {
-    return schema.min(min, message);
+    return schema.uppercase(params);
   };
 }
-function schemaMax(max, message) {
+function schemaRegex(regex, params) {
   return function (schema) {
-    return schema.max(max, message);
+    return schema.regex(regex, params);
   };
 }
 function schemaTableIdentity() {
@@ -854,6 +812,13 @@ function schemaBigNumber() {
     return z.union([z.string(), z.number()]);
   };
 }
+function schemaCaptcha(options) {
+  return function (schema) {
+    return schema.openapi({
+      captcha: options
+    });
+  };
+}
 
 function schemaOpenapi(refId, metadata) {
   return function (schema) {
@@ -908,13 +873,54 @@ function schemaArray(schemaLike, params) {
       val = coerceWithNil(val);
       if (isNil(val)) return val;
       if (typeof val !== 'string') return val;
-      if (isNil(params?.separator) && val[0] === '[') return JSON.parse(val);
+      if (val.startsWith('[') && val.endsWith(']')) return JSON.parse(val);
       return val.split(params?.separator ?? ',');
     }, z.array(makeSchemaLike(schemaLike ?? schema, z.any()), params)
     // z.array(makeSchemaLike(schemaLike, schema), params),
     );
   };
 }
+function schemaStrictObject() {
+  return function (schema) {
+    return z.strictObject(schema.shape);
+  };
+}
+function schemaLooseObject() {
+  return function (schema) {
+    return z.looseObject(schema.shape);
+  };
+}
+
+function schemaZodRefine(zodRefineName, options) {
+  return function (schema) {
+    return schema.superRefine(async (value, refinementCtx) => {
+      const app = useApp();
+      const options2 = app.bean.onion.zodRefine.getOnionOptionsDynamic(zodRefineName, options);
+      // execute
+      const beanFullName = beanFullNameFromOnionName(zodRefineName, 'zodRefine');
+      const beanInstance = app.bean._getBean(beanFullName);
+      if (!beanInstance) {
+        throw new Error(`zodRefine bean not found: ${beanFullName}`);
+      }
+      return await beanInstance.execute(value, refinementCtx, options2);
+    });
+  };
+}
+function schemaZodTransform(zodTransformName, options) {
+  return function (schema) {
+    return schema.transform(async value => {
+      const app = useApp();
+      const options2 = app.bean.onion.zodTransform.getOnionOptionsDynamic(zodTransformName, options);
+      // execute
+      const beanFullName = beanFullNameFromOnionName(zodTransformName, 'zodTransform');
+      const beanInstance = app.bean._getBean(beanFullName);
+      if (!beanInstance) {
+        throw new Error(`zodTransform bean not found: ${beanFullName}`);
+      }
+      return await beanInstance.execute(value, options2);
+    });
+  };
+}
 
 const v = {
   lazy: schemaLazy,
@@ -922,20 +928,33 @@ const v = {
   default: schemaDefault,
   object: schemaObject,
   optional: schemaOptional,
+  strictObject: schemaStrictObject,
+  looseObject: schemaLooseObject,
   // helpers
   email: schemaEmail,
   url: schemaUrl,
   uuid: schemaUuid,
-  ip: schemaIp,
+  ipv4: schemaIPv4,
+  ipv6: schemaIPv6,
   min: schemaMin,
   max: schemaMax,
+  trim: schemaTrim,
+  toLowerCase: schemaToLowerCase,
+  toUpperCase: schemaToUpperCase,
+  lowercase: schemaLowercase,
+  uppercase: schemaUppercase,
+  regex: schemaRegex,
   tableIdentity: schemaTableIdentity,
   bigNumber: schemaBigNumber,
+  captcha: schemaCaptcha,
   // openapi
   openapi: schemaOpenapi,
   title: schemaTitle,
   description: schemaDescription,
-  example: schemaExample
+  example: schemaExample,
+  // zod
+  refine: schemaZodRefine,
+  transform: schemaZodTransform
 };
 
 const OrderCoreBase = 100;
@@ -943,4 +962,4 @@ const OrderBusinessBase = 1000;
 const OrderUnknownBase = 10000;
 const OrderMaxBase = 100000;
 
-export { $locale, $schema, $schemaLazy, Api, Arg, Main, OrderBusinessBase, OrderCoreBase, OrderMaxBase, OrderUnknownBase, ScopeModuleAOpenapi, ServiceOpenapi, SummerCacheJson, SymbolRouteHandlersArgumentsMeta, SymbolRouteHandlersArgumentsValue, SymbolSchemaDynamicRefId, addSchemaDynamic, bodySchemaWrapperDefault, config, createPipesArgumentDecorator, errorsAdapter, getSchemaDynamic, getSchemasDynamic, getTargetDecoratorRuleColumns, getTargetDecoratorRules, locales, makeSchemaLike, makeSchemaLikes, mergeFieldsOpenapiMetadata, prepareClassType, schemaRefCustomAdapter, v };
+export { $schema, $schemaLazy, Api, Main, OrderBusinessBase, OrderCoreBase, OrderMaxBase, OrderUnknownBase, ScopeModuleAOpenapi, ServiceOpenapi, SummerCacheJson, SymbolRouteHandlersArgumentsMeta, SymbolRouteHandlersArgumentsValue, SymbolSchemaDynamicRefId, addSchemaDynamic, bodySchemaWrapperDefault, config, getSchemaDynamic, getSchemasDynamic, getTargetDecoratorRuleColumns, getTargetDecoratorRules, makeSchemaLike, makeSchemaLikes, mergeFieldsOpenapiMetadata, prepareClassType, schemaRefCustomAdapter, v };

package/dist/lib/decorator/index.d.ts

@@ -1,3 +1 @@
 export * from './api.ts';
-export * from './arguments.ts';
-export * from './pipesArgument.ts';

package/dist/lib/schema/bodySchemaWrapper.d.ts

@@ -3,12 +3,4 @@ export declare function bodySchemaWrapperDefault(bodySchema: any): z.ZodObject<{
     code: z.ZodString;
     message: z.ZodString;
     data: any;
-}, "strip", z.ZodTypeAny, {
-    message: string;
-    code: string;
-    data?: any;
-}, {
-    message: string;
-    code: string;
-    data?: any;
-}>;
+}, z.core.$strip>;

package/dist/lib/schema/makeSchemaLikes.d.ts

@@ -1,4 +1,4 @@
 import type { SchemaLike } from 'vona-module-a-openapiutils';
 import type { z } from 'zod';
-export declare function makeSchemaLikes(schemaLikes: SchemaLike[], typeInit: any): z.ZodSchema;
-export declare function makeSchemaLike(schemaLike: SchemaLike | undefined, schemaPrevious: z.ZodSchema): z.ZodSchema;
+export declare function makeSchemaLikes<T>(schemaLikes: SchemaLike<T> | SchemaLike<T>[], typeInit: any): z.ZodType<T>;
+export declare function makeSchemaLike<T>(schemaLike: SchemaLike<T> | undefined, schemaPrevious: z.ZodType<T>): z.ZodType<T>;

package/dist/lib/schema/schema.d.ts

@@ -2,12 +2,12 @@ import type { Constructable } from 'vona';
 import type { SchemaLike } from 'vona-module-a-openapiutils';
 import type { ISchemaObjectOptions } from '../../types/decorator.ts';
 import { z } from 'zod';
-export declare function $schema(schemaLike: z.ZodSchema): z.ZodSchema;
+export declare function $schema<T>(schemaLike: z.ZodType<T>): z.ZodType<T>;
 export declare function $schema(classType: StringConstructor): z.ZodString;
 export declare function $schema(classType: NumberConstructor): z.ZodNumber;
 export declare function $schema(classType: BooleanConstructor): z.ZodBoolean;
 export declare function $schema(classType: DateConstructor): z.ZodDate;
 export declare function $schema(classType: BigIntConstructor): z.ZodBigInt;
 export declare function $schema(classType: ArrayConstructor): z.ZodArray<z.ZodAny>;
-export declare function $schema<T>(classType: Constructable<T>, options?: ISchemaObjectOptions): z.ZodSchema<T>;
-export declare function $schemaLazy<T>(...schemaLikes: SchemaLike[]): z.ZodSchema<T>;
+export declare function $schema<T>(classType: Constructable<T>, options?: ISchemaObjectOptions): z.ZodType<T>;
+export declare function $schemaLazy<T>(...schemaLikes: SchemaLike<T>[]): z.ZodType<T>;

package/dist/lib/schema/v/helpers.d.ts

@@ -1,14 +1,18 @@
-import type { IpVersion } from 'zod';
-import type { errorUtil } from '../../zod/errorUtil.ts';
+import type { ISchemaObjectExtensionFieldCaptcha } from '../../../types/captcha.ts';
 import { z } from 'zod';
-export declare function schemaEmail(message?: errorUtil.ErrMessage): (schema: z.ZodString) => z.ZodString;
-export declare function schemaUrl(message?: errorUtil.ErrMessage): (schema: z.ZodString) => z.ZodString;
-export declare function schemaUuid(message?: errorUtil.ErrMessage): (schema: z.ZodString) => z.ZodString;
-export declare function schemaIp(options?: string | {
-    version?: IpVersion;
-    message?: string;
-}): (schema: z.ZodString) => z.ZodString;
-export declare function schemaMin(min: number, message?: errorUtil.ErrMessage): (schema: any) => any;
-export declare function schemaMax(max: number, message?: errorUtil.ErrMessage): (schema: any) => any;
-export declare function schemaTableIdentity(): (_schema?: any) => any;
-export declare function schemaBigNumber(): (_schema: any) => any;
+export declare function schemaEmail(params?: string | z.core.$ZodEmailParams): (_schema: z.ZodString) => z.ZodEmail;
+export declare function schemaUrl(params?: string | z.core.$ZodURLParams): (_schema: z.ZodString) => z.ZodURL;
+export declare function schemaUuid(params?: string | z.core.$ZodUUIDParams): (_schema: z.ZodString) => z.ZodUUID;
+export declare function schemaIPv4(params?: string | z.core.$ZodIPv4Params): (_schema: z.ZodString) => z.ZodIPv4;
+export declare function schemaIPv6(params?: string | z.core.$ZodIPv6Params): (_schema: z.ZodString) => z.ZodIPv6;
+export declare function schemaMin(min: number, params?: string | z.core.$ZodCheckMinLengthParams | z.core.$ZodCheckGreaterThanParams): (schema: z.ZodString | z.ZodNumber) => z.ZodString | z.ZodNumber;
+export declare function schemaMax(max: number, params?: string | z.core.$ZodCheckMaxLengthParams | z.core.$ZodCheckLessThanParams): (schema: z.ZodString | z.ZodNumber) => z.ZodString | z.ZodNumber;
+export declare function schemaTrim(): (schema: z.ZodString) => z.ZodString;
+export declare function schemaToLowerCase(): (schema: z.ZodString) => z.ZodString;
+export declare function schemaToUpperCase(): (schema: z.ZodString) => z.ZodString;
+export declare function schemaLowercase(params?: string | z.core.$ZodCheckLowerCaseParams): (schema: z.ZodString) => z.ZodString;
+export declare function schemaUppercase(params?: string | z.core.$ZodCheckUpperCaseParams): (schema: z.ZodString) => z.ZodString;
+export declare function schemaRegex(regex: RegExp, params?: string | z.core.$ZodCheckRegexParams): (schema: z.ZodString) => z.ZodString;
+export declare function schemaTableIdentity(): (_schema?: any) => z.ZodString | z.ZodNumber;
+export declare function schemaBigNumber(): (_schema: any) => z.ZodType;
+export declare function schemaCaptcha(options: ISchemaObjectExtensionFieldCaptcha): (schema: z.ZodType) => z.ZodType;

package/dist/lib/schema/v/openapi.d.ts

@@ -1,7 +1,7 @@
-import type { ZodOpenAPIMetadata } from '@asteasolutions/zod-to-openapi';
-import type { z, ZodTypeAny } from 'zod';
-export declare function schemaOpenapi<T extends ZodTypeAny>(metadata: Partial<ZodOpenAPIMetadata<z.input<T>>>): any;
-export declare function schemaOpenapi<T extends ZodTypeAny>(refId: string, metadata?: Partial<ZodOpenAPIMetadata<z.input<T>>>): any;
-export declare function schemaTitle<T extends ZodTypeAny>(title?: string): (schema: T) => T;
-export declare function schemaDescription<T extends ZodTypeAny>(description?: string): (schema: T) => T;
-export declare function schemaExample<T extends ZodTypeAny>(example?: any): (schema: T) => T;
+import type { ZodOpenAPIMetadata } from '@cabloy/zod-to-openapi';
+import type { z } from 'zod';
+export declare function schemaOpenapi<T extends z.ZodType>(metadata: Partial<ZodOpenAPIMetadata<z.input<T>>>): T;
+export declare function schemaOpenapi<T extends z.ZodType>(refId: string, metadata?: Partial<ZodOpenAPIMetadata<z.input<T>>>): T;
+export declare function schemaTitle<T extends z.ZodType>(title?: string): (schema: T) => T;
+export declare function schemaDescription<T extends z.ZodType>(description?: string): (schema: T) => T;
+export declare function schemaExample<T extends z.ZodType>(example?: any): (schema: T) => T;

package/dist/lib/schema/v/system.d.ts

@@ -2,10 +2,12 @@ import type { Constructable } from 'vona';
 import type { SchemaLike } from 'vona-module-a-openapiutils';
 import type { ISchemaObjectOptions } from '../../../types/decorator.ts';
 import { z } from 'zod';
-export declare function schemaDefault(defaultValue: any | Function): (schema: z.ZodSchema) => z.ZodSchema;
-export declare function schemaOptional(): (schema: z.ZodSchema) => z.ZodSchema;
-export declare function schemaLazy<T>(...schemaLikes: SchemaLike[]): (_schema?: z.ZodSchema) => z.ZodSchema<T>;
-export declare function schemaObject<T>(classType: Constructable<T>, options?: ISchemaObjectOptions): (_schema?: z.ZodSchema) => z.ZodSchema<T>;
-export declare function schemaArray(schemaLike?: SchemaLike, params?: z.RawCreateParams & {
+export declare function schemaDefault(defaultValue: any | Function): (schema: z.ZodType) => z.ZodType;
+export declare function schemaOptional(): (schema: z.ZodType) => z.ZodType;
+export declare function schemaLazy<T>(...schemaLikes: SchemaLike<T>[]): (_schema?: z.ZodType) => z.ZodType<T>;
+export declare function schemaObject<T>(classType: Constructable<T>, options?: ISchemaObjectOptions): (_schema?: z.ZodType) => z.ZodType<T>;
+export declare function schemaArray(schemaLike?: SchemaLike, params?: z.core.$ZodArrayParams & {
     separator?: string;
-}): (schema: z.ZodSchema) => z.ZodSchema;
+}): (schema: z.ZodType) => z.ZodType;
+export declare function schemaStrictObject(): (schema: z.ZodObject) => z.ZodObject;
+export declare function schemaLooseObject(): (schema: z.ZodObject) => z.ZodObject;

package/dist/lib/schema/v/zod.d.ts

@@ -0,0 +1,4 @@
+import type { IZodRefineRecord, IZodTransformRecord } from 'vona-module-a-zod';
+import type z from 'zod';
+export declare function schemaZodRefine<T extends keyof IZodRefineRecord>(zodRefineName: T, options?: Partial<IZodRefineRecord[T]>): (schema: z.ZodType) => z.ZodType;
+export declare function schemaZodTransform<T extends keyof IZodTransformRecord>(zodTransformName: T, options?: Partial<IZodTransformRecord[T]>): (schema: z.ZodType) => z.ZodType;

package/dist/lib/schema/v.d.ts

@@ -1,22 +1,35 @@
-import { schemaBigNumber, schemaEmail, schemaIp, schemaMax, schemaMin, schemaTableIdentity, schemaUrl, schemaUuid } from './v/helpers.ts';
+import { schemaBigNumber, schemaCaptcha, schemaEmail, schemaIPv4, schemaIPv6, schemaLowercase, schemaMax, schemaMin, schemaRegex, schemaTableIdentity, schemaToLowerCase, schemaToUpperCase, schemaTrim, schemaUppercase, schemaUrl, schemaUuid } from './v/helpers.ts';
 import { schemaDescription, schemaExample, schemaOpenapi, schemaTitle } from './v/openapi.ts';
-import { schemaArray, schemaDefault, schemaLazy, schemaObject, schemaOptional } from './v/system.ts';
+import { schemaArray, schemaDefault, schemaLazy, schemaLooseObject, schemaObject, schemaOptional, schemaStrictObject } from './v/system.ts';
+import { schemaZodRefine, schemaZodTransform } from './v/zod.ts';
 export declare const v: {
     lazy: typeof schemaLazy;
     array: typeof schemaArray;
     default: typeof schemaDefault;
     object: typeof schemaObject;
     optional: typeof schemaOptional;
+    strictObject: typeof schemaStrictObject;
+    looseObject: typeof schemaLooseObject;
     email: typeof schemaEmail;
     url: typeof schemaUrl;
     uuid: typeof schemaUuid;
-    ip: typeof schemaIp;
+    ipv4: typeof schemaIPv4;
+    ipv6: typeof schemaIPv6;
     min: typeof schemaMin;
     max: typeof schemaMax;
+    trim: typeof schemaTrim;
+    toLowerCase: typeof schemaToLowerCase;
+    toUpperCase: typeof schemaToUpperCase;
+    lowercase: typeof schemaLowercase;
+    uppercase: typeof schemaUppercase;
+    regex: typeof schemaRegex;
     tableIdentity: typeof schemaTableIdentity;
     bigNumber: typeof schemaBigNumber;
+    captcha: typeof schemaCaptcha;
     openapi: typeof schemaOpenapi;
     title: typeof schemaTitle;
     description: typeof schemaDescription;
     example: typeof schemaExample;
+    refine: typeof schemaZodRefine;
+    transform: typeof schemaZodTransform;
 };

package/dist/lib/utils.d.ts

@@ -1,5 +1,6 @@
 import type { Constructable } from 'vona';
-export declare function getTargetDecoratorRules(target: object): Record<PropertyKey, unknown>;
+import type { TypeDecoratorRules } from 'vona-module-a-openapiutils';
+export declare function getTargetDecoratorRules(target: object): TypeDecoratorRules;
 export declare function getTargetDecoratorRuleColumns(target: object): Record<PropertyKey, unknown>;
 export declare function mergeFieldsOpenapiMetadata(target: Constructable): void;
 export declare function prepareClassType<T>(classType: (() => Constructable<T>) | Constructable<T>): Constructable<T>;

package/dist/lib/zod/index.d.ts

@@ -1,3 +1 @@
-export * from './errorsAdapter.ts';
-export * from './errorUtil.ts';
 export * from './schemaRefCustomAdapter.ts';

package/dist/types/captcha.d.ts

@@ -0,0 +1,4 @@
+import type { ICaptchaSceneRecord } from 'vona-module-a-captcha';
+export interface ISchemaObjectExtensionFieldCaptcha {
+    scene: keyof ICaptchaSceneRecord;
+}

package/dist/types/decorator.d.ts

@@ -1,15 +1,15 @@
 import type { Constructable, Type, VonaContext } from 'vona';
 import type { z } from 'zod';
 export interface ISchemaObjectOptions {
-    passthrough?: boolean;
+    loose?: boolean;
     strict?: boolean;
 }
 export interface RouteHandlerArgumentMetaDecorator {
     index: number;
     type: RouteHandlerArgumentType;
     field?: string;
-    pipes: (Function | z.ZodSchema)[];
-    schema: z.ZodSchema;
+    pipes: Function[];
+    schema: z.ZodType;
     extractValue?: TypeExtractValue;
 }
 export interface RouteHandlerArgumentMeta {

package/dist/types/index.d.ts

@@ -4,4 +4,5 @@ export * from './behavior.ts';
 export * from './component.ts';
 export * from './database.ts';
 export * from './decorator.ts';
+export * from './query.ts';
 export * from './rest.ts';

package/dist/types/query.d.ts

@@ -0,0 +1,13 @@
+import type { IModelSelectParamsJoinType, ITableRecord, TypeOpsNormal } from 'vona-module-a-orm';
+export interface ISchemaObjectExtensionFieldQueryJoin {
+    type?: IModelSelectParamsJoinType;
+    table: keyof ITableRecord;
+    on: [string, string];
+}
+export interface ISchemaObjectExtensionFieldQuery {
+    table?: keyof ITableRecord;
+    joinType?: IModelSelectParamsJoinType;
+    joinOn?: [string, string];
+    originalName?: string;
+    op?: TypeOpsNormal;
+}

package/dist/types/rest.d.ts

@@ -1,9 +1,11 @@
-import type { ZodOpenAPIMetadata } from '@asteasolutions/zod-to-openapi';
+import type { ZodOpenAPIMetadata } from '@cabloy/zod-to-openapi';
 import type { CurrencyOptions } from '@zhennann/currency';
 import type { IOpenApiOptions } from 'vona-module-a-openapiutils';
-import type { z, ZodTypeAny } from 'zod';
+import type { z } from 'zod';
 import type { TypeResourceActionRowRecordRender } from './actions.ts';
+import type { ISchemaObjectExtensionFieldCaptcha } from './captcha.ts';
 import type { IComponentRecord } from './component.ts';
+import type { ISchemaObjectExtensionFieldQuery } from './query.ts';
 import 'openapi3-ts/oas30';
 import 'openapi3-ts/oas31';
 export interface ISchemaObjectExtensionFieldRest {
@@ -16,6 +18,8 @@ export interface ISchemaObjectExtensionFieldRest {
 }
 export interface ISchemaObjectExtensionField {
     rest?: ISchemaObjectExtensionFieldRest;
+    query?: ISchemaObjectExtensionFieldQuery;
+    captcha?: ISchemaObjectExtensionFieldCaptcha;
 }
 declare module 'openapi3-ts/oas30' {
     interface SchemaObject extends ISchemaObjectExtensionField {
@@ -28,9 +32,9 @@ declare module 'openapi3-ts/oas31' {
 export type TypeFieldRenderComponent = (keyof IComponentRecord) | (keyof TypeResourceActionRowRecordRender) | 'text' | 'textarea' | 'select' | 'checkbox' | 'radio' | 'switch' | 'image' | 'file' | 'color' | 'password' | 'email' | 'url';
 export type TypeFieldRenderComponentProvider = (keyof IComponentRecord) | (keyof TypeResourceActionRowRecordRender) | 'input' | 'textarea' | 'select';
 export type TypeSchemaScene = 'table' | 'form';
-export type TypeOpenapiMetadata<T extends ZodTypeAny = ZodTypeAny> = Partial<ZodOpenAPIMetadata<z.input<T>>>;
+export type TypeOpenapiMetadata<T extends z.ZodType = z.ZodType> = Partial<ZodOpenAPIMetadata<z.input<T>>>;
 export type TypeEntityOptionsFields<T extends {}, More extends string | undefined = never> = {
-    [key in ((keyof T) | (More extends string ? More : never))]?: TypeOpenapiMetadata | z.ZodSchema;
+    [key in ((keyof T) | (More extends string ? More : never))]?: TypeOpenapiMetadata | z.ZodType;
 };
 export type TypeControllerOptionsActions<T extends {}> = {
     [key in (keyof T)]?: IOpenApiOptions;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-openapi",
   "type": "module",
-  "version": "5.0.29",
+  "version": "5.0.31",
   "title": "a-openapi",
   "vonaModule": {
     "capabilities": {
@@ -9,7 +9,9 @@
     },
     "dependencies": {},
     "globalDependencies": {
-      "@asteasolutions/zod-to-openapi": true,
+      "@cabloy/zod-openapi": true,
+      "@cabloy/zod-to-openapi": true,
+      "openapi3-ts": true,
       "zod": true
     }
   },
@@ -33,12 +35,13 @@
     "static"
   ],
   "dependencies": {
-    "@asteasolutions/zod-to-openapi": "^7.3.0",
-    "@cabloy/zod-errors-custom": "^1.0.13",
-    "@cabloy/zod-query": "^1.0.16",
+    "@cabloy/zod-errors-custom": "^2.0.1",
+    "@cabloy/zod-openapi": "^1.0.1",
+    "@cabloy/zod-query": "^2.0.1",
+    "@cabloy/zod-to-openapi": "^8.1.1",
     "@zhennann/currency": "^2.0.0",
-    "openapi3-ts": "^4.4.0",
-    "zod": "^3.25.58"
+    "openapi3-ts": "^4.5.0",
+    "zod": "^4.1.5"
   },
   "devDependencies": {
     "clean-package": "^2.2.0",

package/dist/config/locale/en-us.d.ts

@@ -1,80 +0,0 @@
-declare const _default: {
-    ZodError_invalid_input: string;
-    ZodError_invalid_type_required: string;
-    ZodError_invalid_type_requiredDetail: string;
-    ZodError_invalid_literal: string;
-    ZodError_unrecognized_keys: string;
-    ZodError_invalid_union: string;
-    ZodError_invalid_union_discriminator: string;
-    ZodError_invalid_enum_value: string;
-    ZodError_invalid_arguments: string;
-    ZodError_invalid_return_type: string;
-    ZodError_invalid_date: string;
-    ZodError_invalid_string_includes: string;
-    ZodError_invalid_string_includes_position: string;
-    ZodError_invalid_string_startsWith: string;
-    ZodError_invalid_string_endsWith: string;
-    ZodError_invalid_string_validation: string;
-    ZodError_invalid_string: string;
-    ZodError_too_small_array_exact: string;
-    ZodError_too_small_array_inclusive: string;
-    ZodError_too_small_array_not_inclusive: string;
-    ZodError_too_small_string_exact: string;
-    ZodError_too_small_string_inclusive: string;
-    ZodError_too_small_string_not_inclusive: string;
-    ZodError_too_small_number_exact: string;
-    ZodError_too_small_number_inclusive: string;
-    ZodError_too_small_number_not_inclusive: string;
-    ZodError_too_small_set_exact: string;
-    ZodError_too_small_set_inclusive: string;
-    ZodError_too_small_set_not_inclusive: string;
-    ZodError_too_small_date_exact: string;
-    ZodError_too_small_date_inclusive: string;
-    ZodError_too_small_date_not_inclusive: string;
-    ZodError_too_big_array_exact: string;
-    ZodError_too_big_array_inclusive: string;
-    ZodError_too_big_array_not_inclusive: string;
-    ZodError_too_big_string_exact: string;
-    ZodError_too_big_string_inclusive: string;
-    ZodError_too_big_string_not_inclusive: string;
-    ZodError_too_big_number_exact: string;
-    ZodError_too_big_number_inclusive: string;
-    ZodError_too_big_number_not_inclusive: string;
-    ZodError_too_big_set_exact: string;
-    ZodError_too_big_set_inclusive: string;
-    ZodError_too_big_set_not_inclusive: string;
-    ZodError_too_big_date_exact: string;
-    ZodError_too_big_date_inclusive: string;
-    ZodError_too_big_date_not_inclusive: string;
-    ZodError_custom: string;
-    ZodError_invalid_intersection_types: string;
-    ZodError_not_multiple_of: string;
-    ZodError_not_finite: string;
-    ZodError_validations_email: string;
-    ZodError_validations_url: string;
-    ZodError_validations_uuid: string;
-    ZodError_validations_cuid: string;
-    ZodError_validations_regex: string;
-    ZodError_validations_datetime: string;
-    ZodError_types_function: string;
-    ZodError_types_number: string;
-    ZodError_types_string: string;
-    ZodError_types_nan: string;
-    ZodError_types_integer: string;
-    ZodError_types_float: string;
-    ZodError_types_boolean: string;
-    ZodError_types_date: string;
-    ZodError_types_bigint: string;
-    ZodError_types_undefined: string;
-    ZodError_types_symbol: string;
-    ZodError_types_null: string;
-    ZodError_types_array: string;
-    ZodError_types_object: string;
-    ZodError_types_unknown: string;
-    ZodError_types_promise: string;
-    ZodError_types_void: string;
-    ZodError_types_never: string;
-    ZodError_types_map: string;
-    ZodError_types_set: string;
-};
-export default _default;

package/dist/config/locale/zh-cn.d.ts

@@ -1,80 +0,0 @@
-declare const _default: {
-    ZodError_invalid_input: string;
-    ZodError_invalid_type_required: string;
-    ZodError_invalid_type_requiredDetail: string;
-    ZodError_invalid_literal: string;
-    ZodError_unrecognized_keys: string;
-    ZodError_invalid_union: string;
-    ZodError_invalid_union_discriminator: string;
-    ZodError_invalid_enum_value: string;
-    ZodError_invalid_arguments: string;
-    ZodError_invalid_return_type: string;
-    ZodError_invalid_date: string;
-    ZodError_invalid_string_includes: string;
-    ZodError_invalid_string_includes_position: string;
-    ZodError_invalid_string_startsWith: string;
-    ZodError_invalid_string_endsWith: string;
-    ZodError_invalid_string_validation: string;
-    ZodError_invalid_string: string;
-    ZodError_too_small_array_exact: string;
-    ZodError_too_small_array_inclusive: string;
-    ZodError_too_small_array_not_inclusive: string;
-    ZodError_too_small_string_exact: string;
-    ZodError_too_small_string_inclusive: string;
-    ZodError_too_small_string_not_inclusive: string;
-    ZodError_too_small_number_exact: string;
-    ZodError_too_small_number_inclusive: string;
-    ZodError_too_small_number_not_inclusive: string;
-    ZodError_too_small_set_exact: string;
-    ZodError_too_small_set_inclusive: string;
-    ZodError_too_small_set_not_inclusive: string;
-    ZodError_too_small_date_exact: string;
-    ZodError_too_small_date_inclusive: string;
-    ZodError_too_small_date_not_inclusive: string;
-    ZodError_too_big_array_exact: string;
-    ZodError_too_big_array_inclusive: string;
-    ZodError_too_big_array_not_inclusive: string;
-    ZodError_too_big_string_exact: string;
-    ZodError_too_big_string_inclusive: string;
-    ZodError_too_big_string_not_inclusive: string;
-    ZodError_too_big_number_exact: string;
-    ZodError_too_big_number_inclusive: string;
-    ZodError_too_big_number_not_inclusive: string;
-    ZodError_too_big_set_exact: string;
-    ZodError_too_big_set_inclusive: string;
-    ZodError_too_big_set_not_inclusive: string;
-    ZodError_too_big_date_exact: string;
-    ZodError_too_big_date_inclusive: string;
-    ZodError_too_big_date_not_inclusive: string;
-    ZodError_custom: string;
-    ZodError_invalid_intersection_types: string;
-    ZodError_not_multiple_of: string;
-    ZodError_not_finite: string;
-    ZodError_validations_email: string;
-    ZodError_validations_url: string;
-    ZodError_validations_uuid: string;
-    ZodError_validations_cuid: string;
-    ZodError_validations_regex: string;
-    ZodError_validations_datetime: string;
-    ZodError_types_function: string;
-    ZodError_types_number: string;
-    ZodError_types_string: string;
-    ZodError_types_nan: string;
-    ZodError_types_integer: string;
-    ZodError_types_float: string;
-    ZodError_types_boolean: string;
-    ZodError_types_date: string;
-    ZodError_types_bigint: string;
-    ZodError_types_undefined: string;
-    ZodError_types_symbol: string;
-    ZodError_types_null: string;
-    ZodError_types_array: string;
-    ZodError_types_object: string;
-    ZodError_types_unknown: string;
-    ZodError_types_promise: string;
-    ZodError_types_void: string;
-    ZodError_types_never: string;
-    ZodError_types_map: string;
-    ZodError_types_set: string;
-};
-export default _default;

package/dist/lib/decorator/arguments.d.ts

@@ -1,38 +0,0 @@
-import type { SchemaLike } from 'vona-module-a-openapiutils';
-declare function Param(): ParameterDecorator;
-declare function Param(...schemaLikes: SchemaLike[]): ParameterDecorator;
-declare function Param(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
-declare function Query(): ParameterDecorator;
-declare function Query(...schemaLikes: SchemaLike[]): ParameterDecorator;
-declare function Query(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
-declare function Body(): ParameterDecorator;
-declare function Body(...schemaLikes: SchemaLike[]): ParameterDecorator;
-declare function Body(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
-declare function Headers(): ParameterDecorator;
-declare function Headers(...schemaLikes: SchemaLike[]): ParameterDecorator;
-declare function Headers(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
-declare function Fields(): ParameterDecorator;
-declare function Fields(...schemaLikes: SchemaLike[]): ParameterDecorator;
-declare function Fields(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
-declare function Field(): ParameterDecorator;
-declare function Field(...schemaLikes: SchemaLike[]): ParameterDecorator;
-declare function Field(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
-declare function Files(): ParameterDecorator;
-declare function Files(...schemaLikes: SchemaLike[]): ParameterDecorator;
-declare function Files(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
-declare function File(): ParameterDecorator;
-declare function File(...schemaLikes: SchemaLike[]): ParameterDecorator;
-declare function File(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
-declare function User(...schemaLikes: SchemaLike[]): ParameterDecorator;
-export declare const Arg: {
-    param: typeof Param;
-    query: typeof Query;
-    body: typeof Body;
-    headers: typeof Headers;
-    fields: typeof Fields;
-    field: typeof Field;
-    files: typeof Files;
-    file: typeof File;
-    user: typeof User;
-};
-export {};

package/dist/lib/decorator/pipesArgument.d.ts

@@ -1,3 +0,0 @@
-import type { SchemaLike } from 'vona-module-a-openapiutils';
-import type { RouteHandlerArgumentType, TypeExtractValue } from '../../types/decorator.ts';
-export declare function createPipesArgumentDecorator(paramType: RouteHandlerArgumentType, extractValue?: TypeExtractValue): (field?: string | SchemaLike, ...schemaLikes: SchemaLike[]) => ParameterDecorator;

package/dist/lib/zod/errorUtil.d.ts

@@ -1,9 +0,0 @@
-export declare namespace errorUtil {
-    type ErrMessage = string | {
-        message?: string;
-    };
-    const errToObj: (message?: ErrMessage) => {
-        message?: string | undefined;
-    };
-    const toString: (message?: ErrMessage) => string | undefined;
-}

package/dist/lib/zod/errorsAdapter.d.ts

@@ -1,2 +0,0 @@
-import type { VonaApplication } from 'vona';
-export declare function errorsAdapter(app: VonaApplication): void;