@bedrockio/model 0.19.3 → 0.20.1

package/.claude/settings.local.json

@@ -7,7 +7,28 @@
       "WebFetch(domain:www.npmjs.com)",
       "WebFetch(domain:gist.github.com)",
       "WebFetch(domain:mongoosejs.com)",
-      "WebFetch(domain:github.com)"
+      "WebFetch(domain:github.com)",
+      "Bash(yarn types)",
+      "Bash(chmod:*)",
+      "Bash(find:*)",
+      "Read(//Users/andrew/Bedrock/core/services/api/**)",
+      "Bash(cat:*)",
+      "Bash(npx tsc:*)",
+      "Bash(npm install:*)",
+      "Bash(yarn add:*)",
+      "Bash(yarn tsc:*)",
+      "Bash(/dev/null)",
+      "Bash(echo \"Exit code: $?\")",
+      "Bash(tsc:*)",
+      "Read(//Users/andrew/Bedrock/yada/**)",
+      "Bash(scripts/types:*)",
+      "Bash(tree:*)",
+      "Bash(awk:*)",
+      "Bash(grep:*)",
+      "Bash(for file in types/modules/{clone,delete-hooks,export,include,soft-delete}.d.ts)",
+      "Bash(do)",
+      "Bash(done)",
+      "Bash(node_modules/.bin/prettier:*)"
     ],
     "deny": [],
     "ask": []

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.20.1
+
+- Fixed `_id: false` on array fields.
+
+## 0.20.0
+
+- Added types and documentation to all augmented methods.
+
 ## 0.19.3
 
 - Fixed issue with unknown sort fields throwing in aggregations.

package/README.md

@@ -26,6 +26,8 @@ Bedrock utilities for model creation.
   - [Reload](#reload)
   - [Clone](#clone)
   - [Slugs](#slugs)
+  - [Hydrate](#hydrate)
+  - [Export](#export)
 - [Testing](#testing)
 - [Troubleshooting](#troubleshooting)
 
@@ -1814,6 +1816,33 @@ is possible:
 
 However the likelyhood of such collisions on a slug are acceptably small.
 
+### Hydrate
+
+Overrides the default Mongoose `hydrate` method to only include fields defined
+in the schema. This prevents leaking extra data from aggregations:
+
+```js
+const user = User.hydrate({
+  _id: '507f1f77bcf86cd799439011',
+  name: 'John Doe',
+  email: 'john@example.com',
+  extraField: 'This will be excluded',
+});
+```
+
+### Export
+
+Adds an `export` method to documents that exports all defined schema paths into
+a plain object, excluding undefined values:
+
+```js
+const data = user.export();
+```
+
+> [!WARNING]
+> Note that this method is for internal use only. It bypasses all access control and may include sensitive data. Typical serialization of documents uses `toObject` or simply relies on the `toJSON` method of documents.
+
+
 ## Testing
 
 A helper `createTestModel` is exported to allow quickly building models for

package/dist/cjs/schema.js

@@ -29,8 +29,8 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
  * applied. For more about syntax and functionality see
  * [the documentation](https://github.com/bedrockio/model#schemas).
  * @param {object} definition
- * @param {mongoose.SchemaOptions} options
- * @returns mongoose.Schema
+ * @param {mongoose.SchemaOptions} [options]
+ * @returns {mongoose.Schema}
  */
 function createSchema(definition, options = {}) {
   (0, _cache.addCacheFields)(definition);
@@ -84,7 +84,13 @@ function normalizeAttributes(arg, path = []) {
   } else if (typeof arg === 'object') {
     const attributes = {};
     for (let [key, val] of Object.entries(arg)) {
-      attributes[key] = normalizeAttributes(val, [...path, key]);
+      if (key === '_id' && val === false) {
+        // This is a special case in Mongoose that allows disabling
+        // the _id field for array objects so perserve it here.
+        attributes[key] = val;
+      } else {
+        attributes[key] = normalizeAttributes(val, [...path, key]);
+      }
     }
     return attributes;
   }

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@bedrockio/model",
-  "version": "0.19.3",
+  "version": "0.20.1",
   "description": "Bedrock utilities for model creation.",
   "type": "module",
   "scripts": {
     "test": "jest",
-    "types": "tsc",
+    "types": "scripts/types",
     "lint": "eslint",
     "build": "scripts/build",
     "eject": "scripts/eject.js",
@@ -39,7 +39,7 @@
     "@babel/preset-env": "^7.26.0",
     "@bedrockio/eslint-plugin": "^1.2.2",
     "@bedrockio/prettier-config": "^1.1.1",
-    "@bedrockio/yada": "^1.10.3",
+    "@bedrockio/yada": "^1.10.6",
     "@shelf/jest-mongodb": "^5.2.2",
     "eslint": "^9.36.0",
     "jest": "^30.2.0",

package/src/schema.js

@@ -28,8 +28,8 @@ import {
  * applied. For more about syntax and functionality see
  * [the documentation](https://github.com/bedrockio/model#schemas).
  * @param {object} definition
- * @param {mongoose.SchemaOptions} options
- * @returns mongoose.Schema
+ * @param {mongoose.SchemaOptions} [options]
+ * @returns {mongoose.Schema}
  */
 export function createSchema(definition, options = {}) {
   addCacheFields(definition);
@@ -89,7 +89,13 @@ export function normalizeAttributes(arg, path = []) {
   } else if (typeof arg === 'object') {
     const attributes = {};
     for (let [key, val] of Object.entries(arg)) {
-      attributes[key] = normalizeAttributes(val, [...path, key]);
+      if (key === '_id' && val === false) {
+        // This is a special case in Mongoose that allows disabling
+        // the _id field for array objects so perserve it here.
+        attributes[key] = val;
+      } else {
+        attributes[key] = normalizeAttributes(val, [...path, key]);
+      }
     }
     return attributes;
   }

package/tsconfig.validate.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["types/index.d.ts"],
+  "compilerOptions": {
+    "noEmit": true,
+    "skipLibCheck": false
+  }
+}

package/types/generated/access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"access.d.ts","sourceRoot":"","sources":["../../src/access.js"],"names":[],"mappings":"AAIA;;GAEG;AACH,oCAFW,MAAM,GAAC,MAAM,EAAE,yBA2BzB"}

package/types/{assign.d.ts.map → generated/assign.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"assign.d.ts","sourceRoot":"","sources":["../src/assign.js"],"names":[],"mappings":"AAEA,+CAKC"}
+{"version":3,"file":"assign.d.ts","sourceRoot":"","sources":["../../src/assign.js"],"names":[],"mappings":"AAEA,+CAKC"}

package/types/{cache.d.ts.map → generated/cache.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../src/cache.js"],"names":[],"mappings":"AASA,sDAeC;AAED,+DASC"}
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/cache.js"],"names":[],"mappings":"AASA,sDAeC;AAED,+DASC"}

package/types/{clone.d.ts.map → generated/clone.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"clone.d.ts","sourceRoot":"","sources":["../src/clone.js"],"names":[],"mappings":"AAQA,8CAIC"}
+{"version":3,"file":"clone.d.ts","sourceRoot":"","sources":["../../src/clone.js"],"names":[],"mappings":"AAQA,8CAIC"}

package/types/generated/const.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../../src/const.js"],"names":[],"mappings":";;;;;;;;AASA,iCAAkC,CAAC,CAAC"}

package/types/generated/delete-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-hooks.d.ts","sourceRoot":"","sources":["../../src/delete-hooks.js"],"names":[],"mappings":"AASA,wDAgBC;AAED,qEAqCC"}

package/types/{disallowed.d.ts.map → generated/disallowed.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"disallowed.d.ts","sourceRoot":"","sources":["../src/disallowed.js"],"names":[],"mappings":"AAEA,mDA+BC"}
+{"version":3,"file":"disallowed.d.ts","sourceRoot":"","sources":["../../src/disallowed.js"],"names":[],"mappings":"AAEA,mDA+BC"}

package/types/generated/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../src/env.js"],"names":[],"mappings":"AAAA,4BAAyC"}

package/types/generated/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.js"],"names":[],"mappings":"AAAA;CAA8C;AAE9C;IACE,uBAGC;IADC,UAAgB;CAEnB;AAED;IACE,wCAGC;IADC,aAAsB;CAEzB;AAED;IACE,wCAGC;IADC,aAAsB;IAGxB;;;MAKC;CACF"}

package/types/{export.d.ts.map → generated/export.d.ts.map}

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

package/types/{hydrate.d.ts.map → generated/hydrate.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"hydrate.d.ts","sourceRoot":"","sources":["../src/hydrate.js"],"names":[],"mappings":"AAUA,gDAIC"}
+{"version":3,"file":"hydrate.d.ts","sourceRoot":"","sources":["../../src/hydrate.js"],"names":[],"mappings":"AAUA,gDAIC"}

package/types/generated/include.d.ts.map

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

package/types/generated/index.d.ts

@@ -0,0 +1,7 @@
+export { createSchema } from "./schema";
+export { addValidators } from "./validation";
+export { isEqual } from "./utils";
+export * from "./testing";
+export * from "./errors";
+export { loadModel, loadModelDir } from "./load";
+//# sourceMappingURL=index.d.ts.map

package/types/{index.d.ts.map → generated/index.d.ts.map}

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

package/types/generated/load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../src/load.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,sCAJW,MAAM,QACN,MAAM,OAahB;AAED;;;;GAIG;AACH,sCAFW,MAAM,mBAkBhB;qBA3CoB,UAAU"}

package/types/{query.d.ts.map → generated/query.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.js"],"names":[],"mappings":"AAIA,oDAUC;AAED,0DAWC"}
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/query.js"],"names":[],"mappings":"AAIA,oDAUC;AAED,0DAWC"}

package/types/{reload.d.ts.map → generated/reload.d.ts.map}

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

package/types/generated/schema.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Creates a new Mongoose schema with Bedrock extensions
+ * applied. For more about syntax and functionality see
+ * [the documentation](https://github.com/bedrockio/model#schemas).
+ * @param {object} definition
+ * @param {mongoose.SchemaOptions} [options]
+ * @returns {mongoose.Schema}
+ */
+export function createSchema(definition: object, options?: mongoose.SchemaOptions): mongoose.Schema;
+export function normalizeAttributes(arg: any, path?: any[]): any;
+import mongoose from 'mongoose';
+//# sourceMappingURL=schema.d.ts.map

package/types/generated/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/schema.js"],"names":[],"mappings":"AAyBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,QAAQ,CAAC,aAAa,GACpB,QAAQ,CAAC,MAAM,CAgD3B;AAED,iEAoBC;qBApGoB,UAAU"}

package/types/{search.d.ts → generated/search.d.ts}

@@ -1,15 +1,20 @@
 export function applySearch(schema: any, definition: any): void;
 export function searchValidation(options?: {}): {
+    validateInput(): void;
     setup(): void;
     get(path?: string | Array<string>): any;
     unwind(path?: string | Array<string>): any;
-    pick(...names?: string[]): /*elided*/ any;
-    omit(...names?: string[]): /*elided*/ any;
+    pick(...names: string[]): /*elided*/ any;
+    omit(...names: string[]): /*elided*/ any;
     require(...fields: string[]): /*elided*/ any;
     requireAll(): /*elided*/ any;
     transform(fn: Function, root?: boolean): /*elided*/ any;
     export(): any;
     append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
+    stripEmpty(): /*elided*/ any;
+    stripUnknown(): /*elided*/ any;
+    allowFlatKeys(): /*elided*/ any;
+    expandFlatKeys(): /*elided*/ any;
     options(options?: {
         stripEmpty?: boolean;
         stripUnknown?: boolean;

package/types/generated/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/search.js"],"names":[],"mappings":"AAuBA,gEAaC;AAED;;;;;;;;;;;;;;;;;kBAwIQ,CAAJ;oBAEE,CAAA;qBAKO,CAAC;sBACG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAnDkB,CAAA;;;;;;;;;;;;;;EApElC;AAED;;;;;;;;;;;;;;;;mBA1BmD,CAAC;;;;;;;;;;;;qBAuBlD,CAAC;sBAGmB,CAAC;sBACrB,CAAC;wBAA8B,CAAC;wBACrB,CAAC;;;4BAwBc,CAAC;kCAK3B,CAAD;wBACc,CAAC;wBAA+B,CAAC;wCACtB,CAAC;2BAGhB,CAAC;kCAES,CAAC;2BACd,CAAC;qBACL,CAAJ;;;uBAuBgC,CAAC;6BAEjB,CAAC;8BACF,CAAC;6BACD,CAAC;0BAIZ,CAAA;6BACmB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBANW,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA5FgB,CAAC;;;;;;;;;;;;qBAuBlD,CAAC;sBAGmB,CAAC;sBACrB,CAAC;wBAA8B,CAAC;wBACrB,CAAC;;;4BAwBc,CAAC;kCAK3B,CAAD;wBACc,CAAC;wBAA+B,CAAC;wCACtB,CAAC;2BAGhB,CAAC;kCAES,CAAC;2BACd,CAAC;qBACL,CAAJ;;;uBAuBgC,CAAC;6BAEjB,CAAC;8BACF,CAAC;6BACD,CAAC;0BAIZ,CAAA;6BACmB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBANW,CAAA;;;;;;;;;;;;;;;;;EArDlC"}

package/types/generated/serialization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialization.d.ts","sourceRoot":"","sources":["../../src/serialization.js"],"names":[],"mappings":";;;IAWa,2DAIV"}

package/types/generated/slug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slug.d.ts","sourceRoot":"","sources":["../../src/slug.js"],"names":[],"mappings":"AAIA,6CAsBC"}

package/types/generated/soft-delete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"soft-delete.d.ts","sourceRoot":"","sources":["../../src/soft-delete.js"],"names":[],"mappings":"AAMA,mDAIC;AAED,0DAwBC"}

package/types/generated/testing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../../src/testing.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,qDAiBC;AAED,2CAEC"}

package/types/{upsert.d.ts.map → generated/upsert.d.ts.map}

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

package/types/generated/utils.d.ts.map

@@ -0,0 +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;AAsBD,iDAYC;qBAlKoB,UAAU"}

package/types/{validation-schemas.d.ts → generated/validation-schemas.d.ts}

@@ -162,16 +162,21 @@ export const OBJECT_ID_SCHEMA: {
     runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
 };
 export const NUMBER_RANGE_SCHEMA: {
+    validateInput(): void;
     setup(): void;
     get(path?: string | Array<string>): any;
     unwind(path?: string | Array<string>): any;
-    pick(...names?: string[]): /*elided*/ any;
-    omit(...names?: string[]): /*elided*/ any;
+    pick(...names: string[]): /*elided*/ any;
+    omit(...names: string[]): /*elided*/ any;
     require(...fields: string[]): /*elided*/ any;
     requireAll(): /*elided*/ any;
     transform(fn: Function, root?: boolean): /*elided*/ any;
     export(): any;
     append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
+    stripEmpty(): /*elided*/ any;
+    stripUnknown(): /*elided*/ any;
+    allowFlatKeys(): /*elided*/ any;
+    expandFlatKeys(): /*elided*/ any;
     options(options?: {
         stripEmpty?: boolean;
         stripUnknown?: boolean;
@@ -221,16 +226,21 @@ export const NUMBER_RANGE_SCHEMA: {
     runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
 };
 export const STRING_RANGE_SCHEMA: {
+    validateInput(): void;
     setup(): void;
     get(path?: string | Array<string>): any;
     unwind(path?: string | Array<string>): any;
-    pick(...names?: string[]): /*elided*/ any;
-    omit(...names?: string[]): /*elided*/ any;
+    pick(...names: string[]): /*elided*/ any;
+    omit(...names: string[]): /*elided*/ any;
     require(...fields: string[]): /*elided*/ any;
     requireAll(): /*elided*/ any;
     transform(fn: Function, root?: boolean): /*elided*/ any;
     export(): any;
     append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
+    stripEmpty(): /*elided*/ any;
+    stripUnknown(): /*elided*/ any;
+    allowFlatKeys(): /*elided*/ any;
+    expandFlatKeys(): /*elided*/ any;
     options(options?: {
         stripEmpty?: boolean;
         stripUnknown?: boolean;
@@ -280,16 +290,21 @@ export const STRING_RANGE_SCHEMA: {
     runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
 };
 export const DATE_RANGE_SCHEMA: {
+    validateInput(): void;
     setup(): void;
     get(path?: string | Array<string>): any;
     unwind(path?: string | Array<string>): any;
-    pick(...names?: string[]): /*elided*/ any;
-    omit(...names?: string[]): /*elided*/ any;
+    pick(...names: string[]): /*elided*/ any;
+    omit(...names: string[]): /*elided*/ any;
     require(...fields: string[]): /*elided*/ any;
     requireAll(): /*elided*/ any;
     transform(fn: Function, root?: boolean): /*elided*/ any;
     export(): any;
     append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
+    stripEmpty(): /*elided*/ any;
+    stripUnknown(): /*elided*/ any;
+    allowFlatKeys(): /*elided*/ any;
+    expandFlatKeys(): /*elided*/ any;
     options(options?: {
         stripEmpty?: boolean;
         stripUnknown?: boolean;
@@ -340,16 +355,21 @@ export const DATE_RANGE_SCHEMA: {
 };
 export const REFERENCE_SCHEMA: import("@bedrockio/yada/types/Schema").default;
 export const INCLUDE_FIELD_SCHEMA: {
+    validateInput(): void;
     setup(): void;
     get(path?: string | Array<string>): any;
     unwind(path?: string | Array<string>): any;
-    pick(...names?: string[]): /*elided*/ any;
-    omit(...names?: string[]): /*elided*/ any;
+    pick(...names: string[]): /*elided*/ any;
+    omit(...names: string[]): /*elided*/ any;
     require(...fields: string[]): /*elided*/ any;
     requireAll(): /*elided*/ any;
     transform(fn: Function, root?: boolean): /*elided*/ any;
     export(): any;
     append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
+    stripEmpty(): /*elided*/ any;
+    stripUnknown(): /*elided*/ any;
+    allowFlatKeys(): /*elided*/ any;
+    expandFlatKeys(): /*elided*/ any;
     options(options?: {
         stripEmpty?: boolean;
         stripUnknown?: boolean;

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

@@ -0,0 +1 @@
+{"version":3,"file":"validation-schemas.d.ts","sourceRoot":"","sources":["../../src/validation-schemas.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA2FwE,CAAC;aACjE,CAAC;uBAGc,CAAC;;;;;;;;;;;eAO2H,CAAC;;;;;;;;;;;;;;;;EAtG1F;AAE1D;;;;;;;;;;;;;;;eAwBwB,CAAC;;;;;;;;;;;;iBAoBjB,CAAC;kBAEC,CAAC;kBAEH,CAAH;oBAA8B,CAAC;oBAEhC,CAAD;;;wBA4BW,CAAC;8BAEK,CAAA;oBAEd,CAAF;oBAEiB,CAAC;oCACjB,CAAC;uBAEF,CAAD;8BACkB,CAAC;uBAAkC,CAAC;iBAA4B,CAAC;;;mBAYjC,CAAC;yBAAoC,CAAC;0BAAqC,CAAC;yBAAoC,CAAC;sBAAiC,CAAC;yBAAoC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAA1F,CAAC;;;;;;;;;;;;;;;;EA5F/I;AAEL;;;;;;;;;;;;;;;;;kBA0Fo4B,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAAr1B,CAAC;;;;;;;;;;;;;;EAhF/I;AAEL;;;;;;;;;;;;;;;;;kBA8Eo4B,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAAr1B,CAAC;;;;;;;;;;;;;;EApE/I;AAEL;;;;;;;;;;;;;;;;;kBAkEo4B,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAAr1B,CAAC;;;;;;;;;;;;;;EAhC/I;AAEL,8EAqBK;AAEL;;;;;;;;;;;;;;;;;kBAOo4B,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAAr1B,CAAC;;;;;;;;;;;;;;EADjJ"}

package/types/generated/validation.d.ts.map

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

package/types/generated/warn.d.ts.map

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

package/types/index.d.ts

@@ -1,7 +1,22 @@
-export { createSchema } from "./schema";
-export { addValidators } from "./validation";
-export { isEqual } from "./utils";
-export * from "./testing";
-export * from "./errors";
-export { loadModel, loadModelDir } from "./load";
-//# sourceMappingURL=index.d.ts.map
+/**
+ * Mongoose Model interface augmentations.
+ * Note that signatures inside these files must match mongoose
+ * 8.19.2 Model interface. Types script will fail if this package
+ * is bumped and that signature does not match.
+ */
+
+import './modules/search';
+import './modules/validation';
+import './modules/soft-delete';
+import './modules/upsert';
+import './modules/slug';
+import './modules/cache';
+import './modules/include';
+import './modules/hydrate';
+import './modules/assign';
+import './modules/clone';
+import './modules/reload';
+import './modules/export';
+import './modules/delete-hooks';
+
+export * from './generated/index';

package/types/modules/assign.d.ts

@@ -0,0 +1,22 @@
+declare module 'mongoose' {
+  interface Document {
+    /**
+     * Assigns fields to this document, converting falsy values (null, empty string) to undefined to ensure they are unset.
+     *
+     * @param {Object} fields - Object of fields to assign to the document
+     *
+     * @returns {void}
+     *
+     * @example
+     * ```js
+     * user.assign({
+     *   name: 'Jane Doe',
+     *   email: null
+     * });
+     * ```
+     *
+     * @see {@link https://github.com/bedrockio/model#assign}
+     */
+    assign(fields: any): void;
+  }
+}

package/types/modules/cache.d.ts

@@ -0,0 +1,31 @@
+import type { HydratedDocument } from 'mongoose';
+
+declare module 'mongoose' {
+  interface Model<
+    TRawDocType,
+    TQueryHelpers = {},
+    TInstanceMethods = {},
+    TVirtuals = {},
+    THydratedDocumentType = HydratedDocument<
+      TRawDocType,
+      TVirtuals & TInstanceMethods,
+      TQueryHelpers,
+      TVirtuals
+    >,
+    TSchema = any,
+  > {
+    /**
+     * Synchronizes cached fields across documents. Finds documents with null cached fields and updates them with values from related documents.
+     *
+     * @returns {Promise<Object>} - Bulk write result
+     *
+     * @example
+     * ```js
+     * const result = await User.syncCacheFields();
+     * ```
+     *
+     * @see {@link https://github.com/bedrockio/model#cache}
+     */
+    syncCacheFields(): Promise<any>;
+  }
+}

package/types/modules/clone.d.ts

@@ -0,0 +1,18 @@
+declare module 'mongoose' {
+  interface Document {
+    /**
+     * Creates a new instance of this document with the same field values, generating new values for unique fields by appending a counter.
+     *
+     * @returns {Document} - A new document instance
+     *
+     * @example
+     * ```js
+     * const clone = user.clone();
+     * await clone.save();
+     * ```
+     *
+     * @see {@link https://github.com/bedrockio/model#clone}
+     */
+    clone(): this;
+  }
+}

package/types/modules/delete-hooks.d.ts

@@ -0,0 +1,33 @@
+declare module 'mongoose' {
+  interface Document {
+    /**
+     * Enhanced version of delete() that validates foreign references and deletes related documents based on clean hooks.
+     * Handles rollback if deletion fails. Only available when delete hooks are configured on the model.
+     *
+     * @returns {Promise<Document>} - The saved document
+     *
+     * @example
+     * ```js
+     * await user.delete();
+     * ```
+     *
+     * @see {@link https://github.com/bedrockio/model#delete-hooks}
+     */
+    delete(): Promise<this>;
+
+    /**
+     * Enhanced version of restore() that also restores related documents that were deleted via clean hooks.
+     * Only available when delete hooks are configured on the model.
+     *
+     * @returns {Promise<Document>} - The saved document
+     *
+     * @example
+     * ```js
+     * await user.restore();
+     * ```
+     *
+     * @see {@link https://github.com/bedrockio/model#delete-hooks}
+     */
+    restore(): Promise<this>;
+  }
+}

package/types/modules/export.d.ts

@@ -0,0 +1,17 @@
+declare module 'mongoose' {
+  interface Document {
+    /**
+     * Exports all defined schema paths from this document into a plain object, excluding undefined values.
+     *
+     * @returns {Object} - Plain object with document data
+     *
+     * @example
+     * ```js
+     * const data = user.export();
+     * ```
+     *
+     * @see {@link https://github.com/bedrockio/model#export}
+     */
+    export(): any;
+  }
+}

package/types/modules/hydrate.d.ts

@@ -0,0 +1,37 @@
+import type { HydratedDocument } from 'mongoose';
+
+declare module 'mongoose' {
+  interface Model<
+    TRawDocType,
+    TQueryHelpers = {},
+    TInstanceMethods = {},
+    TVirtuals = {},
+    THydratedDocumentType = HydratedDocument<
+      TRawDocType,
+      TVirtuals & TInstanceMethods,
+      TQueryHelpers,
+      TVirtuals
+    >,
+    TSchema = any,
+  > {
+    /**
+     * Creates a Mongoose document from a plain object, but only includes fields defined in the schema. Prevents leaking extra data from aggregations.
+     *
+     * @param {Object} obj - Plain object to hydrate into a model instance
+     *
+     * @returns {Document} - Hydrated Mongoose document
+     *
+     * @example
+     * ```js
+     * const user = User.hydrate({
+     *   _id: '507f1f77bcf86cd799439011',
+     *   name: 'John Doe',
+     *   email: 'john@example.com'
+     * });
+     * ```
+     *
+     * @see {@link https://github.com/bedrockio/model#hydrate}
+     */
+    hydrate(obj: any): any;
+  }
+}