@bedrockio/model 0.14.3 → 0.15.0

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 0.15.0
+
+- Tagged outer includes schema.
+- `allowInclude` -> `allowIncludes`.
+- Inclues not allowed on `getUpdateValidation` by default (revert of `0.14.1`).
+
+## 0.14.4
+
+- Fixed bug with nested includes in update validation.
+
 ## 0.14.3
 
 - Allow keyword search on number fields.

package/dist/cjs/include.js

@@ -3,12 +3,10 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.INCLUDE_FIELD_SCHEMA = void 0;
 exports.applyInclude = applyInclude;
 exports.checkSelects = checkSelects;
 exports.getDocumentParams = getDocumentParams;
 exports.getParams = getParams;
-var _yada = _interopRequireDefault(require("@bedrockio/yada"));
 var _lodash = require("lodash");
 var _mongoose = _interopRequireDefault(require("mongoose"));
 var _const = require("./const");
@@ -24,10 +22,6 @@ _mongoose.default.Query.prototype.include = function include(arg) {
   }
   return this;
 };
-const DESCRIPTION = 'Field to be selected or populated.';
-const INCLUDE_FIELD_SCHEMA = exports.INCLUDE_FIELD_SCHEMA = _yada.default.object({
-  include: _yada.default.allow(_yada.default.string().description(DESCRIPTION), _yada.default.array(_yada.default.string().description(DESCRIPTION)))
-});
 function applyInclude(schema) {
   // Query Includes
 

package/dist/cjs/validation-schemas.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.STRING_RANGE_SCHEMA = exports.REFERENCE_SCHEMA = exports.OBJECT_ID_SCHEMA = exports.NUMBER_RANGE_SCHEMA = exports.DATE_SCHEMA = exports.DATE_RANGE_SCHEMA = void 0;
+exports.STRING_RANGE_SCHEMA = exports.REFERENCE_SCHEMA = exports.OBJECT_ID_SCHEMA = exports.NUMBER_RANGE_SCHEMA = exports.INCLUDE_FIELD_SCHEMA = exports.DATE_SCHEMA = exports.DATE_RANGE_SCHEMA = void 0;
 var _yada = _interopRequireDefault(require("@bedrockio/yada"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const DATE_TAGS = {
@@ -66,4 +66,10 @@ const REFERENCE_SCHEMA = exports.REFERENCE_SCHEMA = _yada.default.allow(OBJECT_I
 A 24 character hexadecimal string representing a Mongo [ObjectId](https://bit.ly/3YPtGlU).
 An object with an \`id\` field may also be passed, which will be converted into a string.
     `.trim()
+});
+const INCLUDE_FIELD_SCHEMA = exports.INCLUDE_FIELD_SCHEMA = _yada.default.object({
+  include: _yada.default.allow(_yada.default.string(), _yada.default.array(_yada.default.string())).tag({
+    'x-schema': 'Includes',
+    'x-description': 'A `string` or `array` of fields to be selected or populated using [includes syntax](http://bit.ly/4q2viXl).'
+  })
 });

package/dist/cjs/validation.js

@@ -10,10 +10,8 @@ exports.getTupleValidator = getTupleValidator;
 exports.getValidationSchema = getValidationSchema;
 var _yada = _interopRequireDefault(require("@bedrockio/yada"));
 var _lodash = require("lodash");
-var _mongoose = _interopRequireDefault(require("mongoose"));
 var _access = require("./access");
 var _errors = require("./errors");
-var _include = require("./include");
 var _search = require("./search");
 var _softDelete = require("./soft-delete");
 var _utils = require("./utils");
@@ -59,12 +57,12 @@ function addValidators(schemas) {
 }
 function applyValidation(schema, definition) {
   schema.static('getCreateValidation', function getCreateValidation(options) {
-    return getSchemaFromMongoose(schema, {
+    return getSchemaForMongoose(schema, {
       model: this,
       stripEmpty: true,
       applyUnique: true,
       stripDeleted: true,
-      allowInclude: false,
+      allowIncludes: false,
       stripTimestamps: true,
       allowDefaultTags: true,
       allowExpandedRefs: true,
@@ -73,7 +71,7 @@ function applyValidation(schema, definition) {
     });
   });
   schema.static('getUpdateValidation', function getUpdateValidation(options) {
-    return getSchemaFromMongoose(schema, {
+    return getSchemaForMongoose(schema, {
       model: this,
       allowNull: true,
       applyUnique: true,
@@ -81,7 +79,7 @@ function applyValidation(schema, definition) {
       stripUnknown: true,
       stripDeleted: true,
       allowFlatKeys: true,
-      allowInclude: true,
+      allowIncludes: false,
       stripTimestamps: true,
       allowExpandedRefs: true,
       requireWriteAccess: true,
@@ -96,15 +94,15 @@ function applyValidation(schema, definition) {
       formats,
       ...rest
     } = options;
-    let validation = getSchemaFromMongoose(schema, {
+    let validation = getSchemaForMongoose(schema, {
       model: this,
       allowNull: true,
       stripEmpty: true,
       allowSearch: true,
       skipRequired: true,
-      allowInclude: true,
       stripDeleted: true,
       allowFlatKeys: true,
+      allowIncludes: true,
       unwindArrayFields: true,
       requireReadAccess: true,
       ...rest
@@ -129,10 +127,10 @@ function applyValidation(schema, definition) {
     });
   });
   schema.static('getIncludeValidation', function getIncludeValidation() {
-    return _include.INCLUDE_FIELD_SCHEMA;
+    return _validationSchemas.INCLUDE_FIELD_SCHEMA;
   });
   schema.static('getBaseSchema', function getBaseSchema() {
-    return getSchemaFromMongoose(schema, {
+    return getSchemaForMongoose(schema, {
       model: this,
       stripDeleted: true,
       requireReadAccess: true
@@ -142,7 +140,7 @@ function applyValidation(schema, definition) {
 
 // Yada schemas
 
-function getSchemaFromMongoose(schema, options = {}) {
+function getSchemaForMongoose(schema, options = {}) {
   const fields = getMongooseFields(schema, options);
   return getValidationSchema(fields, options);
 }
@@ -164,12 +162,12 @@ function getMongooseFields(schema, options) {
 // Exported for testing
 function getValidationSchema(attributes, options = {}) {
   const {
-    allowInclude,
+    allowIncludes,
     updateAccess
   } = options;
   let schema = getObjectSchema(attributes, options);
-  if (allowInclude) {
-    schema = schema.append(_include.INCLUDE_FIELD_SCHEMA);
+  if (allowIncludes) {
+    schema = schema.append(_validationSchemas.INCLUDE_FIELD_SCHEMA);
   }
   if (updateAccess) {
     return validateAccess('update', schema, updateAccess, {
@@ -182,7 +180,7 @@ function getValidationSchema(attributes, options = {}) {
 function getObjectSchema(arg, options) {
   if ((0, _utils.isSchemaTypedef)(arg)) {
     return getSchemaForTypedef(arg, options);
-  } else if (arg instanceof _mongoose.default.Schema) {
+  } else if ((0, _utils.isMongooseSchema)(arg)) {
     return getObjectSchema(arg.obj, options);
   } else if (Array.isArray(arg)) {
     return getArraySchema(arg, options);
@@ -244,7 +242,7 @@ function getSchemaForTypedef(typedef, options = {}) {
   } = typedef;
   let schema;
   if ((0, _utils.isMongooseSchema)(type)) {
-    schema = getSchemaFromMongoose(type, options);
+    schema = getObjectSchema(type, options);
   } else if (Array.isArray(type)) {
     schema = getArraySchema(type, options);
   } else if (typeof type === 'object') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/model",
-  "version": "0.14.3",
+  "version": "0.15.0",
   "description": "Bedrock utilities for model creation.",
   "type": "module",
   "scripts": {

package/src/include.js

@@ -1,4 +1,3 @@
-import yd from '@bedrockio/yada';
 import { escapeRegExp } from 'lodash';
 import mongoose from 'mongoose';
 
@@ -16,15 +15,6 @@ mongoose.Query.prototype.include = function include(arg) {
   return this;
 };
 
-const DESCRIPTION = 'Field to be selected or populated.';
-
-export const INCLUDE_FIELD_SCHEMA = yd.object({
-  include: yd.allow(
-    yd.string().description(DESCRIPTION),
-    yd.array(yd.string().description(DESCRIPTION)),
-  ),
-});
-
 export function applyInclude(schema) {
   // Query Includes
 

package/src/validation-schemas.js

@@ -100,3 +100,11 @@ A 24 character hexadecimal string representing a Mongo [ObjectId](https://bit.ly
 An object with an \`id\` field may also be passed, which will be converted into a string.
     `.trim(),
   });
+
+export const INCLUDE_FIELD_SCHEMA = yd.object({
+  include: yd.allow(yd.string(), yd.array(yd.string())).tag({
+    'x-schema': 'Includes',
+    'x-description':
+      'A `string` or `array` of fields to be selected or populated using [includes syntax](http://bit.ly/4q2viXl).',
+  }),
+});

package/src/validation.js

@@ -1,13 +1,12 @@
 import yd from '@bedrockio/yada';
 import { get, lowerFirst, omit } from 'lodash';
-import mongoose from 'mongoose';
 
 import { hasAccess } from './access';
 import { ImplementationError, PermissionsError } from './errors';
-import { INCLUDE_FIELD_SCHEMA } from './include';
 import { exportValidation, searchValidation } from './search';
 import { assertUnique } from './soft-delete';
 import { isMongooseSchema, isSchemaTypedef } from './utils';
+import { INCLUDE_FIELD_SCHEMA } from './validation-schemas';
 
 import {
   DATE_RANGE_SCHEMA,
@@ -62,12 +61,12 @@ export function addValidators(schemas) {
 
 export function applyValidation(schema, definition) {
   schema.static('getCreateValidation', function getCreateValidation(options) {
-    return getSchemaFromMongoose(schema, {
+    return getSchemaForMongoose(schema, {
       model: this,
       stripEmpty: true,
       applyUnique: true,
       stripDeleted: true,
-      allowInclude: false,
+      allowIncludes: false,
       stripTimestamps: true,
       allowDefaultTags: true,
       allowExpandedRefs: true,
@@ -77,7 +76,7 @@ export function applyValidation(schema, definition) {
   });
 
   schema.static('getUpdateValidation', function getUpdateValidation(options) {
-    return getSchemaFromMongoose(schema, {
+    return getSchemaForMongoose(schema, {
       model: this,
       allowNull: true,
       applyUnique: true,
@@ -85,7 +84,7 @@ export function applyValidation(schema, definition) {
       stripUnknown: true,
       stripDeleted: true,
       allowFlatKeys: true,
-      allowInclude: true,
+      allowIncludes: false,
       stripTimestamps: true,
       allowExpandedRefs: true,
       requireWriteAccess: true,
@@ -99,15 +98,15 @@ export function applyValidation(schema, definition) {
     function getSearchValidation(options = {}) {
       const { allowExport, defaults, formats, ...rest } = options;
 
-      let validation = getSchemaFromMongoose(schema, {
+      let validation = getSchemaForMongoose(schema, {
         model: this,
         allowNull: true,
         stripEmpty: true,
         allowSearch: true,
         skipRequired: true,
-        allowInclude: true,
         stripDeleted: true,
         allowFlatKeys: true,
+        allowIncludes: true,
         unwindArrayFields: true,
         requireReadAccess: true,
         ...rest,
@@ -146,7 +145,7 @@ export function applyValidation(schema, definition) {
   });
 
   schema.static('getBaseSchema', function getBaseSchema() {
-    return getSchemaFromMongoose(schema, {
+    return getSchemaForMongoose(schema, {
       model: this,
       stripDeleted: true,
       requireReadAccess: true,
@@ -156,7 +155,7 @@ export function applyValidation(schema, definition) {
 
 // Yada schemas
 
-function getSchemaFromMongoose(schema, options = {}) {
+function getSchemaForMongoose(schema, options = {}) {
   const fields = getMongooseFields(schema, options);
   return getValidationSchema(fields, options);
 }
@@ -175,11 +174,11 @@ function getMongooseFields(schema, options) {
 
 // Exported for testing
 export function getValidationSchema(attributes, options = {}) {
-  const { allowInclude, updateAccess } = options;
+  const { allowIncludes, updateAccess } = options;
 
   let schema = getObjectSchema(attributes, options);
 
-  if (allowInclude) {
+  if (allowIncludes) {
     schema = schema.append(INCLUDE_FIELD_SCHEMA);
   }
 
@@ -196,7 +195,7 @@ export function getValidationSchema(attributes, options = {}) {
 function getObjectSchema(arg, options) {
   if (isSchemaTypedef(arg)) {
     return getSchemaForTypedef(arg, options);
-  } else if (arg instanceof mongoose.Schema) {
+  } else if (isMongooseSchema(arg)) {
     return getObjectSchema(arg.obj, options);
   } else if (Array.isArray(arg)) {
     return getArraySchema(arg, options);
@@ -261,7 +260,7 @@ function getSchemaForTypedef(typedef, options = {}) {
   let schema;
 
   if (isMongooseSchema(type)) {
-    schema = getSchemaFromMongoose(type, options);
+    schema = getObjectSchema(type, options);
   } else if (Array.isArray(type)) {
     schema = getArraySchema(type, options);
   } else if (typeof type === 'object') {

package/types/include.d.ts

@@ -2,65 +2,4 @@ export function applyInclude(schema: any): void;
 export function checkSelects(doc: any, ret: any): void;
 export function getParams(modelName: any, arg: any): any;
 export function getDocumentParams(doc: any, arg: any, options?: {}): any;
-export const INCLUDE_FIELD_SCHEMA: {
-    setup(): void;
-    get(path?: string | Array<string>): any;
-    unwind(path?: string | Array<string>): any;
-    pick(...names?: string[]): /*elided*/ any;
-    omit(...names?: string[]): /*elided*/ any;
-    require(...fields: string[]): /*elided*/ any;
-    requireAll(): /*elided*/ any;
-    requireAllWithin(): /*elided*/ any;
-    export(): any;
-    append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
-    options(options?: {
-        stripEmpty?: boolean;
-        stripUnknown?: boolean;
-        allowFlatKeys?: boolean;
-        expandFlatKeys?: boolean;
-    }): /*elided*/ any;
-    format(name: any, fn: any): /*elided*/ any;
-    toString(): any;
-    assertions: any[];
-    meta: {};
-    required(): /*elided*/ any;
-    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;
-    validate(value: any, options?: {}): Promise<any>;
-    clone(meta: any): /*elided*/ any;
-    toJSON(extra?: any): any;
-    toOpenApi(...extra: any[]): any;
-    getAnyType(): {
-        type: string[];
-    };
-    getFormat(): {
-        format: any;
-    };
-    getDefault(): {
-        default?: undefined;
-    } | {
-        default: any;
-    };
-    getNullable(): {
-        nullable: boolean;
-    };
-    getEnum(): any;
-    expandExtra(extra?: {}): {};
-    inspect(): string;
-    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>;
-};
 //# sourceMappingURL=include.d.ts.map

package/types/include.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"include.d.ts","sourceRoot":"","sources":["../src/include.js"],"names":[],"mappings":"AA2BA,gDAuEC;AAMD,uDA4BC;AAGD,yDAIC;AAaD,yEAUC;AA9ID;;;;;;;;;;;;kBAwGwB,CAAC;oBAEnB,CADL;qBAAgC,CAAC;sBACxB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAnCqD,CAAC;;;;;;;;;;;;;;;;;EAlE9D"}
+{"version":3,"file":"include.d.ts","sourceRoot":"","sources":["../src/include.js"],"names":[],"mappings":"AAiBA,gDAuEC;AAMD,uDA4BC;AAGD,yDAIC;AAaD,yEAUC"}

package/types/validation-schemas.d.ts

@@ -344,4 +344,65 @@ export const DATE_RANGE_SCHEMA: {
     runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
 };
 export const REFERENCE_SCHEMA: import("@bedrockio/yada/types/Schema").default;
+export const INCLUDE_FIELD_SCHEMA: {
+    setup(): void;
+    get(path?: string | Array<string>): any;
+    unwind(path?: string | Array<string>): any;
+    pick(...names?: string[]): /*elided*/ any;
+    omit(...names?: string[]): /*elided*/ any;
+    require(...fields: string[]): /*elided*/ any;
+    requireAll(): /*elided*/ any;
+    requireAllWithin(): /*elided*/ any;
+    export(): any;
+    append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
+    options(options?: {
+        stripEmpty?: boolean;
+        stripUnknown?: boolean;
+        allowFlatKeys?: boolean;
+        expandFlatKeys?: boolean;
+    }): /*elided*/ any;
+    format(name: any, fn: any): /*elided*/ any;
+    toString(): any;
+    assertions: any[];
+    meta: {};
+    required(): /*elided*/ any;
+    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;
+    validate(value: any, options?: {}): Promise<any>;
+    clone(meta: any): /*elided*/ any;
+    toJSON(extra?: any): any;
+    toOpenApi(...extra: any[]): any;
+    getAnyType(): {
+        type: string[];
+    };
+    getFormat(): {
+        format: any;
+    };
+    getDefault(): {
+        default?: undefined;
+    } | {
+        default: any;
+    };
+    getNullable(): {
+        nullable: boolean;
+    };
+    getEnum(): any;
+    expandExtra(extra?: {}): {};
+    inspect(): string;
+    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>;
+};
 //# sourceMappingURL=validation-schemas.d.ts.map

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;;;mBAG0V,CAAC;yBAAoC,CAAC;0BAAqC,CAAC;yBAAoC,CAAC;sBAAiC,CAAC;yBAAoC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eANpjB,CAAC;;;;;;;;;;;;;;;;;;;EA9ElB;AAEL;;;;;;;;;;;;kBAkFmtB,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;eANjyB,CAAC;;;;;;;;;;;;;;;;;EAlElB;AAEL;;;;;;;;;;;;kBAsEmtB,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;eANjyB,CAAC;;;;;;;;;;;;;;;;;EAtDlB;AAEL;;;;;;;;;;;;kBA0DmtB,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;eANjyB,CAAC;;;;;;;;;;;;;;;;;EAlBlB;AAEL,8EAqBK"}
+{"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;;;mBAW2D,CAAC;yBAAoC,CAAC;0BAAqC,CAAC;yBAAoC,CAAC;sBAAiC,CAAC;yBAAoC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAdrR,CAAC;;;;;;;;;;;;;;;;;;;EA9ElB;AAEL;;;;;;;;;;;;kBA0Fob,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAdlgB,CAAC;;;;;;;;;;;;;;;;;EAlElB;AAEL;;;;;;;;;;;;kBA8Eob,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAdlgB,CAAC;;;;;;;;;;;;;;;;;EAtDlB;AAEL;;;;;;;;;;;;kBAkEob,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAdlgB,CAAC;;;;;;;;;;;;;;;;;EAlBlB;AAEL,8EAqBK;AAEL;;;;;;;;;;;;kBAOob,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAdlgB,CAAC;;;;;;;;;;;;;;;;;EAapB"}

package/types/validation.d.ts.map

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