@bedrockio/model 0.14.4 → 0.16.0

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 0.16.0
+
+- Added `upsert` method.
+
+## 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.

package/README.md

@@ -931,6 +931,20 @@ caller does not need to know whether the path contains subdocuments or foreign
 references. As Bedrock has knowledge of the schemas, it is able to build the
 appropriate call to `populate` for you.
 
+#### Include Syntax
+
+| Example           | Type      | Populated | Description                                          |
+| ----------------- | --------- | --------- | ---------------------------------------------------- |
+| `shop`            | Inclusive | shop      | Populates top level document.                        |
+| `shop.user`       | Inclusive | shop/user | Populates two levels deep.                           |
+| `^name`           | Exclusive |           | Selects only `name`.                                 |
+| `^shop.name`      | Exclusive | shop      | Selects only `shop.name`.                            |
+| `^shop.user.name` | Exclusive | shop/user | Selects only `shop.user.name`.                       |
+| `shop.^user.name` | Exclusive | shop/user | Selects root fields and `shop.user.name`.            |
+| `shop.user.^name` | Exclusive | shop/user | Selects root and `shop` fields and `shop.user.name`. |
+| `*Name`           | Wildcard  |           | Matches any root field ending with `Name`.           |
+| `**Name`          | Wildcard  |           | Matches any root or nested field ending with `Name`. |
+
 #### Exclusive Fields
 
 By default, arguments to `include` are for population. However often field
@@ -1650,35 +1664,52 @@ string, both of which would be stored in the database if naively assigned with
 
 ### Upsert
 
-This module adds a single `findOrCreate` convenience method that is easy to
-understand and avoids some of the gotchas that come with upserting documents in
-Mongoose:
+This module adds two similar methods:
+
+- `upsert`
+- `findOrCreate`
+
+The `upsert` method is used when documents must always be overwritten with the
+latest data.
 
 ```js
-const shop = await Shop.findOrCreate({
-  name: 'My Shop',
-});
+const shop = await Shop.upsert(
+  {
+    name: 'My Shop',
+  },
+  {
+    name: 'My Shop',
+    slug: 'my-shop',
+  },
+);
+
+// This is equivalent to:
 
-// This is equivalent to running:
 let shop = await Shop.findOne({
   name: 'My Shop',
 });
 
-if (!shop) {
+if (shop) {
+  shop.assign({
+    name: 'My Shop',
+    slug: 'my-shop',
+  });
+  await shop.save();
+} else {
   shop = await Shop.create({
     name: 'My Shop',
+    slug: 'my-shop',
   });
 }
 ```
 
-In most cases not all of the fields should be queried on to determine if an
-existing document exists. In this case two arguments should be passed the first
-of which is the query:
+The `findOrCreate` method does just whan the name implies and will return the
+document it finds without modifying it.
 
 ```js
 const shop = await Shop.findOrCreate(
   {
-    slug: 'my-shop',
+    name: 'My Shop',
   },
   {
     name: 'My Shop',
@@ -1686,9 +1717,10 @@ const shop = await Shop.findOrCreate(
   },
 );
 
-// This is equivalent to running:
+// This is equivalent to:
+
 let shop = await Shop.findOne({
-  slug: 'my-shop',
+  name: 'My Shop',
 });
 
 if (!shop) {
@@ -1699,6 +1731,27 @@ if (!shop) {
 }
 ```
 
+Note that a single argument can also be passed as a shortcut to both the query
+and the update for simple cases:
+
+```js
+const shop = await Shop.findOrCreate({
+  name: 'My Shop',
+});
+
+// This is equivalent to:
+
+let shop = await Shop.findOne({
+  name: 'My Shop',
+});
+
+if (!shop) {
+  shop = await Shop.create({
+    name: 'My Shop',
+  });
+}
+```
+
 ### Clone
 
 Adds a single `clone` method on documents. This is an async method mostly for

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/upsert.js

@@ -5,11 +5,22 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.applyUpsert = applyUpsert;
 function applyUpsert(schema) {
-  // Note: Intentionally avoiding the findOneAndUpdate approach here
-  // as this will prevent hooks from being run on the document. This
-  // means however that we cannot always return a query here as the
-  // operations are inherently different.
+  // Note: Avoiding the findOneAndUpdate approach here as this
+  // will prevent hooks from being run on the document. This
+  // means however that we cannot always return a query here
+  // as the operations are inherently different.
 
+  schema.static('upsert', async function upsert(query, fields) {
+    fields ||= query;
+    let doc = await this.findOne(query);
+    if (doc) {
+      doc.assign(fields);
+      await doc.save();
+    } else {
+      doc = await this.create(fields);
+    }
+    return doc;
+  });
   schema.static('findOrCreate', async function findOrCreate(query, fields) {
     fields ||= query;
     let doc = await this.findOne(query);

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](https://bit.ly/4mZwSq4).'
+  })
 });

package/dist/cjs/validation.js

@@ -12,7 +12,6 @@ var _yada = _interopRequireDefault(require("@bedrockio/yada"));
 var _lodash = require("lodash");
 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");
@@ -63,7 +62,7 @@ function applyValidation(schema, definition) {
       stripEmpty: true,
       applyUnique: true,
       stripDeleted: true,
-      allowInclude: false,
+      allowIncludes: false,
       stripTimestamps: true,
       allowDefaultTags: true,
       allowExpandedRefs: true,
@@ -80,7 +79,7 @@ function applyValidation(schema, definition) {
       stripUnknown: true,
       stripDeleted: true,
       allowFlatKeys: true,
-      allowInclude: true,
+      allowIncludes: false,
       stripTimestamps: true,
       allowExpandedRefs: true,
       requireWriteAccess: true,
@@ -101,9 +100,9 @@ function applyValidation(schema, definition) {
       stripEmpty: true,
       allowSearch: true,
       skipRequired: true,
-      allowInclude: true,
       stripDeleted: true,
       allowFlatKeys: true,
+      allowIncludes: true,
       unwindArrayFields: true,
       requireReadAccess: true,
       ...rest
@@ -128,7 +127,7 @@ 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 getSchemaForMongoose(schema, {
@@ -163,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, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/model",
-  "version": "0.14.4",
+  "version": "0.16.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/upsert.js

@@ -1,8 +1,23 @@
 export function applyUpsert(schema) {
-  // Note: Intentionally avoiding the findOneAndUpdate approach here
-  // as this will prevent hooks from being run on the document. This
-  // means however that we cannot always return a query here as the
-  // operations are inherently different.
+  // Note: Avoiding the findOneAndUpdate approach here as this
+  // will prevent hooks from being run on the document. This
+  // means however that we cannot always return a query here
+  // as the operations are inherently different.
+
+  schema.static('upsert', async function upsert(query, fields) {
+    fields ||= query;
+
+    let doc = await this.findOne(query);
+
+    if (doc) {
+      doc.assign(fields);
+      await doc.save();
+    } else {
+      doc = await this.create(fields);
+    }
+
+    return doc;
+  });
 
   schema.static('findOrCreate', async function findOrCreate(query, fields) {
     fields ||= query;

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](https://bit.ly/4mZwSq4).',
+  }),
+});

package/src/validation.js

@@ -3,10 +3,10 @@ import { get, lowerFirst, omit } from 'lodash';
 
 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,
@@ -66,7 +66,7 @@ export function applyValidation(schema, definition) {
       stripEmpty: true,
       applyUnique: true,
       stripDeleted: true,
-      allowInclude: false,
+      allowIncludes: false,
       stripTimestamps: true,
       allowDefaultTags: true,
       allowExpandedRefs: true,
@@ -84,7 +84,7 @@ export function applyValidation(schema, definition) {
       stripUnknown: true,
       stripDeleted: true,
       allowFlatKeys: true,
-      allowInclude: true,
+      allowIncludes: false,
       stripTimestamps: true,
       allowExpandedRefs: true,
       requireWriteAccess: true,
@@ -104,9 +104,9 @@ export function applyValidation(schema, definition) {
         stripEmpty: true,
         allowSearch: true,
         skipRequired: true,
-        allowInclude: true,
         stripDeleted: true,
         allowFlatKeys: true,
+        allowIncludes: true,
         unwindArrayFields: true,
         requireReadAccess: true,
         ...rest,
@@ -174,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);
   }
 

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/schema.d.ts

@@ -28,7 +28,9 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
     id?: boolean;
     _id?: boolean;
     minimize?: boolean;
-    optimisticConcurrency?: boolean;
+    optimisticConcurrency?: boolean | string[] | {
+        exclude: string[];
+    };
     pluginTags?: string[];
     read?: string;
     readConcern?: {
@@ -47,16 +49,16 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
         getters: boolean;
         versionKey: boolean;
         transform: (doc: any, ret: any, options: any) => void;
-    } | mongoose.ToObjectOptions<any>;
+    } | mongoose.ToObjectOptions<any, any>;
     toObject: {
         getters: boolean;
         versionKey: boolean;
         transform: (doc: any, ret: any, options: any) => void;
-    } | mongoose.ToObjectOptions<any>;
+    } | mongoose.ToObjectOptions<any, any>;
     typeKey?: string;
     validateBeforeSave?: boolean;
     validateModifiedOnly?: boolean;
-    versionKey?: string | boolean;
+    versionKey?: string | false;
     selectPopulatedPaths?: boolean;
     skipVersioning?: {
         [key: string]: boolean;
@@ -64,12 +66,13 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
     storeSubdocValidationError?: boolean;
     timestamps: boolean | mongoose.SchemaTimestampsConfig;
     suppressReservedKeysWarning?: boolean;
-    statics?: mongoose.AddThisParameter<any, mongoose.Model<any, {}, {}, {}, any, any>>;
+    statics?: mongoose.AddThisParameter<any, mongoose.Model<any, any, any, any, any, any>>;
     methods?: mongoose.AddThisParameter<any, any> & mongoose.AnyObject;
     query?: any;
     castNonArrays?: boolean;
     virtuals?: mongoose.SchemaOptionsVirtualsPropertyType<any, any, any>;
     overwriteModels?: boolean;
+    encryptionType?: "csfle" | "queryableEncryption";
 }, any, any>;
 export function normalizeAttributes(arg: any, path?: any[]): any;
 import mongoose from 'mongoose';

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;;;;;;;YA6CQ,CAAA;WACvC,CAAD;mBAAqB,CAAC;;;;;;;;;;;;;;;;;;;;;SAiHX,CAAC;gBAA4B,CAAA;SAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aApHpD;AAED,iEAsBC;qBA9FoB,UAAU"}
+{"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"}

package/types/upsert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"upsert.d.ts","sourceRoot":"","sources":["../src/upsert.js"],"names":[],"mappings":"AAAA,+CAiBC"}
+{"version":3,"file":"upsert.d.ts","sourceRoot":"","sources":["../src/upsert.js"],"names":[],"mappings":"AAAA,+CAgCC"}

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;;;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"}