@web-ts-toolkit/access-router 0.38.0 → 0.39.0

package/advanced.mjs

@@ -53,21 +53,25 @@ import {
   isArray as isArray4,
   isBoolean,
   isFunction,
-  isNil,
-  isPlainObject as isPlainObject7,
-  isString as isString2,
+  isNil as isNil2,
+  isPlainObject as isPlainObject8,
+  isString as isString3,
   keys
 } from "@web-ts-toolkit/utils";
 
+// src/helpers/query.ts
+import { flattenDeep, isNil, isPlainObject, isString, reduce } from "@web-ts-toolkit/utils";
+var DEFAULT_LIST_HARD_LIMIT = 1e3;
+
 // src/helpers/index.ts
-import { forEach, isArray, isEmpty, isObject, isPlainObject as isPlainObject2, isString, mapValuesAsync } from "@web-ts-toolkit/utils";
+import { forEach, isArray, isEmpty, isObject, isPlainObject as isPlainObject3, isString as isString2 } from "@web-ts-toolkit/utils";
 
 // src/lib.ts
 import { Document, Schema } from "mongoose";
-import { isPlainObject } from "@web-ts-toolkit/utils";
+import { isPlainObject as isPlainObject2 } from "@web-ts-toolkit/utils";
 var isSchema = (val) => val instanceof Schema;
 var isObjectIdType = (val) => val === "ObjectId" || val === Schema.Types.ObjectId;
-var isReference = (val) => isPlainObject(val) && !!val.ref && isObjectIdType(val.type);
+var isReference = (val) => isPlainObject2(val) && !!val.ref && isObjectIdType(val.type);
 
 // src/helpers/index.ts
 function recurseObject(obj) {
@@ -97,7 +101,7 @@ function buildRefs(schema) {
     }
     const target = isObject(val) && "type" in val ? val.type ?? val : val;
     if (isArray(target) && target.length > 0) {
-      if (isSchema(target[0]) || isPlainObject2(target[0])) {
+      if (isSchema(target[0]) || isPlainObject3(target[0])) {
         return;
       }
     }
@@ -110,7 +114,7 @@ function buildSubPaths(schema) {
   forEach(schema, (val, key) => {
     const target = isObject(val) && "type" in val ? val.type ?? val : val;
     if (isArray(target) && target.length > 0) {
-      if (isSchema(target[0]) || isPlainObject2(target[0]) && !isReference(target[0])) {
+      if (isSchema(target[0]) || isPlainObject3(target[0]) && !isReference(target[0])) {
         subPaths.push(key);
       }
     }
@@ -119,7 +123,7 @@ function buildSubPaths(schema) {
 }
 
 // src/openapi/build-spec.ts
-import { isArray as isArray2, isPlainObject as isPlainObject4 } from "@web-ts-toolkit/utils";
+import { isArray as isArray2, isPlainObject as isPlainObject5 } from "@web-ts-toolkit/utils";
 
 // src/openapi/responses.ts
 var json = (schema) => ({
@@ -190,19 +194,19 @@ var openApiResponses = {
 
 // src/openapi/schemas.ts
 import { z } from "zod";
-import { isPlainObject as isPlainObject3 } from "@web-ts-toolkit/utils";
+import { isPlainObject as isPlainObject4 } from "@web-ts-toolkit/utils";
 var fallbackObjectSchema = { type: "object", additionalProperties: true };
 function isOpenApiSchemaPatch(source) {
-  return isPlainObject3(source) && source.kind === "objectProperties";
+  return isPlainObject4(source) && source.kind === "objectProperties";
 }
 function isOpenApiSchemaResolver(source) {
-  return isPlainObject3(source) && source.kind === "schemaResolver" && typeof source.resolve === "function";
+  return isPlainObject4(source) && source.kind === "schemaResolver" && typeof source.resolve === "function";
 }
 function isJsonSchemaLike(source) {
-  return isPlainObject3(source) && ("type" in source || "properties" in source || "$ref" in source || "anyOf" in source);
+  return isPlainObject4(source) && ("type" in source || "properties" in source || "$ref" in source || "anyOf" in source);
 }
 function hasOpenApiSchema(source) {
-  return isPlainObject3(source) && isJsonSchemaLike(source.openapi);
+  return isPlainObject4(source) && isJsonSchemaLike(source.openapi);
 }
 function toOpenApiSchema(source) {
   if (!source) return void 0;
@@ -210,7 +214,7 @@ function toOpenApiSchema(source) {
   if (!resolvedSource) return void 0;
   if (isOpenApiSchemaPatch(resolvedSource)) {
     const schema = toOpenApiSchema(resolvedSource.source) ?? { ...fallbackObjectSchema };
-    const properties = isPlainObject3(schema.properties) ? { ...schema.properties } : {};
+    const properties = isPlainObject4(schema.properties) ? { ...schema.properties } : {};
     for (const [key, value] of Object.entries(resolvedSource.properties)) {
       properties[key] = toOpenApiSchema(value) ?? fallbackObjectSchema;
     }
@@ -243,7 +247,7 @@ var toOpenApiPath = (path) => normalizePath(path).replace(/:([A-Za-z0-9_]+)/g, "
 var schemaToQueryParameters = (schema) => {
   const jsonSchema = toOpenApiSchema(schema);
   if (!jsonSchema || jsonSchema.type !== "object") return [];
-  const properties = isPlainObject4(jsonSchema.properties) ? jsonSchema.properties : {};
+  const properties = isPlainObject5(jsonSchema.properties) ? jsonSchema.properties : {};
   const required = new Set(
     isArray2(jsonSchema.required) ? jsonSchema.required.filter((item) => typeof item === "string") : []
   );
@@ -336,7 +340,7 @@ var OpenApiCollisionError = class extends Error {
 };
 
 // src/openapi/registry.ts
-var isPlainObject5 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var isPlainObject6 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 var stableKey = (value) => {
   if (value === null || typeof value === "undefined") return "null";
   if (typeof value === "function") return "[Function]";
@@ -371,7 +375,7 @@ var OpenApiRegistry = class {
       this.routes[existingIndex] = route;
       return;
     }
-    if (descriptorsEqual(existing, route) && (route.idempotent || isPlainObject5(existing) && existing.idempotent)) {
+    if (descriptorsEqual(existing, route) && (route.idempotent || isPlainObject6(existing) && existing.idempotent)) {
       return;
     }
     if (this.options.rejectConflicts) {
@@ -450,6 +454,42 @@ var defaultLogger = createLogger({
 
 // src/options/manager.ts
 import { assign, get, set } from "@web-ts-toolkit/utils";
+var toPath = (key) => {
+  if (Array.isArray(key)) return key;
+  return typeof key === "string" ? key.split(".") : [key];
+};
+var cloneConfigValue = (value) => {
+  if (Array.isArray(value)) {
+    return value.map((item) => cloneConfigValue(item));
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  if (Object.getPrototypeOf(value) !== Object.prototype) {
+    return value;
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([entryKey, entryValue]) => [
+      entryKey,
+      cloneConfigValue(entryValue)
+    ])
+  );
+};
+var freezeConfigValue = (value) => {
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  if (Object.isFrozen(value)) {
+    return value;
+  }
+  if (Array.isArray(value) || Object.getPrototypeOf(value) === Object.prototype) {
+    for (const nestedValue of Object.values(value)) {
+      freezeConfigValue(nestedValue);
+    }
+    return Object.freeze(value);
+  }
+  return value;
+};
 var getNestedOption = (manager, key, defaultValue) => {
   const keys2 = String(key).split(".");
   if (keys2.length === 1) {
@@ -467,8 +507,9 @@ var getNestedOption = (manager, key, defaultValue) => {
   return option;
 };
 var OptionsManager = class {
-  constructor(defaultOptions) {
+  constructor(defaultOptions, options = {}) {
     this.defaultOptions = defaultOptions;
+    this.preserveKeys = new Set(options.preserveKeys ?? []);
     this.listeners = {};
     const _this = this;
     this.currentOptions = new Proxy({}, {
@@ -489,13 +530,34 @@ var OptionsManager = class {
     return get(this.currentOptions, key, defaultValue);
   }
   set(key, value) {
-    set(this.currentOptions, key, value);
+    const path = toPath(key);
+    if (path.length <= 1) {
+      set(this.currentOptions, path, this.preserveKeys.has(String(path[0])) ? value : cloneConfigValue(value));
+      return;
+    }
+    const [rootKey, ...nestedPath] = path;
+    const currentRoot = get(this.currentOptions, [rootKey], void 0);
+    const nextRoot = cloneConfigValue(currentRoot ?? {});
+    set(nextRoot, nestedPath, cloneConfigValue(value));
+    set(this.currentOptions, [rootKey], nextRoot);
   }
   fetch() {
-    return { ...this.currentOptions };
+    const cloned = cloneConfigValue(this.currentOptions);
+    for (const key of this.preserveKeys) {
+      if (key in this.currentOptions) {
+        cloned[key] = this.currentOptions[key];
+      }
+    }
+    return freezeConfigValue(cloned);
   }
   assign(options) {
-    assign(this.currentOptions, options);
+    const cloned = cloneConfigValue(options);
+    for (const key of this.preserveKeys) {
+      if (key in options) {
+        cloned[key] = options[key];
+      }
+    }
+    assign(this.currentOptions, cloned);
   }
   onchange(key, func) {
     set(this.listeners, key, func);
@@ -504,7 +566,7 @@ var OptionsManager = class {
 };
 
 // src/request-complexity.ts
-import { isArray as isArray3, isPlainObject as isPlainObject6 } from "@web-ts-toolkit/utils";
+import { isArray as isArray3, isPlainObject as isPlainObject7 } from "@web-ts-toolkit/utils";
 var defaultRequestComplexity = {
   maxDepth: 8,
   maxNodes: 500,
@@ -513,7 +575,8 @@ var defaultRequestComplexity = {
   maxBulkItems: 100,
   maxIncludeCount: 10,
   maxSubQueryCount: 10,
-  maxBulkConcurrency: 10
+  maxBulkConcurrency: 10,
+  maxHookConcurrency: 10
 };
 var normalizePositiveInteger = (value, fallback) => {
   return Number.isSafeInteger(value) && Number(value) > 0 ? Number(value) : fallback;
@@ -529,6 +592,10 @@ var resolveRequestComplexity = (options) => ({
   maxBulkConcurrency: normalizePositiveInteger(
     options?.maxBulkConcurrency,
     defaultRequestComplexity.maxBulkConcurrency
+  ),
+  maxHookConcurrency: normalizePositiveInteger(
+    options?.maxHookConcurrency,
+    defaultRequestComplexity.maxHookConcurrency
   )
 });
 function validateRequestComplexity(value, options, scope = "request") {
@@ -575,7 +642,7 @@ function validateRequestComplexity(value, options, scope = "request") {
       }
       return;
     }
-    if (!isPlainObject6(current)) return;
+    if (!isPlainObject7(current)) return;
     for (const [key, child] of Object.entries(current)) {
       if (key === "__proto__" || key === "prototype" || key === "constructor") {
         pushError(`Unsupported key: ${key}`, path.concat(key));
@@ -622,24 +689,25 @@ var defaultModelOptions = {
 var defaultDataOptions = {
   basePath: null,
   parentPath: "/",
-  queryRouteSegment: "__query"
+  queryRouteSegment: "__query",
+  listHardLimit: DEFAULT_LIST_HARD_LIMIT
 };
 var normalizeBasePath = (name, value) => {
-  if (isNil(value)) {
+  if (isNil2(value)) {
     return `/${pluralize(name)}`;
   }
-  return isString2(value) ? addLeadingSlash(value) : "";
+  return isString3(value) ? addLeadingSlash(value) : "";
 };
 var hasModelPermission = (value, modelPermissionPrefix) => {
   if (!modelPermissionPrefix) {
     return true;
   }
-  if (isString2(value)) {
+  if (isString3(value)) {
     return value.trim().split(" ").some((item) => item.startsWith(modelPermissionPrefix));
   }
   if (isArray4(value)) {
     return value.some((item) => {
-      if (isString2(item) || isArray4(item)) {
+      if (isString3(item) || isArray4(item)) {
         return hasModelPermission(item, modelPermissionPrefix);
       }
       return true;
@@ -653,7 +721,7 @@ var classifyPermissionSchema = (permissionSchema, modelPermissionPrefix) => {
   const modelPermissionKeys = {};
   forEach2(schemaKeys, (schemaKey) => {
     const schemaRule = permissionSchema[schemaKey];
-    const ruleEntries = isPlainObject7(schemaRule) ? Object.entries(schemaRule) : FIELD_ACCESS_KEYS.map((accessKey) => [accessKey, schemaRule]);
+    const ruleEntries = isPlainObject8(schemaRule) ? Object.entries(schemaRule) : FIELD_ACCESS_KEYS.map((accessKey) => [accessKey, schemaRule]);
     for (let x = 0; x < ruleEntries.length; x++) {
       const [accessKey, value] = ruleEntries[x];
       if (!isArray4(globalPermissionKeys[accessKey])) {
@@ -679,17 +747,30 @@ var classifyPermissionSchema = (permissionSchema, modelPermissionPrefix) => {
     modelPermissionKeys
   };
 };
+var refreshPermissionMetadata = (target) => {
+  const permissionSchema = target.permissionSchema ?? {};
+  const { schemaKeys, globalPermissionKeys, modelPermissionKeys } = classifyPermissionSchema(
+    permissionSchema,
+    target.modelPermissionPrefix ?? ""
+  );
+  target._permissionSchemaKeys = schemaKeys;
+  target._globalPermissionKeys = globalPermissionKeys;
+  target._modelPermissionKeys = modelPermissionKeys;
+};
 var AccessRuntime = class {
-  constructor() {
-    this.globalOptions = new OptionsManager({
-      requestPermissionField: "_permissions",
-      globalPermissions: () => ({}),
-      requireRegisteredPopulateModels: true,
-      logger: defaultLogger,
-      requestComplexity: defaultRequestComplexity
-    }).build();
+  constructor(options = {}) {
+    this.globalOptions = new OptionsManager(
+      {
+        requestPermissionField: "_permissions",
+        globalPermissions: () => ({}),
+        requireRegisteredPopulateModels: true,
+        logger: defaultLogger,
+        requestComplexity: defaultRequestComplexity
+      },
+      { preserveKeys: ["logger"] }
+    ).build();
     this.defaultModelOptions = new OptionsManager({
-      listHardLimit: 1e3,
+      listHardLimit: DEFAULT_LIST_HARD_LIMIT,
       documentPermissionField: "_permissions",
       idParam: "id",
       idField: "_id",
@@ -707,6 +788,7 @@ var AccessRuntime = class {
     this.modelAtts = {};
     this.modelInstances = {};
     this.openApiRegistry = new OpenApiRegistry();
+    this.allowGlobalModelLookup = options.allowGlobalModelLookup ?? false;
     ensureMongooseJsonSchemaInitialized();
   }
   registerModelInstance(modelName, model) {
@@ -722,13 +804,16 @@ var AccessRuntime = class {
     this.modelInstances[modelName] = model;
   }
   hasModelInstance(modelName) {
-    return modelName in this.modelInstances;
+    return modelName in this.modelInstances || this.allowGlobalModelLookup && modelName in mongoose.models;
   }
   getModelInstance(modelName) {
     const registered = this.modelInstances[modelName];
     if (registered) return registered;
+    if (!this.allowGlobalModelLookup) return null;
     const global = mongoose.models[modelName];
-    return global ?? null;
+    if (!global) return null;
+    this.registerModelInstance(modelName, global);
+    return global;
   }
   registerOpenApiRoute(route) {
     this.openApiRegistry.register(route);
@@ -777,24 +862,24 @@ var AccessRuntime = class {
     return this.defaultModelOptions.get(key, defaultValue);
   }
   createModelOptions(modelName) {
-    const model = this.getModelInstance(modelName) ?? mongoose.model(modelName);
+    const model = this.getModelInstance(modelName);
+    if (!model) {
+      throw new Error(
+        `Runtime model registry missing model "${modelName}". Pass a mongoose.Model instance to createRouter() or register it with registerModelInstance() before using this isolated runtime.`
+      );
+    }
     const manager = new OptionsManager({
       ...defaultModelOptions,
       modelName
     });
-    manager.onchange("permissionSchema", function(newval, key, target) {
-      const permissionSchema = newval ?? {};
-      const { schemaKeys, globalPermissionKeys, modelPermissionKeys } = classifyPermissionSchema(
-        permissionSchema,
-        target.modelPermissionPrefix ?? ""
-      );
-      target._permissionSchemaKeys = schemaKeys;
-      target._globalPermissionKeys = globalPermissionKeys;
-      target._modelPermissionKeys = modelPermissionKeys;
+    manager.onchange("permissionSchema", function(_newval, _key, target) {
+      refreshPermissionMetadata(target);
+    }).onchange("modelPermissionPrefix", function(_newval, _key, target) {
+      refreshPermissionMetadata(target);
     }).onchange("basePath", function(newval, key, target) {
       target[key] = normalizeBasePath(
         modelName,
-        isString2(newval) || isNil(newval) ? newval : void 0
+        isString3(newval) || isNil2(newval) ? newval : void 0
       );
     }).build();
     this.modelJsonSchemas[modelName] = model.jsonSchema();
@@ -852,7 +937,7 @@ var AccessRuntime = class {
     manager.onchange("basePath", function(newval, key, target) {
       target[key] = normalizeBasePath(
         dataName,
-        isString2(newval) || isNil(newval) ? newval : void 0
+        isString3(newval) || isNil2(newval) ? newval : void 0
       );
     }).build();
     return manager;
@@ -908,7 +993,7 @@ var AccessRuntime = class {
   getModelRef(modelName, refPath) {
     this.ensureModelMeta(modelName);
     const value = get2(this.modelRefs, `${modelName}.${refPath}`, null);
-    return isString2(value) ? value : null;
+    return isString3(value) ? value : null;
   }
   getModelSub(modelName) {
     this.ensureModelMeta(modelName);
@@ -919,7 +1004,7 @@ var AccessRuntime = class {
     return get2(this.modelAtts, modelName, []);
   }
 };
-var defaultRuntime = new AccessRuntime();
+var defaultRuntime = new AccessRuntime({ allowGlobalModelLookup: true });
 
 // src/runtime-context.ts
 import { AsyncLocalStorage } from "async_hooks";
@@ -1003,7 +1088,7 @@ var includeItemSchema = z2.object({
   filter: z2.record(z2.string(), z2.unknown()).optional(),
   localField: z2.string().min(1),
   foreignField: z2.string().min(1),
-  args: z2.unknown().optional(),
+  args: z2.unknown().optional().describe("Forwarded to list/read includes. Count includes ignore pagination fields so counts remain exact."),
   options: z2.unknown().optional()
 }).passthrough();
 var includeSchema = z2.union([includeItemSchema, z2.array(includeItemSchema)]);
@@ -1540,7 +1625,7 @@ import { z as z4 } from "zod";
 var dataListBodySchema = z4.object({
   filter: objectOrArraySchema.optional(),
   select: projectionSchema.optional(),
-  sort: z4.string().optional(),
+  sort: sortSchema.optional(),
   skip: z4.union([nonNegativeIntegerSchema, nonNegativeIntegerString]).optional(),
   limit: z4.union([positiveIntegerSchema, positiveIntegerString]).optional(),
   page: z4.union([nonNegativeIntegerSchema, nonNegativeIntegerString]).optional(),
@@ -1632,7 +1717,7 @@ var rootModelSubReadArgsSchema = z5.object({
 var rootModelCountOptionsSchema = z5.object({}).strict().optional();
 var rootDataListArgsSchema = z5.object({
   select: projectionSchema.optional(),
-  sort: z5.string().optional(),
+  sort: sortSchema.optional(),
   skip: z5.union([nonNegativeIntegerSchema, nonNegativeIntegerString]).optional(),
   limit: z5.union([positiveIntegerSchema, positiveIntegerString]).optional(),
   page: z5.union([nonNegativeIntegerSchema, nonNegativeIntegerString]).optional(),

package/index.d.mts

@@ -1,10 +1,173 @@
 import mongoose, { Schema } from 'mongoose';
 import { Response, NextFunction, RequestHandler, Router } from 'express';
-import { A as AccessRouterBaseRequest, aa as GuardHook, ay as ModelRequest, cG as AccessRuntime, N as DataRouterOptions, L as DataRequest, cH as DataService, cI as Model, az as ModelRouterOptions, cJ as Service, cK as PublicService, _ as ExtendedModelRouterOptions, cj as Validation, bu as RootRouterOptions, cL as OpenApiRouterOptions, cM as OpenApiRegistryOptions, cN as OpenApiRouteDescriptor, cO as OpenApiDocumentOptions, cP as OpenApiParameter, cQ as OpenApiSchema, cR as OpenApiResponses, a8 as GlobalOptions, R as DefaultModelRouterOptions, Z as ExtendedDefaultModelRouterOptions } from './parsers--DZcTstL.mjs';
-export { cS as AccessRouterPermissionMap, cT as AccessRouterPermissions, c as AccessRouterRequest, d as AccessRouterRequestExtensions, l as AjvErrorObjectLike, m as AjvValidatorLike, n as ArkTypeErrorsLike, o as ArkTypeLike, a9 as GlobalPermissionValue, ad as IoTsContextEntryLike, ae as IoTsDecodeErrorLike, af as IoTsDecoderLike, ag as JoiSchemaLike, ah as JoiValidationErrorDetailLike, am as MaybePromise, an as ModelBaseFilterHook, ap as ModelDeleteHook, aq as ModelDocPermissionsHook, as as ModelDocumentHook, at as ModelHook, av as ModelIdentifierHook, aw as ModelListHook, ax as ModelOverrideFilterHook, aA as ModelValidateHook, cU as OpenApiMethod, cV as Permissions, a_ as RequestSchemaAdapter, a$ as RequestSchemaFailure, b0 as RequestSchemaIssue, b1 as RequestSchemaLike, b2 as RequestSchemaOptions, b3 as RequestSchemaResult, b4 as RequestSchemaSuccess, b5 as RequestSchemaValidator, bF as StandardSchemaFailure, bG as StandardSchemaInferOutput, bH as StandardSchemaIssue, bI as StandardSchemaPathSegment, bJ as StandardSchemaResult, bK as StandardSchemaSuccess, bL as StandardSchemaV1, c0 as SuperstructFailureLike, c1 as SuperstructValidateLike, cd as ValibotIssueLike, ce as ValibotPathItemLike, cf as ValibotSafeParseLike, cg as ValibotSafeParseResult, cl as VineValidationErrorLike, cm as VineValidationMessageLike, cn as VineValidatorLike, co as YupSchemaLike, cp as YupValidationErrorLike, cW as defaultRuntime, cq as defineRequestSchema, cr as fromAjv, cs as fromArkType, ct as fromIoTs, cu as fromJoi, cv as fromStandardSchema, cw as fromSuperstruct, cx as fromValibot, cy as fromVine, cz as fromYup, cA as fromZod } from './parsers--DZcTstL.mjs';
+import { a8 as GlobalOptions, R as DefaultModelRouterOptions, Z as ExtendedDefaultModelRouterOptions, az as ModelRouterOptions, _ as ExtendedModelRouterOptions, N as DataRouterOptions, Y as ExtendedDataRouterOptions, A as AccessRouterBaseRequest, aa as GuardHook, ay as ModelRequest, L as DataRequest, cG as DataService, $ as Filter, aI as Projection, bD as Sort, aF as Populate, cH as Service, cI as PublicService, cj as Validation, bu as RootRouterOptions } from './parsers-PMWujHUV.mjs';
+export { cJ as AccessRouterPermissionMap, cK as AccessRouterPermissions, c as AccessRouterRequest, d as AccessRouterRequestExtensions, l as AjvErrorObjectLike, m as AjvValidatorLike, n as ArkTypeErrorsLike, o as ArkTypeLike, a9 as GlobalPermissionValue, ad as IoTsContextEntryLike, ae as IoTsDecodeErrorLike, af as IoTsDecoderLike, ag as JoiSchemaLike, ah as JoiValidationErrorDetailLike, am as MaybePromise, an as ModelBaseFilterHook, ap as ModelDeleteHook, aq as ModelDocPermissionsHook, as as ModelDocumentHook, at as ModelHook, av as ModelIdentifierHook, aw as ModelListHook, ax as ModelOverrideFilterHook, aA as ModelValidateHook, cL as Permissions, a_ as RequestSchemaAdapter, a$ as RequestSchemaFailure, b0 as RequestSchemaIssue, b1 as RequestSchemaLike, b2 as RequestSchemaOptions, b3 as RequestSchemaResult, b4 as RequestSchemaSuccess, b5 as RequestSchemaValidator, bF as StandardSchemaFailure, bG as StandardSchemaInferOutput, bH as StandardSchemaIssue, bI as StandardSchemaPathSegment, bJ as StandardSchemaResult, bK as StandardSchemaSuccess, bL as StandardSchemaV1, c0 as SuperstructFailureLike, c1 as SuperstructValidateLike, cd as ValibotIssueLike, ce as ValibotPathItemLike, cf as ValibotSafeParseLike, cg as ValibotSafeParseResult, cl as VineValidationErrorLike, cm as VineValidationMessageLike, cn as VineValidatorLike, co as YupSchemaLike, cp as YupValidationErrorLike, cq as defineRequestSchema, cr as fromAjv, cs as fromArkType, ct as fromIoTs, cu as fromJoi, cv as fromStandardSchema, cw as fromSuperstruct, cx as fromValibot, cy as fromVine, cz as fromYup, cA as fromZod } from './parsers-PMWujHUV.mjs';
 import JsonRouter from '@web-ts-toolkit/express-json-router';
 import 'zod';
 
+type OpenApiMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
+type OpenApiSchema = Record<string, unknown>;
+type OpenApiSchemaSource = unknown;
+type OpenApiParameter = {
+    name: string;
+    in: 'path' | 'query';
+    required?: boolean;
+    description?: string;
+    schema?: OpenApiSchema;
+};
+type OpenApiResponse = {
+    description: string;
+    content?: Record<string, {
+        schema: OpenApiSchema;
+    }>;
+};
+type OpenApiResponses = Record<string, OpenApiResponse>;
+type OpenApiRouteDescriptor = {
+    method: OpenApiMethod;
+    path: string;
+    operationId?: string;
+    summary?: string;
+    description?: string;
+    tags?: string[];
+    acl?: string;
+    deprecated?: boolean;
+    query?: OpenApiSchemaSource;
+    body?: OpenApiSchemaSource;
+    pathParams?: Record<string, OpenApiSchemaSource>;
+    responses?: OpenApiResponses;
+    /**
+     * When true, replaces an existing registration with the same method/path
+     * even when the descriptors differ. When false (default), conflicting
+     * registrations throw at registration time so consumers can detect
+     * accidental route shadowing.
+     */
+    allowReplace?: boolean;
+    /**
+     * When true, this exact descriptor is idempotent and registering the same
+     * method/path with an equivalent descriptor again is silently accepted.
+     * Differing re-registrations still throw unless {@link allowReplace} is set.
+     * Additionally, an idempotent descriptor may share its operationId with
+     * another idempotent descriptor mounted at a different path on the same
+     * registry, so reserved operations (e.g. the root batch route) can be
+     * exposed from multiple base paths without triggering strict-mode
+     * duplicate-operationId rejection.
+     */
+    idempotent?: boolean;
+};
+type OpenApiRegistryOptions = {
+    /**
+     * Throw when the same method/path is registered twice with differing
+     * descriptors, instead of silently replacing. Default: true (strict).
+     * The {@link AccessRuntime} registry is constructed in strict mode by
+     * default; construct {@link OpenApiRegistry} directly with
+     * `rejectConflicts: false` for legacy replacement semantics.
+     */
+    rejectConflicts?: boolean;
+    /**
+     * Throw when the same operationId is registered more than once, including
+     * when {@link OpenApiRouteDescriptor.allowReplace} is set. Default: true.
+     */
+    rejectDuplicateOperationIds?: boolean;
+};
+type OpenApiDocumentOptions = {
+    title: string;
+    version: string;
+    description?: string;
+    servers?: Array<{
+        url: string;
+        description?: string;
+    }>;
+};
+type OpenApiRouterOptions = Partial<OpenApiDocumentOptions> & {
+    jsonPath?: string;
+    docsPath?: string | false;
+    swaggerUiCssUrl?: string;
+    swaggerUiBundleUrl?: string;
+};
+
+declare class AccessRuntime {
+    private readonly allowGlobalModelLookup;
+    constructor(options?: {
+        allowGlobalModelLookup?: boolean;
+    });
+    private readonly globalOptions;
+    private readonly defaultModelOptions;
+    private readonly modelOptions;
+    private readonly modelJsonSchemas;
+    private readonly dataOptions;
+    private readonly modelRefs;
+    private readonly modelSubs;
+    private readonly modelAtts;
+    private readonly modelInstances;
+    private readonly openApiRegistry;
+    registerModelInstance(modelName: string, model: mongoose.Model<unknown>): void;
+    hasModelInstance(modelName: string): boolean;
+    getModelInstance(modelName: string): mongoose.Model<unknown> | null;
+    registerOpenApiRoute(route: OpenApiRouteDescriptor): void;
+    /**
+     * Enable strict OpenAPI collision detection for the remainder of this
+     * runtime's lifetime. After this call, conflicting method/path
+     * registrations and duplicate operationIds throw {@link OpenApiCollisionError}
+     * instead of silently replacing. Existing already-registered routes are
+     * not retroactively re-validated.
+     */
+    enableOpenApiCollisionDetection(): void;
+    getOpenApiRoutes(): OpenApiRouteDescriptor[];
+    clearOpenApiRoutes(): void;
+    getOpenApiSpec(info: OpenApiDocumentOptions): {
+        openapi: string;
+        info: Omit<OpenApiDocumentOptions, "servers">;
+        servers?: OpenApiDocumentOptions["servers"];
+        paths: Record<string, Record<string, {
+            [key: `x-${string}`]: unknown;
+            operationId?: string;
+            summary?: string;
+            description?: string;
+            tags?: string[];
+            deprecated?: boolean;
+            parameters?: OpenApiParameter[];
+            requestBody?: {
+                required?: boolean;
+                content: Record<string, {
+                    schema: OpenApiSchema;
+                }>;
+            };
+            responses: OpenApiResponses;
+        }>>;
+    };
+    setGlobalOptions(options: GlobalOptions): void;
+    setGlobalOption<K extends keyof GlobalOptions>(key: K, value: GlobalOptions[K]): void;
+    getGlobalOptions(): GlobalOptions;
+    getGlobalOption<K extends keyof GlobalOptions>(key: K, defaultValue?: GlobalOptions[K]): GlobalOptions[K];
+    setDefaultModelOptions(options: DefaultModelRouterOptions): void;
+    setDefaultModelOption<K extends keyof ExtendedDefaultModelRouterOptions>(key: K, value: ExtendedDefaultModelRouterOptions[K]): void;
+    getDefaultModelOptions(): DefaultModelRouterOptions<unknown>;
+    getDefaultModelOption<K extends keyof ExtendedDefaultModelRouterOptions>(key: K, defaultValue?: ExtendedDefaultModelRouterOptions[K]): ExtendedDefaultModelRouterOptions<unknown>[K];
+    private createModelOptions;
+    private getOrCreateModelOptions;
+    setModelOptions<TModel = unknown>(modelName: string, options: ModelRouterOptions<TModel>): void;
+    setModelOption<K extends keyof ExtendedModelRouterOptions<TModel>, TModel = unknown>(modelName: string, key: K, value: ExtendedModelRouterOptions<TModel>[K]): void;
+    getModelOptions<TModel = unknown>(modelName: string): ModelRouterOptions<TModel>;
+    getModelOption<K extends keyof ExtendedModelRouterOptions<TModel>, TModel = unknown>(modelName: string, key: K | string, defaultValue?: ExtendedModelRouterOptions<TModel>[K]): ExtendedModelRouterOptions<TModel>[K];
+    getExactModelOption<K extends keyof ExtendedModelRouterOptions<TModel>, TModel = unknown>(modelName: string, key: K | string): ExtendedModelRouterOptions<TModel>[K];
+    getModelNames(): string[];
+    hasModel(modelName: string): boolean;
+    getModelJsonSchema(modelName: string): Record<string, unknown>;
+    private createDataOptions;
+    private getOrCreateDataOptions;
+    setDataOptions<TData = unknown>(dataName: string, options: DataRouterOptions<TData>): void;
+    setDataOption<K extends keyof DataRouterOptions<TData>, TData = unknown>(dataName: string, key: K, value: DataRouterOptions<TData>[K]): void;
+    getDataOptions<TData = unknown>(dataName: string): DataRouterOptions<TData>;
+    getDataOption<K extends keyof DataRouterOptions<TData>, TData = unknown>(dataName: string, key: K | string, defaultValue?: DataRouterOptions<TData>[K]): DataRouterOptions<TData>[K];
+    getExactDataOption<K extends keyof ExtendedDataRouterOptions<TData>, TData = unknown>(dataName: string, key: K | string): ExtendedDataRouterOptions<TData>[K];
+    getDataNames(): string[];
+    ensureModelMeta(modelName: string): void;
+    getModelRef(modelName: string, refPath: string): string | null;
+    getModelSub(modelName: string): string[];
+    getModelAtt(modelName: string): string[];
+}
+declare const defaultRuntime: AccessRuntime;
+
 declare function macl(): (req: AccessRouterBaseRequest, res: Response, next: NextFunction) => Promise<void>;
 interface GuardModelConditionID {
     type: 'param' | 'query';
@@ -55,6 +218,38 @@ declare class DataRouter<TData = unknown> {
     get routes(): Router;
 }
 
+interface FindProps {
+    filter: Filter;
+    select?: Projection;
+    sort?: Sort;
+    populate?: Populate[] | string;
+    limit?: string | number;
+    hardLimit?: number;
+    skip?: string | number;
+    lean?: boolean;
+}
+interface FindOneProps {
+    filter: Filter;
+    select?: Projection;
+    sort?: Sort;
+    populate?: Populate[] | string;
+    lean?: boolean;
+}
+declare class Model {
+    modelName: string;
+    mongooseModel: mongoose.Model<any>;
+    runtime: AccessRuntime | null;
+    constructor(modelName: string, runtime?: AccessRuntime);
+    new(): any;
+    create(data: unknown): Promise<any>;
+    find({ filter, select, sort, populate, limit, hardLimit, skip, lean }: FindProps): mongoose.Query<any[], any>;
+    findOne({ filter, select, sort, populate, lean }: FindOneProps): mongoose.Query<any, any>;
+    exists(filter: Filter): ReturnType<typeof Model.prototype.findOne> | null;
+    countDocuments(filter?: {}): mongoose.Query<number, any>;
+    distinct(field: string, conditions?: {}): mongoose.Query<any[], any>;
+    aggregate(pipeline: unknown[]): mongoose.Aggregate<any[]>;
+}
+
 type SetTargetOption<TRouter, TOption> = {
     (option: TOption): TRouter;
     (key: string, option: unknown): TRouter;
@@ -379,4 +574,4 @@ type AccessRuntimeApi = typeof macl & Wtt;
 declare function createAccessRuntime(): AccessRuntimeApi;
 declare const acl: AccessRuntimeApi;
 
-export { AccessRuntime, type AccessRuntimeApi, type CombinedRouteInput, DataRouter, DataRouterOptions, ExtendedDefaultModelRouterOptions, ExtendedModelRouterOptions, GlobalOptions, type GuardModelCondition, type GuardModelConditionID, ModelRouter, ModelRouterOptions, type OpLogContext, OpenApiCollisionError, OpenApiDocumentOptions, OpenApiRegistry, OpenApiRegistryOptions, OpenApiRouteDescriptor, OpenApiRouterOptions, RootRouter, RootRouterOptions, acl, combineRoutes, createAccessRuntime, createOpenApiRouter, acl as default, getDefaultModelOption, getDefaultModelOptions, getGlobalOption, getGlobalOptions, getModelInstance, getModelJsonSchema, getModelNames, getModelOption, getModelOptions, guard, hasModelInstance, isLevelEnabled, permissionsPlugin, redactFilter, redactPayload, registerModelInstance, safeStringify, setDefaultModelOption, setDefaultModelOptions, setGlobalOption, setGlobalOptions, setModelOption, setModelOptions };
+export { AccessRuntime, type AccessRuntimeApi, type CombinedRouteInput, DataRouter, DataRouterOptions, ExtendedDefaultModelRouterOptions, ExtendedModelRouterOptions, GlobalOptions, type GuardModelCondition, type GuardModelConditionID, ModelRouter, ModelRouterOptions, type OpLogContext, OpenApiCollisionError, type OpenApiDocumentOptions, type OpenApiMethod, OpenApiRegistry, type OpenApiRegistryOptions, type OpenApiRouteDescriptor, type OpenApiRouterOptions, RootRouter, RootRouterOptions, acl, combineRoutes, createAccessRuntime, createOpenApiRouter, acl as default, defaultRuntime, getDefaultModelOption, getDefaultModelOptions, getGlobalOption, getGlobalOptions, getModelInstance, getModelJsonSchema, getModelNames, getModelOption, getModelOptions, guard, hasModelInstance, isLevelEnabled, permissionsPlugin, redactFilter, redactPayload, registerModelInstance, safeStringify, setDefaultModelOption, setDefaultModelOptions, setGlobalOption, setGlobalOptions, setModelOption, setModelOptions };