@classytic/mongokit 3.0.3 → 3.0.5

package/dist/pagination/PaginationEngine.d.ts

@@ -1,5 +1,5 @@
 import { Model } from 'mongoose';
-import { A as AnyDocument, P as PaginationConfig, O as OffsetPaginationOptions, a as OffsetPaginationResult, K as KeysetPaginationOptions, b as KeysetPaginationResult, c as AggregatePaginationOptions, d as AggregatePaginationResult } from '../types-B3dPUKjs.js';
+import { A as AnyDocument, P as PaginationConfig, O as OffsetPaginationOptions, a as OffsetPaginationResult, K as KeysetPaginationOptions, b as KeysetPaginationResult, c as AggregatePaginationOptions, d as AggregatePaginationResult } from '../types-CHIDluaP.js';
 
 /**
  * Pagination Engine

package/dist/plugins/index.d.ts

@@ -1,4 +1,4 @@
-import { F as FieldPreset, r as Plugin, L as Logger, I as SoftDeleteOptions, t as RepositoryInstance, B as ValidatorDefinition, G as ValidationChainOptions, i as RepositoryContext, W as CacheOptions, _ as CascadeOptions } from '../types-B3dPUKjs.js';
+import { F as FieldPreset, r as Plugin, L as Logger, M as SoftDeleteOptions, t as RepositoryInstance, G as ValidatorDefinition, I as ValidationChainOptions, i as RepositoryContext, Z as CacheOptions, a1 as CascadeOptions } from '../types-CHIDluaP.js';
 import 'mongoose';
 
 /**
@@ -54,10 +54,42 @@ declare function auditLogPlugin(logger: Logger): Plugin;
 /**
  * Soft delete plugin
  *
- * @example
+ * @example Basic usage
+ * ```typescript
  * const repo = new Repository(Model, [
  *   softDeletePlugin({ deletedField: 'deletedAt' })
  * ]);
+ *
+ * // Delete (soft)
+ * await repo.delete(id);
+ *
+ * // Restore
+ * await repo.restore(id);
+ *
+ * // Get deleted documents
+ * await repo.getDeleted({ page: 1, limit: 20 });
+ * ```
+ *
+ * @example With null filter mode (for schemas with default: null)
+ * ```typescript
+ * // Schema: { deletedAt: { type: Date, default: null } }
+ * const repo = new Repository(Model, [
+ *   softDeletePlugin({
+ *     deletedField: 'deletedAt',
+ *     filterMode: 'null', // default - works with default: null
+ *   })
+ * ]);
+ * ```
+ *
+ * @example With TTL for auto-cleanup
+ * ```typescript
+ * const repo = new Repository(Model, [
+ *   softDeletePlugin({
+ *     deletedField: 'deletedAt',
+ *     ttlDays: 30, // Auto-delete after 30 days
+ *   })
+ * ]);
+ * ```
  */
 declare function softDeletePlugin(options?: SoftDeleteOptions): Plugin;
 

package/dist/plugins/index.js

@@ -115,12 +115,45 @@ function auditLogPlugin(logger) {
 }
 
 // src/plugins/soft-delete.plugin.ts
+function buildDeletedFilter(deletedField, filterMode, includeDeleted) {
+  if (includeDeleted) {
+    return {};
+  }
+  if (filterMode === "exists") {
+    return { [deletedField]: { $exists: false } };
+  }
+  return { [deletedField]: null };
+}
+function buildGetDeletedFilter(deletedField, filterMode) {
+  if (filterMode === "exists") {
+    return { [deletedField]: { $exists: true, $ne: null } };
+  }
+  return { [deletedField]: { $ne: null } };
+}
 function softDeletePlugin(options = {}) {
   const deletedField = options.deletedField || "deletedAt";
   const deletedByField = options.deletedByField || "deletedBy";
+  const filterMode = options.filterMode || "null";
+  const addRestoreMethod = options.addRestoreMethod !== false;
+  const addGetDeletedMethod = options.addGetDeletedMethod !== false;
+  const ttlDays = options.ttlDays;
   return {
     name: "softDelete",
     apply(repo) {
+      if (ttlDays !== void 0 && ttlDays > 0) {
+        const ttlSeconds = ttlDays * 24 * 60 * 60;
+        repo.Model.collection.createIndex(
+          { [deletedField]: 1 },
+          {
+            expireAfterSeconds: ttlSeconds,
+            partialFilterExpression: { [deletedField]: { $type: "date" } }
+          }
+        ).catch((err) => {
+          if (!err.message.includes("already exists")) {
+            console.warn(`[softDeletePlugin] Failed to create TTL index: ${err.message}`);
+          }
+        });
+      }
       repo.on("before:delete", async (context) => {
         if (options.soft !== false) {
           const updateData = {
@@ -134,23 +167,126 @@ function softDeletePlugin(options = {}) {
         }
       });
       repo.on("before:getAll", (context) => {
-        if (!context.includeDeleted && options.soft !== false) {
-          const queryParams = context.queryParams || {};
-          queryParams.filters = {
-            ...queryParams.filters || {},
-            [deletedField]: { $exists: false }
-          };
-          context.queryParams = queryParams;
+        if (options.soft !== false) {
+          const deleteFilter = buildDeletedFilter(deletedField, filterMode, !!context.includeDeleted);
+          if (Object.keys(deleteFilter).length > 0) {
+            const existingFilters = context.filters || {};
+            context.filters = {
+              ...existingFilters,
+              ...deleteFilter
+            };
+          }
         }
       });
       repo.on("before:getById", (context) => {
-        if (!context.includeDeleted && options.soft !== false) {
-          context.query = {
-            ...context.query || {},
-            [deletedField]: { $exists: false }
-          };
+        if (options.soft !== false) {
+          const deleteFilter = buildDeletedFilter(deletedField, filterMode, !!context.includeDeleted);
+          if (Object.keys(deleteFilter).length > 0) {
+            context.query = {
+              ...context.query || {},
+              ...deleteFilter
+            };
+          }
         }
       });
+      repo.on("before:getByQuery", (context) => {
+        if (options.soft !== false) {
+          const deleteFilter = buildDeletedFilter(deletedField, filterMode, !!context.includeDeleted);
+          if (Object.keys(deleteFilter).length > 0) {
+            context.query = {
+              ...context.query || {},
+              ...deleteFilter
+            };
+          }
+        }
+      });
+      if (addRestoreMethod) {
+        const restoreMethod = async function(id, restoreOptions = {}) {
+          const updateData = {
+            [deletedField]: null,
+            [deletedByField]: null
+          };
+          const result = await this.Model.findByIdAndUpdate(id, { $set: updateData }, {
+            new: true,
+            session: restoreOptions.session
+          });
+          if (!result) {
+            const error = new Error(`Document with id '${id}' not found`);
+            error.status = 404;
+            throw error;
+          }
+          await this.emitAsync("after:restore", { id, result });
+          return result;
+        };
+        if (typeof repo.registerMethod === "function") {
+          repo.registerMethod("restore", restoreMethod);
+        } else {
+          repo.restore = restoreMethod.bind(repo);
+        }
+      }
+      if (addGetDeletedMethod) {
+        const getDeletedMethod = async function(params = {}, getDeletedOptions = {}) {
+          const deletedFilter = buildGetDeletedFilter(deletedField, filterMode);
+          const combinedFilters = {
+            ...params.filters || {},
+            ...deletedFilter
+          };
+          const page = params.page || 1;
+          const limit = params.limit || 20;
+          const skip = (page - 1) * limit;
+          let sortSpec = { [deletedField]: -1 };
+          if (params.sort) {
+            if (typeof params.sort === "string") {
+              const sortOrder = params.sort.startsWith("-") ? -1 : 1;
+              const sortField = params.sort.startsWith("-") ? params.sort.substring(1) : params.sort;
+              sortSpec = { [sortField]: sortOrder };
+            } else {
+              sortSpec = params.sort;
+            }
+          }
+          let query = this.Model.find(combinedFilters).sort(sortSpec).skip(skip).limit(limit);
+          if (getDeletedOptions.session) {
+            query = query.session(getDeletedOptions.session);
+          }
+          if (getDeletedOptions.select) {
+            const selectValue = Array.isArray(getDeletedOptions.select) ? getDeletedOptions.select.join(" ") : getDeletedOptions.select;
+            query = query.select(selectValue);
+          }
+          if (getDeletedOptions.populate) {
+            const populateSpec = getDeletedOptions.populate;
+            if (typeof populateSpec === "string") {
+              query = query.populate(populateSpec.split(",").map((p) => p.trim()));
+            } else if (Array.isArray(populateSpec)) {
+              query = query.populate(populateSpec);
+            } else {
+              query = query.populate(populateSpec);
+            }
+          }
+          if (getDeletedOptions.lean !== false) {
+            query = query.lean();
+          }
+          const [docs, total] = await Promise.all([
+            query.exec(),
+            this.Model.countDocuments(combinedFilters)
+          ]);
+          const pages = Math.ceil(total / limit);
+          return {
+            method: "offset",
+            docs,
+            page,
+            limit,
+            total,
+            pages,
+            hasNext: page < pages,
+            hasPrev: page > 1
+          };
+        };
+        if (typeof repo.registerMethod === "function") {
+          repo.registerMethod("getDeleted", getDeletedMethod);
+        } else {
+          repo.getDeleted = getDeletedMethod.bind(repo);
+        }
+      }
     }
   };
 }

package/dist/queryParser-CxzCjzXd.d.ts

@@ -0,0 +1,303 @@
+import { q as UserContext, F as FieldPreset, H as HttpError, Y as CacheAdapter, y as SchemaBuilderOptions, z as CrudSchemas, V as ValidationResult, v as ParsedQuery } from './types-CHIDluaP.js';
+import mongoose__default, { Schema } from 'mongoose';
+
+/**
+ * Field Selection Utilities
+ *
+ * Provides explicit, performant field filtering using Mongoose projections.
+ *
+ * Philosophy:
+ * - Explicit is better than implicit
+ * - Filter at DB level (10x faster than in-memory)
+ * - Progressive disclosure (show more fields as trust increases)
+ *
+ * @example
+ * ```typescript
+ * // For Mongoose queries (PREFERRED - 90% of cases)
+ * const projection = getMongooseProjection(request.user, fieldPresets.gymPlans);
+ * const plans = await GymPlan.find().select(projection).lean();
+ *
+ * // For complex data (10% of cases - aggregations, multiple sources)
+ * const filtered = filterResponseData(complexData, fieldPresets.gymPlans, request.user);
+ * ```
+ */
+
+/**
+ * Get allowed fields for a user based on their context
+ *
+ * @param user - User object from request.user (or null for public)
+ * @param preset - Field preset configuration
+ * @returns Array of allowed field names
+ *
+ * @example
+ * const fields = getFieldsForUser(request.user, {
+ *   public: ['id', 'name', 'price'],
+ *   authenticated: ['description', 'features'],
+ *   admin: ['createdAt', 'internalNotes']
+ * });
+ */
+declare function getFieldsForUser(user: UserContext | null | undefined, preset: FieldPreset): string[];
+/**
+ * Get Mongoose projection string for query .select()
+ *
+ * @param user - User object from request.user
+ * @param preset - Field preset configuration
+ * @returns Space-separated field names for Mongoose .select()
+ *
+ * @example
+ * const projection = getMongooseProjection(request.user, fieldPresets.gymPlans);
+ * const plans = await GymPlan.find({ organizationId }).select(projection).lean();
+ */
+declare function getMongooseProjection(user: UserContext | null | undefined, preset: FieldPreset): string;
+/**
+ * Filter response data to include only allowed fields
+ *
+ * Use this for complex responses where Mongoose projections aren't applicable:
+ * - Aggregation pipeline results
+ * - Data from multiple sources
+ * - Custom computed fields
+ *
+ * For simple DB queries, prefer getMongooseProjection() (10x faster)
+ *
+ * @param data - Data to filter
+ * @param preset - Field preset configuration
+ * @param user - User object from request.user
+ * @returns Filtered data
+ *
+ * @example
+ * const stats = await calculateComplexStats();
+ * const filtered = filterResponseData(stats, fieldPresets.dashboard, request.user);
+ * return reply.send(filtered);
+ */
+declare function filterResponseData<T extends Record<string, unknown>>(data: T | T[], preset: FieldPreset, user?: UserContext | null): Partial<T> | Partial<T>[];
+/**
+ * Helper to create field presets (module-level)
+ *
+ * Each module should define its own field preset in its own directory.
+ * This keeps modules independent and self-contained.
+ *
+ * @param config - Field configuration
+ * @returns Field preset
+ *
+ * @example
+ * // In modules/gym-plan/gym-plan.fields.ts
+ * export const gymPlanFieldPreset = createFieldPreset({
+ *   public: ['id', 'name', 'price'],
+ *   authenticated: ['features', 'description'],
+ *   admin: ['createdAt', 'updatedAt', 'internalNotes']
+ * });
+ */
+declare function createFieldPreset(config: Partial<FieldPreset>): FieldPreset;
+
+/**
+ * Error Utilities
+ *
+ * HTTP-compatible error creation for repository operations
+ */
+
+/**
+ * Creates an error with HTTP status code
+ *
+ * @param status - HTTP status code
+ * @param message - Error message
+ * @returns Error with status property
+ *
+ * @example
+ * throw createError(404, 'Document not found');
+ * throw createError(400, 'Invalid input');
+ * throw createError(403, 'Access denied');
+ */
+declare function createError(status: number, message: string): HttpError;
+
+/**
+ * In-Memory Cache Adapter
+ *
+ * Simple cache adapter for development and testing.
+ * NOT recommended for production - use Redis or similar.
+ *
+ * @example
+ * ```typescript
+ * import { cachePlugin, createMemoryCache } from '@classytic/mongokit';
+ *
+ * const repo = new Repository(UserModel, [
+ *   cachePlugin({
+ *     adapter: createMemoryCache(),
+ *     ttl: 60,
+ *   })
+ * ]);
+ * ```
+ */
+
+/**
+ * Creates an in-memory cache adapter
+ *
+ * Features:
+ * - Automatic TTL expiration
+ * - Pattern-based clearing (simple glob with *)
+ * - Max entries limit to prevent memory leaks
+ *
+ * @param maxEntries - Maximum cache entries before oldest are evicted (default: 1000)
+ */
+declare function createMemoryCache(maxEntries?: number): CacheAdapter;
+
+/**
+ * Mongoose to JSON Schema Converter with Field Rules
+ *
+ * Generates Fastify JSON schemas from Mongoose models with declarative field rules.
+ *
+ * Field Rules (options.fieldRules):
+ * - immutable: Field cannot be updated (omitted from update schema)
+ * - immutableAfterCreate: Alias for immutable
+ * - systemManaged: System-only field (omitted from create/update)
+ * - optional: Remove from required array
+ *
+ * Additional Options:
+ * - strictAdditionalProperties: Set to true to add "additionalProperties: false" to schemas
+ *   This makes Fastify reject unknown fields at validation level (default: false for backward compatibility)
+ *
+ * @example
+ * buildCrudSchemasFromModel(Model, {
+ *   strictAdditionalProperties: true, // Reject unknown fields
+ *   fieldRules: {
+ *     organizationId: { immutable: true },
+ *     status: { systemManaged: true },
+ *   },
+ *   create: { omitFields: ['verifiedAt'] },
+ *   update: { omitFields: ['customerId'] }
+ * })
+ */
+
+/**
+ * Build CRUD schemas from Mongoose schema
+ */
+declare function buildCrudSchemasFromMongooseSchema(mongooseSchema: Schema, options?: SchemaBuilderOptions): CrudSchemas;
+/**
+ * Build CRUD schemas from Mongoose model
+ */
+declare function buildCrudSchemasFromModel(mongooseModel: mongoose__default.Model<unknown>, options?: SchemaBuilderOptions): CrudSchemas;
+/**
+ * Get fields that are immutable (cannot be updated)
+ */
+declare function getImmutableFields(options?: SchemaBuilderOptions): string[];
+/**
+ * Get fields that are system-managed (cannot be set by users)
+ */
+declare function getSystemManagedFields(options?: SchemaBuilderOptions): string[];
+/**
+ * Check if field is allowed in update
+ */
+declare function isFieldUpdateAllowed(fieldName: string, options?: SchemaBuilderOptions): boolean;
+/**
+ * Validate update body against field rules
+ */
+declare function validateUpdateBody(body?: Record<string, unknown>, options?: SchemaBuilderOptions): ValidationResult;
+
+/**
+ * Query Parser
+ *
+ * Parses HTTP query parameters into MongoDB-compatible query objects.
+ * Supports operators, pagination, sorting, and filtering.
+ */
+
+/** Operator mapping from query syntax to MongoDB operators */
+type OperatorMap = Record<string, string>;
+/** Possible values in filter parameters */
+type FilterValue = string | number | boolean | null | undefined | Record<string, unknown> | unknown[];
+/** Configuration options for QueryParser */
+interface QueryParserOptions {
+    /** Maximum allowed regex pattern length (default: 500) */
+    maxRegexLength?: number;
+    /** Maximum allowed text search query length (default: 200) */
+    maxSearchLength?: number;
+    /** Maximum allowed filter depth (default: 10) */
+    maxFilterDepth?: number;
+    /** Additional operators to block */
+    additionalDangerousOperators?: string[];
+}
+/**
+ * Query Parser Class
+ *
+ * Parses HTTP query parameters into MongoDB-compatible query objects.
+ * Includes security measures against NoSQL injection and ReDoS attacks.
+ *
+ * @example
+ * ```typescript
+ * import { QueryParser } from '@classytic/mongokit';
+ *
+ * const parser = new QueryParser({ maxRegexLength: 100 });
+ * const query = parser.parseQuery(req.query);
+ * ```
+ */
+declare class QueryParser {
+    private readonly options;
+    private readonly operators;
+    /**
+     * Dangerous MongoDB operators that should never be accepted from user input
+     * Security: Prevent NoSQL injection attacks
+     */
+    private readonly dangerousOperators;
+    /**
+     * Regex pattern characters that can cause catastrophic backtracking (ReDoS)
+     */
+    private readonly dangerousRegexPatterns;
+    constructor(options?: QueryParserOptions);
+    /**
+     * Parse query parameters into MongoDB query format
+     */
+    parseQuery(query: Record<string, unknown> | null | undefined): ParsedQuery;
+    /**
+     * Parse sort parameter
+     * Converts string like '-createdAt' to { createdAt: -1 }
+     * Handles multiple sorts: '-createdAt,name' → { createdAt: -1, name: 1 }
+     */
+    private _parseSort;
+    /**
+     * Parse standard filter parameter (filter[field]=value)
+     */
+    private _parseFilters;
+    /**
+     * Handle operator syntax: field[operator]=value
+     */
+    private _handleOperatorSyntax;
+    /**
+     * Handle bracket syntax with object value
+     */
+    private _handleBracketSyntax;
+    /**
+     * Convert operator to MongoDB format
+     */
+    private _toMongoOperator;
+    /**
+     * Create a safe regex pattern with protection against ReDoS attacks
+     * @param pattern - The pattern string from user input
+     * @param flags - Regex flags (default: 'i' for case-insensitive)
+     * @returns A safe RegExp or null if pattern is invalid/dangerous
+     */
+    private _createSafeRegex;
+    /**
+     * Escape special regex characters for literal matching
+     */
+    private _escapeRegex;
+    /**
+     * Sanitize text search query for MongoDB $text search
+     * @param search - Raw search input from user
+     * @returns Sanitized search string or undefined
+     */
+    private _sanitizeSearch;
+    /**
+     * Convert values based on operator type
+     */
+    private _convertValue;
+    /**
+     * Parse $or conditions
+     */
+    private _parseOr;
+    /**
+     * Enhance filters with between operator
+     */
+    private _enhanceWithBetween;
+}
+/** Default query parser instance with standard options */
+declare const defaultQueryParser: QueryParser;
+
+export { type FilterValue as F, type OperatorMap as O, QueryParser as Q, getMongooseProjection as a, type QueryParserOptions as b, createFieldPreset as c, defaultQueryParser as d, buildCrudSchemasFromMongooseSchema as e, filterResponseData as f, getFieldsForUser as g, buildCrudSchemasFromModel as h, getImmutableFields as i, getSystemManagedFields as j, isFieldUpdateAllowed as k, createError as l, createMemoryCache as m, validateUpdateBody as v };

package/dist/{types-B3dPUKjs.d.ts → types-CHIDluaP.d.ts}

@@ -348,30 +348,16 @@ interface JsonSchema {
     format?: string;
     pattern?: string;
 }
-/** CRUD schemas result */
+/** CRUD schemas result - framework-agnostic JSON schemas */
 interface CrudSchemas {
+    /** JSON Schema for create request body */
     createBody: JsonSchema;
+    /** JSON Schema for update request body */
     updateBody: JsonSchema;
+    /** JSON Schema for route params (id validation) */
     params: JsonSchema;
+    /** JSON Schema for list/query parameters */
     listQuery: JsonSchema;
-    crudSchemas: {
-        create: {
-            body: JsonSchema;
-        };
-        update: {
-            body: JsonSchema;
-            params: JsonSchema;
-        };
-        get: {
-            params: JsonSchema;
-        };
-        list: {
-            query: JsonSchema;
-        };
-        remove: {
-            params: JsonSchema;
-        };
-    };
 }
 /** Decoded cursor */
 interface DecodedCursor {
@@ -405,6 +391,8 @@ interface Logger {
     warn?(message: string, meta?: Record<string, unknown>): void;
     debug?(message: string, meta?: Record<string, unknown>): void;
 }
+/** Filter mode for soft delete queries */
+type SoftDeleteFilterMode = 'null' | 'exists';
 /** Soft delete plugin options */
 interface SoftDeleteOptions {
     /** Field name for deletion timestamp (default: 'deletedAt') */
@@ -413,6 +401,51 @@ interface SoftDeleteOptions {
     deletedByField?: string;
     /** Enable soft delete (default: true) */
     soft?: boolean;
+    /**
+     * Filter mode for excluding deleted documents (default: 'null')
+     * - 'null': Filters where deletedField is null (works with `default: null` in schema)
+     * - 'exists': Filters where deletedField does not exist (legacy behavior)
+     */
+    filterMode?: SoftDeleteFilterMode;
+    /** Add restore method to repository (default: true) */
+    addRestoreMethod?: boolean;
+    /** Add getDeleted method to repository (default: true) */
+    addGetDeletedMethod?: boolean;
+    /**
+     * TTL in days for auto-cleanup of deleted documents.
+     * When set, creates a TTL index on the deletedField.
+     * Documents will be automatically removed after the specified days.
+     */
+    ttlDays?: number;
+}
+/** Repository with soft delete methods */
+interface SoftDeleteRepository {
+    /**
+     * Restore a soft-deleted document by setting deletedAt to null
+     * @param id - Document ID to restore
+     * @param options - Optional session for transactions
+     * @returns The restored document
+     */
+    restore(id: string | ObjectId, options?: {
+        session?: ClientSession;
+    }): Promise<unknown>;
+    /**
+     * Get all soft-deleted documents
+     * @param params - Query parameters (filters, pagination, etc.)
+     * @param options - Query options (select, populate, etc.)
+     * @returns Paginated result of deleted documents
+     */
+    getDeleted(params?: {
+        filters?: Record<string, unknown>;
+        sort?: SortSpec | string;
+        page?: number;
+        limit?: number;
+    }, options?: {
+        select?: SelectSpec;
+        populate?: PopulateSpec;
+        lean?: boolean;
+        session?: ClientSession;
+    }): Promise<OffsetPaginationResult<unknown>>;
 }
 /** Lookup options for aggregate */
 interface LookupOptions {
@@ -533,4 +566,4 @@ interface HttpError extends Error {
     }>;
 }
 
-export type { AnyDocument as A, ValidatorDefinition as B, CreateOptions as C, DeleteResult as D, EventPayload as E, FieldPreset as F, ValidationChainOptions as G, HttpError as H, SoftDeleteOptions as I, JsonSchema as J, KeysetPaginationOptions as K, Logger as L, LookupOptions as M, GroupResult as N, OffsetPaginationOptions as O, PaginationConfig as P, MinMaxResult as Q, RepositoryOptions as R, SelectSpec as S, CacheAdapter as T, UpdateOptions as U, ValidationResult as V, CacheOptions as W, CacheOperationOptions as X, CacheStats as Y, CascadeRelation as Z, CascadeOptions as _, OffsetPaginationResult as a, KeysetPaginationResult as b, AggregatePaginationOptions as c, AggregatePaginationResult as d, PluginType as e, ObjectId as f, PopulateSpec as g, SortSpec as h, RepositoryContext as i, AnyModel as j, SortDirection as k, HookMode as l, PaginationResult as m, OperationOptions as n, UpdateManyResult as o, UpdateWithValidationResult as p, UserContext as q, Plugin as r, PluginFunction as s, RepositoryInstance as t, RepositoryEvent as u, ParsedQuery as v, FieldRules as w, SchemaBuilderOptions as x, CrudSchemas as y, DecodedCursor as z };
+export type { CacheStats as $, AnyDocument as A, DecodedCursor as B, CreateOptions as C, DeleteResult as D, EventPayload as E, FieldPreset as F, ValidatorDefinition as G, HttpError as H, ValidationChainOptions as I, JsonSchema as J, KeysetPaginationOptions as K, Logger as L, SoftDeleteOptions as M, SoftDeleteFilterMode as N, OffsetPaginationOptions as O, PaginationConfig as P, SoftDeleteRepository as Q, RepositoryOptions as R, SelectSpec as S, LookupOptions as T, UpdateOptions as U, ValidationResult as V, GroupResult as W, MinMaxResult as X, CacheAdapter as Y, CacheOptions as Z, CacheOperationOptions as _, OffsetPaginationResult as a, CascadeRelation as a0, CascadeOptions as a1, KeysetPaginationResult as b, AggregatePaginationOptions as c, AggregatePaginationResult as d, PopulateSpec as e, SortSpec as f, PluginType as g, ObjectId as h, RepositoryContext as i, AnyModel as j, SortDirection as k, HookMode as l, PaginationResult as m, OperationOptions as n, UpdateManyResult as o, UpdateWithValidationResult as p, UserContext as q, Plugin as r, PluginFunction as s, RepositoryInstance as t, RepositoryEvent as u, ParsedQuery as v, FilterQuery as w, FieldRules as x, SchemaBuilderOptions as y, CrudSchemas as z };