@classytic/mongokit 3.3.2 → 3.4.1

package/dist/{aggregate-BkOG9qwr.d.mts → index-BuoZIZ15.d.mts}

@@ -1,7 +1,95 @@
-import { C as GroupResult, F as ObjectId, G as PopulateSpec, K as ReadPreferenceType, N as MinMaxResult, R as OperationOptions, St as LookupOptions, _ as DeleteResult, at as SortSpec, ct as UpdateManyResult, et as SelectSpec, i as AnyDocument, lt as UpdateOptions, p as CreateOptions, ut as UpdateWithValidationResult } from "./types-pVY0w1Pp.mjs";
+import { Ct as LookupOptions, I as ObjectId, K as PopulateSpec, P as MinMaxResult, dt as UpdateWithValidationResult, i as AnyDocument, lt as UpdateManyResult, m as CreateOptions, ot as SortSpec, q as ReadPreferenceType, tt as SelectSpec, ut as UpdateOptions, v as DeleteResult, w as GroupResult, z as OperationOptions } from "./types-COINbsdL.mjs";
 import { ClientSession, Model, PipelineStage } from "mongoose";
 
-//#region src/actions/create.d.ts
+//#region src/actions/aggregate.d.ts
+declare namespace aggregate_d_exports {
+  export { aggregate, aggregatePaginate, average, countBy, distinct, facet, groupBy, lookup, minMax, sum, unwind };
+}
+/**
+ * Execute aggregation pipeline
+ */
+declare function aggregate<TResult = unknown>(Model: Model<any>, pipeline: PipelineStage[], options?: {
+  session?: ClientSession;
+}): Promise<TResult[]>;
+/**
+ * Aggregate with pagination using native MongoDB $facet
+ * WARNING: $facet results must be <16MB. For larger results (limit >1000),
+ * consider using Repository.aggregatePaginate() or splitting into separate queries.
+ */
+declare function aggregatePaginate<TDoc = AnyDocument>(Model: Model<TDoc>, pipeline: PipelineStage[], options?: {
+  page?: number;
+  limit?: number;
+  session?: ClientSession;
+}): Promise<{
+  docs: TDoc[];
+  total: number;
+  page: number;
+  limit: number;
+  pages: number;
+  hasNext: boolean;
+  hasPrev: boolean;
+}>;
+/**
+ * Group documents by field value
+ */
+declare function groupBy(Model: Model<any>, field: string, options?: {
+  limit?: number;
+  session?: ClientSession;
+}): Promise<GroupResult[]>;
+/**
+ * Count by field values
+ */
+declare function countBy(Model: Model<any>, field: string, query?: Record<string, unknown>, options?: {
+  session?: ClientSession;
+}): Promise<GroupResult[]>;
+/**
+ * Lookup (join) with another collection
+ *
+ * MongoDB $lookup has two mutually exclusive forms:
+ * 1. Simple form: { from, localField, foreignField, as }
+ * 2. Pipeline form: { from, let, pipeline, as }
+ *
+ * This function automatically selects the appropriate form based on parameters.
+ */
+declare function lookup<TDoc = AnyDocument>(Model: Model<TDoc>, lookupOptions: LookupOptions): Promise<TDoc[]>;
+/**
+ * Unwind array field
+ */
+declare function unwind<TDoc = AnyDocument>(Model: Model<TDoc>, field: string, options?: {
+  preserveEmpty?: boolean;
+  session?: ClientSession;
+}): Promise<TDoc[]>;
+/**
+ * Facet search (multiple aggregations in one query)
+ */
+declare function facet<TResult = Record<string, unknown[]>>(Model: Model<any>, facets: Record<string, PipelineStage[]>, options?: {
+  session?: ClientSession;
+}): Promise<TResult[]>;
+/**
+ * Get distinct values
+ */
+declare function distinct<T = unknown>(Model: Model<any>, field: string, query?: Record<string, unknown>, options?: {
+  session?: ClientSession;
+  readPreference?: string;
+}): Promise<T[]>;
+/**
+ * Calculate sum
+ */
+declare function sum(Model: Model<any>, field: string, query?: Record<string, unknown>, options?: {
+  session?: ClientSession;
+}): Promise<number>;
+/**
+ * Calculate average
+ */
+declare function average(Model: Model<any>, field: string, query?: Record<string, unknown>, options?: {
+  session?: ClientSession;
+}): Promise<number>;
+/**
+ * Min/Max
+ */
+declare function minMax(Model: Model<any>, field: string, query?: Record<string, unknown>, options?: {
+  session?: ClientSession;
+}): Promise<MinMaxResult>;
 declare namespace create_d_exports {
   export { create, createDefault, createMany, upsert };
 }
@@ -24,6 +112,42 @@ declare function upsert<TDoc = AnyDocument>(Model: Model<TDoc>, query: Record<st
   session?: ClientSession;
   updatePipeline?: boolean;
 }): Promise<TDoc | null>;
+declare namespace delete_d_exports {
+  export { deleteById, deleteByQuery, deleteMany, restore, softDelete };
+}
+/**
+ * Delete by ID
+ */
+declare function deleteById<TDoc = AnyDocument>(Model: Model<TDoc>, id: string | ObjectId, options?: {
+  session?: ClientSession;
+  query?: Record<string, unknown>;
+}): Promise<DeleteResult>;
+/**
+ * Delete many documents
+ */
+declare function deleteMany<TDoc = AnyDocument>(Model: Model<TDoc>, query: Record<string, unknown>, options?: {
+  session?: ClientSession;
+}): Promise<DeleteResult>;
+/**
+ * Delete by query
+ */
+declare function deleteByQuery(Model: Model<any>, query: Record<string, unknown>, options?: {
+  session?: ClientSession;
+  throwOnNotFound?: boolean;
+}): Promise<DeleteResult>;
+/**
+ * Soft delete (set deleted flag)
+ */
+declare function softDelete<TDoc = AnyDocument>(Model: Model<TDoc>, id: string | ObjectId, options?: {
+  session?: ClientSession;
+  userId?: string;
+}): Promise<DeleteResult>;
+/**
+ * Restore soft deleted document
+ */
+declare function restore<TDoc = AnyDocument>(Model: Model<TDoc>, id: string | ObjectId, options?: {
+  session?: ClientSession;
+}): Promise<DeleteResult>;
 declare namespace read_d_exports {
   export { count, exists, getAll, getById, getByQuery, getOrCreate, tryGetByQuery };
 }
@@ -50,7 +174,7 @@ declare function getByQuery<TDoc = AnyDocument>(Model: Model<TDoc>, query: Recor
 /**
  * Get document by query without throwing (returns null if not found)
  */
-declare function tryGetByQuery<TDoc = AnyDocument>(Model: Model<TDoc>, query: Record<string, unknown>, options?: Omit<OperationOptions, "throwOnNotFound">): Promise<TDoc | null>;
+declare function tryGetByQuery<TDoc = AnyDocument>(Model: Model<TDoc>, query: Record<string, unknown>, options?: Omit<OperationOptions, 'throwOnNotFound'>): Promise<TDoc | null>;
 /**
  * Get all documents (basic query without pagination)
  * For pagination, use Repository.paginate() or Repository.stream()
@@ -75,14 +199,14 @@ declare function getOrCreate<TDoc = AnyDocument>(Model: Model<TDoc>, query: Reco
 /**
  * Count documents matching query
  */
-declare function count(Model: Model<any>, query?: Record<string, unknown>, options?: {
+declare function count<TDoc = AnyDocument>(Model: Model<TDoc>, query?: Record<string, unknown>, options?: {
   session?: ClientSession;
   readPreference?: ReadPreferenceType;
 }): Promise<number>;
 /**
  * Check if document exists
  */
-declare function exists(Model: Model<any>, query: Record<string, unknown>, options?: {
+declare function exists<TDoc = AnyDocument>(Model: Model<TDoc>, query: Record<string, unknown>, options?: {
   session?: ClientSession;
   readPreference?: ReadPreferenceType;
 }): Promise<{
@@ -143,129 +267,8 @@ declare function pushToArray<TDoc = AnyDocument>(Model: Model<TDoc>, id: string
  * Pull from array
  */
 declare function pullFromArray<TDoc = AnyDocument>(Model: Model<TDoc>, id: string | ObjectId, field: string, value: unknown, options?: UpdateOptions): Promise<TDoc>;
-declare namespace delete_d_exports {
-  export { deleteById, deleteByQuery, deleteMany, restore, softDelete };
+declare namespace index_d_exports {
+  export { aggregate_d_exports as aggregate, create_d_exports as create, delete_d_exports as deleteActions, read_d_exports as read, update_d_exports as update };
 }
-/**
- * Delete by ID
- */
-declare function deleteById(Model: Model<any>, id: string | ObjectId, options?: {
-  session?: ClientSession;
-  query?: Record<string, unknown>;
-}): Promise<DeleteResult>;
-/**
- * Delete many documents
- */
-declare function deleteMany(Model: Model<any>, query: Record<string, unknown>, options?: {
-  session?: ClientSession;
-}): Promise<DeleteResult>;
-/**
- * Delete by query
- */
-declare function deleteByQuery(Model: Model<any>, query: Record<string, unknown>, options?: {
-  session?: ClientSession;
-  throwOnNotFound?: boolean;
-}): Promise<DeleteResult>;
-/**
- * Soft delete (set deleted flag)
- */
-declare function softDelete<TDoc = AnyDocument>(Model: Model<TDoc>, id: string | ObjectId, options?: {
-  session?: ClientSession;
-  userId?: string;
-}): Promise<DeleteResult>;
-/**
- * Restore soft deleted document
- */
-declare function restore<TDoc = AnyDocument>(Model: Model<TDoc>, id: string | ObjectId, options?: {
-  session?: ClientSession;
-}): Promise<DeleteResult>;
-declare namespace aggregate_d_exports {
-  export { aggregate, aggregatePaginate, average, countBy, distinct, facet, groupBy, lookup, minMax, sum, unwind };
-}
-/**
- * Execute aggregation pipeline
- */
-declare function aggregate<TResult = unknown>(Model: Model<any>, pipeline: PipelineStage[], options?: {
-  session?: ClientSession;
-}): Promise<TResult[]>;
-/**
- * Aggregate with pagination using native MongoDB $facet
- * WARNING: $facet results must be <16MB. For larger results (limit >1000),
- * consider using Repository.aggregatePaginate() or splitting into separate queries.
- */
-declare function aggregatePaginate<TDoc = AnyDocument>(Model: Model<TDoc>, pipeline: PipelineStage[], options?: {
-  page?: number;
-  limit?: number;
-  session?: ClientSession;
-}): Promise<{
-  docs: TDoc[];
-  total: number;
-  page: number;
-  limit: number;
-  pages: number;
-  hasNext: boolean;
-  hasPrev: boolean;
-}>;
-/**
- * Group documents by field value
- */
-declare function groupBy(Model: Model<any>, field: string, options?: {
-  limit?: number;
-  session?: ClientSession;
-}): Promise<GroupResult[]>;
-/**
- * Count by field values
- */
-declare function countBy(Model: Model<any>, field: string, query?: Record<string, unknown>, options?: {
-  session?: ClientSession;
-}): Promise<GroupResult[]>;
-/**
- * Lookup (join) with another collection
- *
- * MongoDB $lookup has two mutually exclusive forms:
- * 1. Simple form: { from, localField, foreignField, as }
- * 2. Pipeline form: { from, let, pipeline, as }
- *
- * This function automatically selects the appropriate form based on parameters.
- */
-declare function lookup<TDoc = AnyDocument>(Model: Model<TDoc>, lookupOptions: LookupOptions): Promise<TDoc[]>;
-/**
- * Unwind array field
- */
-declare function unwind<TDoc = AnyDocument>(Model: Model<TDoc>, field: string, options?: {
-  preserveEmpty?: boolean;
-  session?: ClientSession;
-}): Promise<TDoc[]>;
-/**
- * Facet search (multiple aggregations in one query)
- */
-declare function facet<TResult = Record<string, unknown[]>>(Model: Model<any>, facets: Record<string, PipelineStage[]>, options?: {
-  session?: ClientSession;
-}): Promise<TResult[]>;
-/**
- * Get distinct values
- */
-declare function distinct<T = unknown>(Model: Model<any>, field: string, query?: Record<string, unknown>, options?: {
-  session?: ClientSession;
-  readPreference?: string;
-}): Promise<T[]>;
-/**
- * Calculate sum
- */
-declare function sum(Model: Model<any>, field: string, query?: Record<string, unknown>, options?: {
-  session?: ClientSession;
-}): Promise<number>;
-/**
- * Calculate average
- */
-declare function average(Model: Model<any>, field: string, query?: Record<string, unknown>, options?: {
-  session?: ClientSession;
-}): Promise<number>;
-/**
- * Min/Max
- */
-declare function minMax(Model: Model<any>, field: string, query?: Record<string, unknown>, options?: {
-  session?: ClientSession;
-}): Promise<MinMaxResult>;
 //#endregion
-export { create_d_exports as a, read_d_exports as i, delete_d_exports as n, update_d_exports as r, aggregate_d_exports as t };
+export { create_d_exports as a, delete_d_exports as i, update_d_exports as n, aggregate_d_exports as o, read_d_exports as r, index_d_exports as t };