@bedrockio/model 0.12.3 → 0.13.1

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 0.13.1
+
+- Do not enforce unique constraints in search validation.
+
+## 0.13.0
+
+- Removed support for passing schemas into `getCreateValidation` etc. now that
+  other methods available on yada exist. Instead allow more flexibility in
+  schema options.
+- Allow appending export schema as an option.
+
 ## 0.12.3
 
 - Support for `include` with top level dynamic references.

package/README.md

@@ -456,8 +456,9 @@ validation which will:
   - `Model.restoreMany`
   - `Model.insertMany`
   - `Model.replaceOne`
-- Append the same validation to `Model.getCreateSchema` and
-  `Model.getUpdateSchema` to allow this constraint to trickle down to the API.
+- Append the same validation to `Model.getCreateValidation` and
+  `Model.getUpdateValidation` to allow this constraint to trickle down to the
+  API.
 
 > [!WARNING] Note that calling `Model.updateOne` will throw an error when a
 > unique field exists on any document **including the document being updated**.
@@ -480,7 +481,7 @@ const router = new Router();
 router.post(
   '/',
   validateBody(
-    User.getCreateValidation({
+    User.getCreateValidation().append({
       password: yd.string().password().required(),
     }),
   ),
@@ -547,7 +548,7 @@ new ones:
 import yd from '@bedrockio/yada';
 
 const signupSchema = yd.object({
-  ...User.getCreateSchema().export(),
+  ...User.getCreateValidation().export(),
   additionalField: yd.string().required(),
 });
 ```
@@ -1290,7 +1291,7 @@ against scopes in the generated validations or when serializing:
 
 ```js
 // In validation middleware:
-const schema = User.getCreateSchema();
+const schema = User.getCreateValidation();
 await schema.validate(ctx.request.body, {
   scopes: authUser.getScopes(),
   // Also accepted:

package/dist/cjs/search.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.applySearch = applySearch;
+exports.exportValidation = exportValidation;
 exports.searchValidation = searchValidation;
 var _yada = _interopRequireDefault(require("@bedrockio/yada"));
 var _logger = _interopRequireDefault(require("@bedrockio/logger"));
@@ -57,6 +58,19 @@ function searchValidation(options = {}) {
     ...appendSchema
   });
 }
+function exportValidation(options = {}) {
+  const {
+    defaults,
+    formats = ['csv']
+  } = options;
+  const {
+    filename = 'export.csv'
+  } = defaults || {};
+  return {
+    filename: _yada.default.string().default(filename).description('Filename when search is exported.'),
+    format: _yada.default.string().allow('json', ...formats).default('json')
+  };
+}
 function searchQuery(Model, options, config) {
   const {
     schema

package/dist/cjs/validation.js

@@ -54,65 +54,67 @@ function addValidators(schemas) {
   Object.assign(NAMED_SCHEMAS, schemas);
 }
 function applyValidation(schema, definition) {
-  schema.static('getCreateValidation', function getCreateValidation(options = {}) {
-    const {
-      allowInclude,
-      ...appendSchema
-    } = options;
+  schema.static('getCreateValidation', function getCreateValidation(options) {
     return getSchemaFromMongoose(schema, {
       model: this,
-      appendSchema,
-      allowInclude,
       stripEmpty: true,
+      applyUnique: true,
       stripDeleted: true,
+      allowInclude: false,
       stripTimestamps: true,
       allowDefaultTags: true,
       allowExpandedRefs: true,
-      requireWriteAccess: true
+      requireWriteAccess: true,
+      ...options
     });
   });
-  schema.static('getUpdateValidation', function getUpdateValidation(options = {}) {
-    const {
-      allowInclude,
-      ...appendSchema
-    } = options;
+  schema.static('getUpdateValidation', function getUpdateValidation(options) {
     return getSchemaFromMongoose(schema, {
       model: this,
-      appendSchema,
-      allowInclude,
       allowNull: true,
+      applyUnique: true,
       skipRequired: true,
       stripUnknown: true,
       stripDeleted: true,
+      allowInclude: false,
       stripTimestamps: true,
       allowExpandedRefs: true,
       requireWriteAccess: true,
-      updateAccess: definition.access?.update
+      updateAccess: definition.access?.update,
+      ...options
     });
   });
   schema.static('getSearchValidation', function getSearchValidation(options = {}) {
     const {
+      allowExport,
       defaults,
-      includeDeleted,
-      ...appendSchema
+      formats,
+      ...rest
     } = options;
-    return getSchemaFromMongoose(schema, {
+    let validation = getSchemaFromMongoose(schema, {
       model: this,
       allowNull: true,
       stripEmpty: true,
       allowSearch: true,
       skipRequired: true,
       allowInclude: true,
+      stripDeleted: true,
       expandDotSyntax: true,
       unwindArrayFields: true,
       requireReadAccess: true,
-      stripDeleted: !includeDeleted,
-      appendSchema: (0, _search.searchValidation)({
-        defaults,
-        definition,
-        appendSchema
-      })
+      ...rest
     });
+    validation = validation.append((0, _search.searchValidation)({
+      defaults,
+      definition
+    }));
+    if (allowExport) {
+      validation = validation.append((0, _search.exportValidation)({
+        formats,
+        defaults
+      }));
+    }
+    return validation;
   });
   schema.static('getDeleteValidation', function getDeleteValidation() {
     const allowed = definition.access?.delete || 'all';
@@ -157,14 +159,10 @@ function getMongooseFields(schema, options) {
 // Exported for testing
 function getValidationSchema(attributes, options = {}) {
   const {
-    appendSchema,
     allowInclude,
     updateAccess
   } = options;
   let schema = getObjectSchema(attributes, options);
-  if (appendSchema) {
-    schema = schema.append(appendSchema);
-  }
   if (allowInclude) {
     schema = schema.append(_include.INCLUDE_FIELD_SCHEMA);
   }
@@ -308,7 +306,7 @@ function getSchemaForTypedef(typedef, options = {}) {
   if (typedef.writeAccess && options.requireWriteAccess) {
     schema = validateAccess('write', schema, typedef.writeAccess, options);
   }
-  if (typedef.softUnique) {
+  if (typedef.softUnique && options.applyUnique) {
     schema = schema.custom(async (value, {
       path,
       originalRoot

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/model",
-  "version": "0.12.3",
+  "version": "0.13.1",
   "description": "Bedrock utilities for model creation.",
   "type": "module",
   "scripts": {
@@ -30,7 +30,7 @@
     "lodash": "^4.17.21"
   },
   "peerDependencies": {
-    "@bedrockio/yada": "^1.4.1",
+    "@bedrockio/yada": "^1.5.0",
     "mongoose": "^8.13.1"
   },
   "devDependencies": {
@@ -39,7 +39,7 @@
     "@babel/preset-env": "^7.26.0",
     "@bedrockio/eslint-plugin": "^1.1.7",
     "@bedrockio/prettier-config": "^1.0.2",
-    "@bedrockio/yada": "^1.4.2",
+    "@bedrockio/yada": "^1.5.0",
     "@shelf/jest-mongodb": "^5.1.0",
     "eslint": "^9.19.0",
     "jest": "^29.7.0",

package/src/search.js

@@ -63,6 +63,21 @@ export function searchValidation(options = {}) {
   });
 }
 
+export function exportValidation(options = {}) {
+  const { defaults, formats = ['csv'] } = options;
+  const { filename = 'export.csv' } = defaults || {};
+  return {
+    filename: yd
+      .string()
+      .default(filename)
+      .description('Filename when search is exported.'),
+    format: yd
+      .string()
+      .allow('json', ...formats)
+      .default('json'),
+  };
+}
+
 function searchQuery(Model, options, config) {
   const { schema } = Model;
 

package/src/validation.js

@@ -4,7 +4,7 @@ import yd from '@bedrockio/yada';
 import { get, omit, lowerFirst } from 'lodash';
 
 import { hasAccess } from './access';
-import { searchValidation } from './search';
+import { searchValidation, exportValidation } from './search';
 import { assertUnique } from './soft-delete';
 import { PermissionsError, ImplementationError } from './errors';
 import { isMongooseSchema, isSchemaTypedef } from './utils';
@@ -56,65 +56,74 @@ export function addValidators(schemas) {
 }
 
 export function applyValidation(schema, definition) {
-  schema.static(
-    'getCreateValidation',
-    function getCreateValidation(options = {}) {
-      const { allowInclude, ...appendSchema } = options;
-      return getSchemaFromMongoose(schema, {
-        model: this,
-        appendSchema,
-        allowInclude,
-        stripEmpty: true,
-        stripDeleted: true,
-        stripTimestamps: true,
-        allowDefaultTags: true,
-        allowExpandedRefs: true,
-        requireWriteAccess: true,
-      });
-    },
-  );
+  schema.static('getCreateValidation', function getCreateValidation(options) {
+    return getSchemaFromMongoose(schema, {
+      model: this,
+      stripEmpty: true,
+      applyUnique: true,
+      stripDeleted: true,
+      allowInclude: false,
+      stripTimestamps: true,
+      allowDefaultTags: true,
+      allowExpandedRefs: true,
+      requireWriteAccess: true,
+      ...options,
+    });
+  });
 
-  schema.static(
-    'getUpdateValidation',
-    function getUpdateValidation(options = {}) {
-      const { allowInclude, ...appendSchema } = options;
-      return getSchemaFromMongoose(schema, {
-        model: this,
-        appendSchema,
-        allowInclude,
-        allowNull: true,
-        skipRequired: true,
-        stripUnknown: true,
-        stripDeleted: true,
-        stripTimestamps: true,
-        allowExpandedRefs: true,
-        requireWriteAccess: true,
-        updateAccess: definition.access?.update,
-      });
-    },
-  );
+  schema.static('getUpdateValidation', function getUpdateValidation(options) {
+    return getSchemaFromMongoose(schema, {
+      model: this,
+      allowNull: true,
+      applyUnique: true,
+      skipRequired: true,
+      stripUnknown: true,
+      stripDeleted: true,
+      allowInclude: false,
+      stripTimestamps: true,
+      allowExpandedRefs: true,
+      requireWriteAccess: true,
+      updateAccess: definition.access?.update,
+      ...options,
+    });
+  });
 
   schema.static(
     'getSearchValidation',
     function getSearchValidation(options = {}) {
-      const { defaults, includeDeleted, ...appendSchema } = options;
-      return getSchemaFromMongoose(schema, {
+      const { allowExport, defaults, formats, ...rest } = options;
+
+      let validation = getSchemaFromMongoose(schema, {
         model: this,
         allowNull: true,
         stripEmpty: true,
         allowSearch: true,
         skipRequired: true,
         allowInclude: true,
+        stripDeleted: true,
         expandDotSyntax: true,
         unwindArrayFields: true,
         requireReadAccess: true,
-        stripDeleted: !includeDeleted,
-        appendSchema: searchValidation({
+        ...rest,
+      });
+
+      validation = validation.append(
+        searchValidation({
           defaults,
           definition,
-          appendSchema,
         }),
-      });
+      );
+
+      if (allowExport) {
+        validation = validation.append(
+          exportValidation({
+            formats,
+            defaults,
+          }),
+        );
+      }
+
+      return validation;
     },
   );
 
@@ -160,13 +169,10 @@ function getMongooseFields(schema, options) {
 
 // Exported for testing
 export function getValidationSchema(attributes, options = {}) {
-  const { appendSchema, allowInclude, updateAccess } = options;
+  const { allowInclude, updateAccess } = options;
 
   let schema = getObjectSchema(attributes, options);
 
-  if (appendSchema) {
-    schema = schema.append(appendSchema);
-  }
   if (allowInclude) {
     schema = schema.append(INCLUDE_FIELD_SCHEMA);
   }
@@ -322,7 +328,7 @@ function getSchemaForTypedef(typedef, options = {}) {
     schema = validateAccess('write', schema, typedef.writeAccess, options);
   }
 
-  if (typedef.softUnique) {
+  if (typedef.softUnique && options.applyUnique) {
     schema = schema.custom(async (value, { path, originalRoot }) => {
       const { id } = originalRoot;
       await assertUnique({

package/types/search.d.ts

@@ -49,4 +49,208 @@ export function searchValidation(options?: {}): {
     runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
     enumToOpenApi(): any;
 };
+export function exportValidation(options?: {}): {
+    filename: {
+        required(): /*elided*/ any;
+        length(length: number): /*elided*/ any;
+        min(length: number): /*elided*/ any;
+        max(length: number): /*elided*/ any;
+        trim(): /*elided*/ any;
+        lowercase(assert?: boolean): /*elided*/ any;
+        uppercase(assert?: boolean): /*elided*/ any;
+        match(reg: RegExp): /*elided*/ any;
+        email(): /*elided*/ any;
+        phone(code: any): /*elided*/ any;
+        hex(): /*elided*/ any;
+        md5(): /*elided*/ any;
+        sha1(): /*elided*/ any;
+        ascii(): /*elided*/ any;
+        base64(options?: {
+            urlSafe?: boolean;
+        }): /*elided*/ any;
+        creditCard(): /*elided*/ any;
+        ip(): /*elided*/ any;
+        country(): /*elided*/ any;
+        locale(): /*elided*/ any;
+        jwt(): /*elided*/ any;
+        slug(): /*elided*/ any;
+        latlng(): /*elided*/ any;
+        postalCode(locale?: string): /*elided*/ any;
+        zipcode(): /*elided*/ any;
+        password(options?: {
+            minLength?: number;
+            minNumbers?: number;
+            minSymbols?: number;
+            minLowercase?: number;
+            minUppercase?: number;
+        }): /*elided*/ any;
+        url(options?: {
+            require_protocol?: boolean;
+            require_valid_protocol?: boolean;
+            require_host?: boolean;
+            require_port?: boolean;
+            allow_protocol_relative_urls?: boolean;
+            allow_fragments?: boolean;
+            allow_query_components?: boolean;
+            validate_length?: boolean;
+            protocols?: string[];
+        }): /*elided*/ any;
+        domain(options?: {
+            require_tld?: boolean;
+            allow_underscores?: boolean;
+            allow_trailing_dot?: boolean;
+            allow_numeric_tld?: boolean;
+            allow_wildcard?: boolean;
+            ignore_max_length?: boolean;
+        }): /*elided*/ any;
+        uuid(version?: 1 | 2 | 3 | 4 | 5): /*elided*/ any;
+        btc(): /*elided*/ any;
+        eth(): /*elided*/ any;
+        swift(): /*elided*/ any;
+        mongo(): /*elided*/ any;
+        calendar(): /*elided*/ any;
+        format(name: any, fn: any): /*elided*/ any;
+        toString(): any;
+        assertions: any[];
+        meta: {};
+        default(arg: any): /*elided*/ any;
+        custom(fn: Function): /*elided*/ any;
+        missing(fn: Function): /*elided*/ any;
+        strip(strip: any): /*elided*/ any;
+        allow(...set: any[]): /*elided*/ any;
+        reject(...set: any[]): /*elided*/ any;
+        nullable(): /*elided*/ any;
+        message(message: any): /*elided*/ any;
+        tag(tags: any): /*elided*/ any;
+        description(description: any): /*elided*/ any;
+        options(options: any): /*elided*/ any;
+        validate(value: any, options?: {}): Promise<any>;
+        clone(meta: any): /*elided*/ any;
+        append(schema: any): import("@bedrockio/yada/types/Schema").default;
+        toOpenApi(extra: any): any;
+        getAnyType(): {
+            type: string[];
+        };
+        getDefault(): {
+            default?: undefined;
+        } | {
+            default: any;
+        };
+        getNullable(): {
+            nullable: boolean;
+        };
+        expandExtra(extra?: {}): {};
+        inspect(): string;
+        get(): void;
+        assertEnum(set: any, allow: any): /*elided*/ any;
+        assert(type: any, fn: any): /*elided*/ any;
+        pushAssertion(assertion: any): void;
+        canSkipAssertion(value: any, assertion: any, options: any): any;
+        transform(fn: any): /*elided*/ any;
+        getSortIndex(type: any): number;
+        runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
+        enumToOpenApi(): any;
+    };
+    format: {
+        required(): /*elided*/ any;
+        length(length: number): /*elided*/ any;
+        min(length: number): /*elided*/ any;
+        max(length: number): /*elided*/ any;
+        trim(): /*elided*/ any;
+        lowercase(assert?: boolean): /*elided*/ any;
+        uppercase(assert?: boolean): /*elided*/ any;
+        match(reg: RegExp): /*elided*/ any;
+        email(): /*elided*/ any;
+        phone(code: any): /*elided*/ any;
+        hex(): /*elided*/ any;
+        md5(): /*elided*/ any;
+        sha1(): /*elided*/ any;
+        ascii(): /*elided*/ any;
+        base64(options?: {
+            urlSafe?: boolean;
+        }): /*elided*/ any;
+        creditCard(): /*elided*/ any;
+        ip(): /*elided*/ any;
+        country(): /*elided*/ any;
+        locale(): /*elided*/ any;
+        jwt(): /*elided*/ any;
+        slug(): /*elided*/ any;
+        latlng(): /*elided*/ any;
+        postalCode(locale?: string): /*elided*/ any;
+        zipcode(): /*elided*/ any;
+        password(options?: {
+            minLength?: number;
+            minNumbers?: number;
+            minSymbols?: number;
+            minLowercase?: number;
+            minUppercase?: number;
+        }): /*elided*/ any;
+        url(options?: {
+            require_protocol?: boolean;
+            require_valid_protocol?: boolean;
+            require_host?: boolean;
+            require_port?: boolean;
+            allow_protocol_relative_urls?: boolean;
+            allow_fragments?: boolean;
+            allow_query_components?: boolean;
+            validate_length?: boolean;
+            protocols?: string[];
+        }): /*elided*/ any;
+        domain(options?: {
+            require_tld?: boolean;
+            allow_underscores?: boolean;
+            allow_trailing_dot?: boolean;
+            allow_numeric_tld?: boolean;
+            allow_wildcard?: boolean;
+            ignore_max_length?: boolean;
+        }): /*elided*/ any;
+        uuid(version?: 1 | 2 | 3 | 4 | 5): /*elided*/ any;
+        btc(): /*elided*/ any;
+        eth(): /*elided*/ any;
+        swift(): /*elided*/ any;
+        mongo(): /*elided*/ any;
+        calendar(): /*elided*/ any;
+        format(name: any, fn: any): /*elided*/ any;
+        toString(): any;
+        assertions: any[];
+        meta: {};
+        default(arg: any): /*elided*/ any;
+        custom(fn: Function): /*elided*/ any;
+        missing(fn: Function): /*elided*/ any;
+        strip(strip: any): /*elided*/ any;
+        allow(...set: any[]): /*elided*/ any;
+        reject(...set: any[]): /*elided*/ any;
+        nullable(): /*elided*/ any;
+        message(message: any): /*elided*/ any;
+        tag(tags: any): /*elided*/ any;
+        description(description: any): /*elided*/ any;
+        options(options: any): /*elided*/ any;
+        validate(value: any, options?: {}): Promise<any>;
+        clone(meta: any): /*elided*/ any;
+        append(schema: any): import("@bedrockio/yada/types/Schema").default;
+        toOpenApi(extra: any): any;
+        getAnyType(): {
+            type: string[];
+        };
+        getDefault(): {
+            default?: undefined;
+        } | {
+            default: any;
+        };
+        getNullable(): {
+            nullable: boolean;
+        };
+        expandExtra(extra?: {}): {};
+        inspect(): string;
+        get(): void;
+        assertEnum(set: any, allow: any): /*elided*/ any;
+        assert(type: any, fn: any): /*elided*/ any;
+        pushAssertion(assertion: any): void;
+        canSkipAssertion(value: any, assertion: any, options: any): any;
+        transform(fn: any): /*elided*/ any;
+        getSortIndex(type: any): number;
+        runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
+        enumToOpenApi(): any;
+    };
+};
 //# sourceMappingURL=search.d.ts.map

package/types/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAuBA,gEAaC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA4CgC,CAAC;;;;;;;;;;;;;;;;;EAnBhC"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAuBA,gEAaC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA0CyC,CAAC;;;;;;;;;;;;;;;;;EAjBzC;AAED;;;;;;;;;;;;;;;;;mBAtBI,CAAA;;;;;;;;;;;;qBAuBC,CAAC;sBAA4B,CAAC;sBACvB,CAAC;wBAA8B,CAAC;wBAEnC,CAAC;;;4BA2BK,CAAC;kCACwB,CAAC;wBACrC,CAAA;wBAA+B,CAAC;wCAK9B,CAAJ;2BAAkC,CAAC;kCACP,CAAC;2BAIhB,CAAC;qBAA4B,CAAC;;;uBAsBT,CAAC;6BACH,CAAC;8BAI7B,CAAF;6BAAoC,CAAC;0BAClB,CAAC;6BAIhB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA5DiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBArCtC,CAAA;;;;;;;;;;;;qBAuBC,CAAC;sBAA4B,CAAC;sBACvB,CAAC;wBAA8B,CAAC;wBAEnC,CAAC;;;4BA2BK,CAAC;kCACwB,CAAC;wBACrC,CAAA;wBAA+B,CAAC;wCAK9B,CAAJ;2BAAkC,CAAC;kCACP,CAAC;2BAIhB,CAAC;qBAA4B,CAAC;;;uBAsBT,CAAC;6BACH,CAAC;8BAI7B,CAAF;6BAAoC,CAAC;0BAClB,CAAC;6BAIhB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA5DiC,CAAC;;;;;;;;;;;;;;;;;;;EAFzC"}

package/types/validation-schemas.d.ts

@@ -5,7 +5,7 @@ export const DATE_SCHEMA: {
     after(min: string | number | Date): /*elided*/ any;
     past(): /*elided*/ any;
     future(): /*elided*/ any;
-    iso(format?: "date" | "date-time"): /*elided*/ any;
+    iso(): /*elided*/ any;
     timestamp(): /*elided*/ any;
     unix(): /*elided*/ any;
     assertions: any[];
@@ -107,6 +107,7 @@ export const OBJECT_ID_SCHEMA: {
     eth(): /*elided*/ any;
     swift(): /*elided*/ any;
     mongo(): /*elided*/ any;
+    calendar(): /*elided*/ any;
     format(name: any, fn: any): /*elided*/ any;
     toString(): any;
     assertions: any[];

package/types/validation-schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation-schemas.d.ts","sourceRoot":"","sources":["../src/validation-schemas.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAoEI,CAAA;;;;;;;;;;;;;;;;;;EApEsD;AAE1D;;;;;;;;;;;;;;;;eAyBwB,CAAC;;;;;;;;;;;;iBAuBjB,CAAA;kBAA4B,CAAC;kBAEjC,CAAF;oBAEI,CAAC;oBAEI,CAAC;;;wBA2BC,CAAC;8BAGI,CAAC;oBAA+B,CAAC;oBAE1C,CAAC;oCAEL,CAAC;uBAAkC,CAAC;8BAAyC,CAAC;uBACzD,CAAC;iBAA4B,CAAC;;;mBAG0V,CAAC;yBAAoC,CAAC;0BAAqC,CAAC;yBAAoC,CAAC;sBAAiC,CAAC;yBAAoC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA1BtkB,CAAA;;;;;;;;;;;;;;;;;;EA1DC;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAwDI,CAAA;;;;;;;;;;;;;;;;;EA9CC;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA4CI,CAAA;;;;;;;;;;;;;;;;;EAlCC;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAgCI,CAAA;;;;;;;;;;;;;;;;;EAEC;AAEL,8EAqBK"}
+{"version":3,"file":"validation-schemas.d.ts","sourceRoot":"","sources":["../src/validation-schemas.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAoEI,CAAA;;;;;;;;;;;;;;;;;;EApEsD;AAE1D;;;;;;;;;;;;;;;;eAyBwB,CAAC;;;;;;;;;;;;iBAuBjB,CAAA;kBAA4B,CAAC;kBAEjC,CAAF;oBAEI,CAAC;oBAEI,CAAC;;;wBA2BC,CAAC;8BAGI,CAAC;oBAA+B,CAAC;oBAE1C,CAAC;oCAEL,CAAC;uBAAkC,CAAC;8BAAyC,CAAC;uBACzD,CAAC;iBAA4B,CAAC;;;mBAG0V,CAAC;yBAAoC,CAAC;0BAAqC,CAAC;yBAAoC,CAAC;sBAAiC,CAAC;yBAAoC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA1BtkB,CAAA;;;;;;;;;;;;;;;;;;EA1DC;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAwDI,CAAA;;;;;;;;;;;;;;;;;EA9CC;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA4CI,CAAA;;;;;;;;;;;;;;;;;EAlCC;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAgCI,CAAA;;;;;;;;;;;;;;;;;EAEC;AAEL,8EAqBK"}

package/types/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AAqDA,kDAEC;AAED,oEAkFC;AAsBD,wEAoBC;AA8SD;;;EAEC;AAED;;;EAOC"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AAqDA,kDAEC;AAED,oEA2FC;AAsBD,wEAiBC;AA8SD;;;EAEC;AAED;;;EAOC"}