@bedrockio/model 0.16.0 → 0.18.0

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.18.0
+
+- Added `reload`.
+
+## 0.17.0
+
+- Added `time` validation.
+
 ## 0.16.0
 
 - Added `upsert` method.

package/README.md

@@ -23,6 +23,7 @@ Bedrock utilities for model creation.
   - [Access Control](#access-control)
   - [Assign](#assign)
   - [Upsert](#upsert)
+  - [Reload](#reload)
   - [Clone](#clone)
   - [Slugs](#slugs)
 - [Testing](#testing)
@@ -1752,6 +1753,32 @@ if (!shop) {
 }
 ```
 
+### Reload
+
+Adds a single `reload` method that reloads a document in place. This is useful
+for testing purposes, etc:
+
+```js
+const shop = await Shop.create({
+  name: 'My Shop',
+});
+
+await Shop.updateOne(
+  {
+    _id: shop._id,
+  },
+  {
+    $set: {
+      name: 'My New Shop',
+    },
+  },
+);
+
+await shop.reload();
+
+shop.name; // Now "My New Shop"
+```
+
 ### Clone
 
 Adds a single `clone` method on documents. This is an async method mostly for

package/dist/cjs/include.js

@@ -360,7 +360,7 @@ function resolvePaths(schema, str) {
     source = source.replaceAll('\\*', '[^.]+');
     source = `^${source}$`;
     const reg = RegExp(source);
-    paths = getSchemaPaths(schema).filter(path => {
+    paths = (0, _utils.getSchemaPaths)(schema).filter(path => {
       return reg.test(path);
     });
   } else {
@@ -369,17 +369,4 @@ function resolvePaths(schema, str) {
   return paths.map(path => {
     return [path, schema.pathType(path)];
   });
-}
-function getSchemaPaths(schema) {
-  return Object.entries(schema.paths || {}).flatMap(([key, schema]) => {
-    if (key.startsWith('_')) {
-      return [];
-    } else if (schema.schema) {
-      return getSchemaPaths(schema.schema).map(path => {
-        return [key, path].join('.');
-      });
-    } else {
-      return [key];
-    }
-  });
 }

package/dist/cjs/reload.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyReload = applyReload;
+var _mongoose = _interopRequireDefault(require("mongoose"));
+var _utils = require("./utils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function applyReload(schema) {
+  schema.method('reload', async function reload() {
+    const paths = getPopulatedPaths(this);
+    const doc = await this.constructor.findById(this.id).include(paths);
+    if (!doc) {
+      throw new Error('Document deleted');
+    }
+    this.overwrite(doc);
+  });
+}
+function getPopulatedPaths(doc) {
+  return getReferencePaths(doc.constructor.schema).filter(path => {
+    const value = doc.get(path);
+    return value && !_mongoose.default.isObjectIdOrHexString(value);
+  });
+}
+function getReferencePaths(schema) {
+  return (0, _utils.getSchemaPaths)(schema).filter(path => {
+    return (0, _utils.isReferenceField)(schema, path);
+  });
+}

package/dist/cjs/schema.js

@@ -14,6 +14,7 @@ var _deleteHooks = require("./delete-hooks");
 var _disallowed = require("./disallowed");
 var _hydrate = require("./hydrate");
 var _include = require("./include");
+var _reload = require("./reload");
 var _search = require("./search");
 var _serialization = require("./serialization");
 var _slug = require("./slug");
@@ -58,6 +59,7 @@ function createSchema(definition, options = {}) {
   (0, _search.applySearch)(schema, definition);
   (0, _cache.applyCache)(schema, definition);
   (0, _clone.applyClone)(schema);
+  (0, _reload.applyReload)(schema);
   (0, _disallowed.applyDisallowed)(schema);
   (0, _include.applyInclude)(schema);
   (0, _hydrate.applyHydrate)(schema);

package/dist/cjs/utils.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getField = getField;
 exports.getInnerField = getInnerField;
+exports.getSchemaPaths = getSchemaPaths;
 exports.isArrayField = isArrayField;
 exports.isDateField = isDateField;
 exports.isEqual = isEqual;
@@ -149,4 +150,17 @@ function resolveInnerField(field) {
     field = field.obj;
   }
   return field;
+}
+function getSchemaPaths(schema) {
+  return Object.entries(schema.paths || {}).flatMap(([key, schema]) => {
+    if (key.startsWith('_')) {
+      return [];
+    } else if (schema.schema) {
+      return getSchemaPaths(schema.schema).map(path => {
+        return [key, path].join('.');
+      });
+    } else {
+      return [key];
+    }
+  });
 }

package/dist/cjs/validation.js

@@ -28,6 +28,8 @@ const NAMED_SCHEMAS = {
   // "calendar" validation is a special case to validate
   // string fields in ISO-8601 format without a time.
   calendar: _yada.default.string().calendar(),
+  // Validates generic ISO-8601 time.
+  time: _yada.default.string().time(),
   ascii: _yada.default.string().ascii(),
   base64: _yada.default.string().base64(),
   btc: _yada.default.string().btc(),
@@ -42,15 +44,15 @@ const NAMED_SCHEMAS = {
   locale: _yada.default.string().locale(),
   md5: _yada.default.string().md5(),
   phone: _yada.default.string().phone(),
-  'phone:US': _yada.default.string().phone('US'),
-  'phone:NANP': _yada.default.string().phone('NANP'),
   postalCode: _yada.default.string().postalCode(),
-  zipcode: _yada.default.string().zipcode(),
   sha1: _yada.default.string().sha1(),
   slug: _yada.default.string().slug(),
   swift: _yada.default.string().swift(),
   url: _yada.default.string().url(),
-  uuid: _yada.default.string().uuid()
+  uuid: _yada.default.string().uuid(),
+  zipcode: _yada.default.string().zipcode(),
+  'phone:NANP': _yada.default.string().phone('NANP'),
+  'phone:US': _yada.default.string().phone('US')
 };
 function addValidators(schemas) {
   Object.assign(NAMED_SCHEMAS, schemas);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/model",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "description": "Bedrock utilities for model creation.",
   "type": "module",
   "scripts": {
@@ -39,13 +39,13 @@
     "@babel/preset-env": "^7.26.0",
     "@bedrockio/eslint-plugin": "^1.2.2",
     "@bedrockio/prettier-config": "^1.1.1",
-    "@bedrockio/yada": "^1.8.0",
+    "@bedrockio/yada": "^1.9.0",
     "@shelf/jest-mongodb": "^5.2.2",
     "eslint": "^9.36.0",
     "jest": "^30.2.0",
     "jest-environment-node": "^30.2.0",
     "mongodb": "^6.20.0",
-    "mongoose": "^8.18.2",
+    "mongoose": "^8.19.2",
     "prettier": "^3.6.2",
     "typescript": "^5.9.2"
   },

package/src/include.js

@@ -2,6 +2,7 @@ import { escapeRegExp } from 'lodash';
 import mongoose from 'mongoose';
 
 import { POPULATE_MAX_DEPTH } from './const';
+import { getSchemaPaths } from './utils';
 import { getInnerField, isSchemaTypedef } from './utils';
 
 // @ts-ignore
@@ -363,17 +364,3 @@ function resolvePaths(schema, str) {
     return [path, schema.pathType(path)];
   });
 }
-
-function getSchemaPaths(schema) {
-  return Object.entries(schema.paths || {}).flatMap(([key, schema]) => {
-    if (key.startsWith('_')) {
-      return [];
-    } else if (schema.schema) {
-      return getSchemaPaths(schema.schema).map((path) => {
-        return [key, path].join('.');
-      });
-    } else {
-      return [key];
-    }
-  });
-}

package/src/reload.js

@@ -0,0 +1,30 @@
+import mongoose from 'mongoose';
+
+import { getSchemaPaths } from './utils';
+import { isReferenceField } from './utils';
+
+export function applyReload(schema) {
+  schema.method('reload', async function reload() {
+    const paths = getPopulatedPaths(this);
+    const doc = await this.constructor.findById(this.id).include(paths);
+
+    if (!doc) {
+      throw new Error('Document deleted');
+    }
+
+    this.overwrite(doc);
+  });
+}
+
+function getPopulatedPaths(doc) {
+  return getReferencePaths(doc.constructor.schema).filter((path) => {
+    const value = doc.get(path);
+    return value && !mongoose.isObjectIdOrHexString(value);
+  });
+}
+
+function getReferencePaths(schema) {
+  return getSchemaPaths(schema).filter((path) => {
+    return isReferenceField(schema, path);
+  });
+}

package/src/schema.js

@@ -8,6 +8,7 @@ import { applyDeleteHooks } from './delete-hooks';
 import { applyDisallowed } from './disallowed';
 import { applyHydrate } from './hydrate';
 import { applyInclude } from './include';
+import { applyReload } from './reload';
 import { applySearch } from './search';
 import { serializeOptions } from './serialization';
 import { applySlug } from './slug';
@@ -61,6 +62,7 @@ export function createSchema(definition, options = {}) {
   applySearch(schema, definition);
   applyCache(schema, definition);
   applyClone(schema);
+  applyReload(schema);
   applyDisallowed(schema);
   applyInclude(schema);
   applyHydrate(schema);

package/src/utils.js

@@ -139,3 +139,17 @@ function resolveInnerField(field) {
   }
   return field;
 }
+
+export function getSchemaPaths(schema) {
+  return Object.entries(schema.paths || {}).flatMap(([key, schema]) => {
+    if (key.startsWith('_')) {
+      return [];
+    } else if (schema.schema) {
+      return getSchemaPaths(schema.schema).map((path) => {
+        return [key, path].join('.');
+      });
+    } else {
+      return [key];
+    }
+  });
+}

package/src/validation.js

@@ -30,6 +30,9 @@ const NAMED_SCHEMAS = {
   // string fields in ISO-8601 format without a time.
   calendar: yd.string().calendar(),
 
+  // Validates generic ISO-8601 time.
+  time: yd.string().time(),
+
   ascii: yd.string().ascii(),
   base64: yd.string().base64(),
   btc: yd.string().btc(),
@@ -44,15 +47,16 @@ const NAMED_SCHEMAS = {
   locale: yd.string().locale(),
   md5: yd.string().md5(),
   phone: yd.string().phone(),
-  'phone:US': yd.string().phone('US'),
-  'phone:NANP': yd.string().phone('NANP'),
   postalCode: yd.string().postalCode(),
-  zipcode: yd.string().zipcode(),
   sha1: yd.string().sha1(),
   slug: yd.string().slug(),
   swift: yd.string().swift(),
   url: yd.string().url(),
   uuid: yd.string().uuid(),
+  zipcode: yd.string().zipcode(),
+
+  'phone:NANP': yd.string().phone('NANP'),
+  'phone:US': yd.string().phone('US'),
 };
 
 export function addValidators(schemas) {

package/types/include.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"include.d.ts","sourceRoot":"","sources":["../src/include.js"],"names":[],"mappings":"AAiBA,gDAuEC;AAMD,uDA4BC;AAGD,yDAIC;AAaD,yEAUC"}
+{"version":3,"file":"include.d.ts","sourceRoot":"","sources":["../src/include.js"],"names":[],"mappings":"AAkBA,gDAuEC;AAMD,uDA4BC;AAGD,yDAIC;AAaD,yEAUC"}

package/types/reload.d.ts

@@ -0,0 +1,2 @@
+export function applyReload(schema: any): void;
+//# sourceMappingURL=reload.d.ts.map

package/types/reload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reload.d.ts","sourceRoot":"","sources":["../src/reload.js"],"names":[],"mappings":"AAKA,+CAWC"}

package/types/schema.d.ts

@@ -19,6 +19,7 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
     };
     collation?: mongoose.mongo.CollationOptions;
     collectionOptions?: mongoose.mongo.CreateCollectionOptions;
+    lean?: boolean | mongoose.LeanOptions;
     timeseries?: mongoose.mongo.TimeSeriesCollectionOptions;
     expireAfterSeconds?: number;
     expires?: number | string;

package/types/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AAuBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,QAAQ,CAAC,aAAa;;;;;;;YAgDJ,CAAC;WAC1B,CAAF;mBAAqB,CAAC;;;;;;;;;;;;;;;;;;;;;;;SA2HlB,CAAC;gBACL,CAAC;SAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAlId;AAED,iEAsBC;qBA9FoB,UAAU"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AAwBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,QAAQ,CAAC,aAAa;;;;;;;YA+CX,CAAC;WAAa,CAAC;mBAEnC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;SA4HmB,CAAC;gBACL,CAAC;SAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAlI9B;AAED,iEAsBC;qBAhGoB,UAAU"}

package/types/search.d.ts

@@ -33,8 +33,9 @@ export function searchValidation(options?: {}): {
     description(description: any): /*elided*/ any;
     validate(value: any, options?: {}): Promise<any>;
     clone(meta: any): /*elided*/ any;
-    toJSON(extra?: any): any;
+    toJsonSchema(extra?: any): any;
     toOpenApi(...extra: any[]): any;
+    toJSON(): any;
     getAnyType(): {
         type: string[];
     };
@@ -120,6 +121,7 @@ export function exportValidation(options?: {}): {
         swift(): /*elided*/ any;
         mongo(): /*elided*/ any;
         calendar(): /*elided*/ any;
+        time(): /*elided*/ any;
         format(name: any, fn: any): /*elided*/ any;
         toString(): any;
         assertions: any[];
@@ -138,8 +140,9 @@ export function exportValidation(options?: {}): {
         validate(value: any, options?: {}): Promise<any>;
         clone(meta: any): /*elided*/ any;
         append(schema: any): import("@bedrockio/yada/types/Schema").default;
-        toJSON(extra?: any): any;
+        toJsonSchema(extra?: any): any;
         toOpenApi(...extra: any[]): any;
+        toJSON(): any;
         getAnyType(): {
             type: string[];
         };
@@ -226,6 +229,7 @@ export function exportValidation(options?: {}): {
         swift(): /*elided*/ any;
         mongo(): /*elided*/ any;
         calendar(): /*elided*/ any;
+        time(): /*elided*/ any;
         format(name: any, fn: any): /*elided*/ any;
         toString(): any;
         assertions: any[];
@@ -244,8 +248,9 @@ export function exportValidation(options?: {}): {
         validate(value: any, options?: {}): Promise<any>;
         clone(meta: any): /*elided*/ any;
         append(schema: any): import("@bedrockio/yada/types/Schema").default;
-        toJSON(extra?: any): any;
+        toJsonSchema(extra?: any): any;
         toOpenApi(...extra: any[]): any;
+        toJSON(): any;
         getAnyType(): {
             type: string[];
         };

package/types/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAuBA,gEAaC;AAED;;;;;;;;;;;;kBA8GU,CAAH;oBAEG,CAAR;qBAEU,CAAF;sBAEF,CAAJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;eArDF,CAAC;;;;;;;;;;;;;;;;;EAtCF;AAED;;;;;;;;;;;;;;;;;mBAtBI,CAAA;;;;;;;;;;;;qBAuBC,CAAC;sBAA4B,CAAC;sBACvB,CAAC;wBAA8B,CAAC;wBAEnC,CAAC;;;4BA4BN,CAAD;kCAAyC,CAAC;wBACtC,CAAC;wBAA+B,CAAC;wCAKlC,CAAA;2BAAkC,CAAC;kCACP,CAAC;2BAIhB,CAAC;qBAA4B,CAAC;;;uBAuB/C,CAAA;6BAEA,CAAA;8BAEK,CAAC;6BAAoC,CAAC;0BAClB,CAAC;6BAIjB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAvCV,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA1DC,CAAA;;;;;;;;;;;;qBAuBC,CAAC;sBAA4B,CAAC;sBACvB,CAAC;wBAA8B,CAAC;wBAEnC,CAAC;;;4BA4BN,CAAD;kCAAyC,CAAC;wBACtC,CAAC;wBAA+B,CAAC;wCAKlC,CAAA;2BAAkC,CAAC;kCACP,CAAC;2BAIhB,CAAC;qBAA4B,CAAC;;;uBAuB/C,CAAA;6BAEA,CAAA;8BAEK,CAAC;6BAAoC,CAAC;0BAClB,CAAC;6BAIjB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAvCV,CAAC;;;;;;;;;;;;;;;;;;;;EAvBF"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAuBA,gEAaC;AAED;;;;;;;;;;;;kBA8GU,CAAH;oBAEG,CAAR;qBAEU,CAAF;sBAEF,CAAJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAlDwB,CAAC;;;;;;;;;;;;;;;;;EAzC5B;AAED;;;;;;;;;;;;;;;;;mBAtBI,CAAA;;;;;;;;;;;;qBAuBC,CAAC;sBAA4B,CAAC;sBACvB,CAAC;wBAA8B,CAAC;wBAEnC,CAAC;;;4BA4BN,CAAD;kCAAyC,CAAC;wBACtC,CAAC;wBAA+B,CAAC;wCAKlC,CAAA;2BAAkC,CAAC;kCACP,CAAC;2BAIhB,CAAC;qBAA4B,CAAC;;;uBAuB/C,CAAA;6BAEA,CAAA;8BAEK,CAAC;6BAAoC,CAAC;0BAClB,CAAC;6BAIjB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBApCgB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA7DzB,CAAA;;;;;;;;;;;;qBAuBC,CAAC;sBAA4B,CAAC;sBACvB,CAAC;wBAA8B,CAAC;wBAEnC,CAAC;;;4BA4BN,CAAD;kCAAyC,CAAC;wBACtC,CAAC;wBAA+B,CAAC;wCAKlC,CAAA;2BAAkC,CAAC;kCACP,CAAC;2BAIhB,CAAC;qBAA4B,CAAC;;;uBAuB/C,CAAA;6BAEA,CAAA;8BAEK,CAAC;6BAAoC,CAAC;0BAClB,CAAC;6BAIjB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBApCgB,CAAC;;;;;;;;;;;;;;;;;;;;EA1B5B"}

package/types/utils.d.ts

@@ -13,5 +13,6 @@ export function resolveRefPath(schema: any, path: any): {
     foreign: any;
 };
 export function getInnerField(obj: any, path: any): any;
+export function getSchemaPaths(schema: any): any;
 import mongoose from 'mongoose';
 //# sourceMappingURL=utils.d.ts.map

package/types/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.js"],"names":[],"mappings":"AAQA,iDAcC;AAED,gHAEC;AAED,+DAEC;AAED,0DAEC;AAED,4DAEC;AAED,4DAEC;AAED,2DAGC;AAOD,mDAGC;AAuBD,mDAgBC;AAKD;;;;EAoBC;AAKD,wDAEC;qBAhIoB,UAAU"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.js"],"names":[],"mappings":"AAQA,iDAcC;AAED,gHAEC;AAED,+DAEC;AAED,0DAEC;AAED,4DAEC;AAED,4DAEC;AAED,2DAGC;AAOD,mDAGC;AAuBD,mDAgBC;AAKD;;;;EAoBC;AAKD,wDAEC;AAcD,iDAYC;qBA1JoB,UAAU"}

package/types/validation-schemas.d.ts

@@ -25,8 +25,9 @@ export const DATE_SCHEMA: {
     validate(value: any, options?: {}): Promise<any>;
     clone(meta: any): /*elided*/ any;
     append(schema: any): import("@bedrockio/yada/types/Schema").default;
-    toJSON(extra?: any): any;
+    toJsonSchema(extra?: any): any;
     toOpenApi(...extra: any[]): any;
+    toJSON(): any;
     getAnyType(): {
         type: string[];
     };
@@ -113,6 +114,7 @@ export const OBJECT_ID_SCHEMA: {
     swift(): /*elided*/ any;
     mongo(): /*elided*/ any;
     calendar(): /*elided*/ any;
+    time(): /*elided*/ any;
     format(name: any, fn: any): /*elided*/ any;
     toString(): any;
     assertions: any[];
@@ -131,8 +133,9 @@ export const OBJECT_ID_SCHEMA: {
     validate(value: any, options?: {}): Promise<any>;
     clone(meta: any): /*elided*/ any;
     append(schema: any): import("@bedrockio/yada/types/Schema").default;
-    toJSON(extra?: any): any;
+    toJsonSchema(extra?: any): any;
     toOpenApi(...extra: any[]): any;
+    toJSON(): any;
     getAnyType(): {
         type: string[];
     };
@@ -194,8 +197,9 @@ export const NUMBER_RANGE_SCHEMA: {
     description(description: any): /*elided*/ any;
     validate(value: any, options?: {}): Promise<any>;
     clone(meta: any): /*elided*/ any;
-    toJSON(extra?: any): any;
+    toJsonSchema(extra?: any): any;
     toOpenApi(...extra: any[]): any;
+    toJSON(): any;
     getAnyType(): {
         type: string[];
     };
@@ -255,8 +259,9 @@ export const STRING_RANGE_SCHEMA: {
     description(description: any): /*elided*/ any;
     validate(value: any, options?: {}): Promise<any>;
     clone(meta: any): /*elided*/ any;
-    toJSON(extra?: any): any;
+    toJsonSchema(extra?: any): any;
     toOpenApi(...extra: any[]): any;
+    toJSON(): any;
     getAnyType(): {
         type: string[];
     };
@@ -316,8 +321,9 @@ export const DATE_RANGE_SCHEMA: {
     description(description: any): /*elided*/ any;
     validate(value: any, options?: {}): Promise<any>;
     clone(meta: any): /*elided*/ any;
-    toJSON(extra?: any): any;
+    toJsonSchema(extra?: any): any;
     toOpenApi(...extra: any[]): any;
+    toJSON(): any;
     getAnyType(): {
         type: string[];
     };
@@ -378,8 +384,9 @@ export const INCLUDE_FIELD_SCHEMA: {
     description(description: any): /*elided*/ any;
     validate(value: any, options?: {}): Promise<any>;
     clone(meta: any): /*elided*/ any;
-    toJSON(extra?: any): any;
+    toJsonSchema(extra?: any): any;
     toOpenApi(...extra: any[]): any;
+    toJSON(): any;
     getAnyType(): {
         type: string[];
     };

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAwFsB,CAAC;;;;;;;;;;;;;;;;;;;EAxFmC;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;;;mBAW0D,CAAC;yBAAoC,CAAC;0BAAqC,CAAC;yBAAoC,CAAC;sBAAiC,CAAC;yBAAoC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAdpR,CAAC;;;;;;;;;;;;;;;;;;;EA9ElB;AAEL;;;;;;;;;;;;kBA0Fmb,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAdjgB,CAAC;;;;;;;;;;;;;;;;;EAlElB;AAEL;;;;;;;;;;;;kBA8Emb,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAdjgB,CAAC;;;;;;;;;;;;;;;;;EAtDlB;AAEL;;;;;;;;;;;;kBAkEmb,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAdjgB,CAAC;;;;;;;;;;;;;;;;;EAlBlB;AAEL,8EAqBK;AAEL;;;;;;;;;;;;kBAOmb,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAdjgB,CAAC;;;;;;;;;;;;;;;;;EAapB"}
+{"version":3,"file":"validation-schemas.d.ts","sourceRoot":"","sources":["../src/validation-schemas.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA0F4E,CAAC;;;;;;;;;;;;;;;;;;;EA1FnB;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;;;mBAW0D,CAAC;yBAAoC,CAAC;0BAAqC,CAAC;yBAAoC,CAAC;sBAAiC,CAAC;yBAAoC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAZ9N,CAAC;;;;;;;;;;;;;;;;;;;EAhFxE;AAEL;;;;;;;;;;;;kBA0Fmb,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAZ3c,CAAC;;;;;;;;;;;;;;;;;EApExE;AAEL;;;;;;;;;;;;kBA8Emb,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAZ3c,CAAC;;;;;;;;;;;;;;;;;EAxDxE;AAEL;;;;;;;;;;;;kBAkEmb,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAZ3c,CAAC;;;;;;;;;;;;;;;;;EApBxE;AAEL,8EAqBK;AAEL;;;;;;;;;;;;kBAOmb,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAZ3c,CAAC;;;;;;;;;;;;;;;;;EAW1E"}

package/types/validation.d.ts.map

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