firestore-batch-updater 1.0.0 → 1.2.0

package/README.ko.md

@@ -1,5 +1,7 @@
 # Firestore Batch Updater
 
+[![npm version](https://img.shields.io/npm/v/firestore-batch-updater.svg)](https://www.npmjs.com/package/firestore-batch-updater)
+
 쿼리 기반 필터링과 진행 상황 추적 기능을 제공하는 Firebase Firestore 대량 업데이트 라이브러리입니다.
 
 [English](./README.md) | 한국어
@@ -10,7 +12,12 @@
 - 500개 제한 없음 - Firebase Admin SDK의 BulkWriter 활용
 - 변경 사항 미리보기 - 업데이트 전 Before/After 비교
 - 진행 상황 추적 - 실시간 진행률 콜백
-- 일괄 생성/Upsert - 여러 문서를 한 번에 생성 또는 upsert
+- 일괄 생성/Upsert/삭제 - 여러 문서를 한 번에 생성, upsert 또는 삭제
+- 정렬 및 제한 - `orderBy()`와 `limit()`으로 정밀한 제어
+- FieldValue 지원 - `increment()`, `arrayUnion()`, `delete()`, `serverTimestamp()` 등 사용 가능
+- 서브컬렉션 & 컬렉션 그룹 - 서브컬렉션 쿼리 또는 동일 이름의 모든 컬렉션 쿼리
+- Dry Run 모드 - 실제 변경 없이 작업 시뮬레이션
+- 문서 개수 조회 - 문서를 로드하지 않고 빠르게 개수 확인
 - 로그 파일 생성 - 감사를 위한 상세 작업 로그 (선택사항)
 
 ## 설치
@@ -71,13 +78,18 @@ console.log(`${result.successCount}개 문서 업데이트 완료`);
 
 | 메서드 | 설명 | 반환값 |
 |--------|------|--------|
-| `collection(path)` | 작업할 컬렉션 선택 | `this` |
+| `collection(path)` | 작업할 컬렉션 선택 (서브컬렉션 경로 지원) | `this` |
+| `collectionGroup(id)` | 동일 ID의 모든 컬렉션 쿼리 | `this` |
 | `where(field, op, value)` | 필터 조건 추가 (체이닝 가능) | `this` |
+| `orderBy(field, direction?)` | 정렬 추가 (체이닝 가능) | `this` |
+| `limit(count)` | 문서 수 제한 (체이닝 가능) | `this` |
+| `count()` | 매칭되는 문서 개수 조회 | `CountResult` |
 | `preview(data)` | 업데이트 전 미리보기 | `PreviewResult` |
 | `update(data, options?)` | 매칭되는 문서 업데이트 | `UpdateResult` |
 | `create(docs, options?)` | 새 문서 생성 | `CreateResult` |
 | `upsert(data, options?)` | 업데이트 또는 생성 (set with merge) | `UpsertResult` |
-| `getFields(field)` | 특정 필드 값 조회 | `FieldValue[]` |
+| `delete(options?)` | 매칭되는 문서 삭제 | `DeleteResult` |
+| `getFields(field)` | 특정 필드 값 조회 | `FieldValueResult[]` |
 
 ### 옵션
 
@@ -87,7 +99,8 @@ console.log(`${result.successCount}개 문서 업데이트 완료`);
 {
   onProgress?: (progress: ProgressInfo) => void;
   log?: LogOptions;
-  batchSize?: number;  // update/upsert 전용
+  batchSize?: number;  // update/upsert/delete 전용
+  dryRun?: boolean;    // update/upsert/delete 전용 - 실제 쓰기 없이 시뮬레이션
 }
 
 // ProgressInfo
@@ -109,15 +122,21 @@ console.log(`${result.successCount}개 문서 업데이트 완료`);
 - 미설정: 모든 문서를 메모리에 한 번에 로드 (소규모 컬렉션에 적합)
 - 설정 시 (예: `batchSize: 1000`): 커서 페이지네이션을 사용하여 배치 단위로 처리 (대규모 컬렉션의 메모리 문제 방지)
 
+**dryRun 옵션:**
+- `true` 설정 시: 실제 변경 없이 `DryRunResult` 반환 (`wouldAffect` 개수와 `sampleIds` 포함)
+
 ### 반환 타입
 
 | 타입 | 필드 |
 |------|------|
+| `CountResult` | `count` |
+| `DryRunResult` | `wouldAffect`, `sampleIds[]`, `operation` |
 | `PreviewResult` | `affectedCount`, `samples[]`, `affectedFields[]` |
 | `UpdateResult` | `successCount`, `failureCount`, `totalCount`, `failedDocIds?`, `logFilePath?` |
 | `CreateResult` | `successCount`, `failureCount`, `totalCount`, `createdIds[]`, `failedDocIds?`, `logFilePath?` |
 | `UpsertResult` | `successCount`, `failureCount`, `totalCount`, `failedDocIds?`, `logFilePath?` |
-| `FieldValue` | `id`, `value` |
+| `DeleteResult` | `successCount`, `failureCount`, `totalCount`, `deletedIds[]`, `failedDocIds?`, `logFilePath?` |
+| `FieldValueResult` | `id`, `value` |
 
 ## 사용 예시
 
@@ -156,6 +175,20 @@ const result = await updater
   .upsert({ tier: "premium", updatedAt: new Date() });
 ```
 
+### 문서 삭제
+
+```typescript
+// 조건에 맞는 문서 삭제
+const result = await updater
+  .collection("users")
+  .where("status", "==", "inactive")
+  .where("lastLoginAt", "<", ninetyDaysAgo)
+  .delete();
+
+console.log(`${result.successCount}개 문서 삭제됨`);
+console.log("삭제된 ID:", result.deletedIds);
+```
+
 ### 업데이트 전 미리보기
 
 ```typescript
@@ -215,7 +248,131 @@ const result = await updater
   .update({ status: "archived" });
 ```
 
-> **참고:** 서로 다른 필드에 여러 `where()` 조건을 사용할 경우, Firestore에서 [복합 인덱스](https://firebase.google.com/docs/firestore/query-data/indexing)가 필요할 수 있습니다. `FAILED_PRECONDITION` 오류가 발생하면 오류 메시지의 링크를 통해 필요한 인덱스를 생성하세요.
+### 정렬 및 제한
+
+```typescript
+// 상위 10명 점수 높은 사용자만 업데이트
+const result = await updater
+  .collection("users")
+  .where("status", "==", "active")
+  .orderBy("score", "desc")
+  .limit(10)
+  .update({ tier: "premium" });
+
+// 가장 오래된 비활성 사용자 100명 삭제
+const deleteResult = await updater
+  .collection("users")
+  .where("status", "==", "inactive")
+  .orderBy("lastLoginAt", "asc")
+  .limit(100)
+  .delete();
+```
+
+### FieldValue 사용
+
+```typescript
+import { BatchUpdater, FieldValue } from "firestore-batch-updater";
+
+// 숫자 증가
+await updater
+  .collection("products")
+  .where("id", "==", "product-1")
+  .update({ viewCount: FieldValue.increment(1) });
+
+// 배열에 항목 추가
+await updater
+  .collection("users")
+  .where("status", "==", "active")
+  .update({ tags: FieldValue.arrayUnion("premium", "verified") });
+
+// 배열에서 항목 제거
+await updater
+  .collection("users")
+  .where("id", "==", "user-1")
+  .update({ tags: FieldValue.arrayRemove("inactive") });
+
+// 서버 타임스탬프
+await updater
+  .collection("users")
+  .where("status", "==", "active")
+  .update({ updatedAt: FieldValue.serverTimestamp() });
+
+// 필드 삭제
+await updater
+  .collection("users")
+  .where("status", "==", "inactive")
+  .update({ temporaryData: FieldValue.delete() });
+```
+
+### 문서 개수 조회
+
+```typescript
+// 문서를 로드하지 않고 빠르게 개수 조회
+const result = await updater
+  .collection("users")
+  .where("status", "==", "inactive")
+  .count();
+
+console.log(`${result.count}명의 비활성 사용자 발견`);
+```
+
+### Dry Run 모드
+
+```typescript
+// 실제 변경 없이 작업 시뮬레이션
+const simulation = await updater
+  .collection("users")
+  .where("status", "==", "inactive")
+  .update(
+    { status: "archived" },
+    { dryRun: true }
+  );
+
+console.log(`${simulation.wouldAffect}개 문서가 영향을 받을 예정`);
+console.log("샘플 ID:", simulation.sampleIds);
+
+// 삭제에도 사용 가능
+const deleteSimulation = await updater
+  .collection("logs")
+  .where("createdAt", "<", thirtyDaysAgo)
+  .delete({ dryRun: true });
+
+console.log(`${deleteSimulation.wouldAffect}개 문서가 삭제될 예정`);
+```
+
+### 서브컬렉션
+
+```typescript
+// 특정 서브컬렉션 경로 쿼리
+const result = await updater
+  .collection("users/user-123/orders")
+  .where("status", "==", "pending")
+  .update({ status: "cancelled" });
+
+// 동적 경로 사용
+const userId = "user-123";
+await updater
+  .collection(`users/${userId}/notifications`)
+  .where("read", "==", false)
+  .delete();
+```
+
+### 컬렉션 그룹 쿼리
+
+```typescript
+// 모든 사용자의 "orders" 서브컬렉션을 한 번에 쿼리
+const result = await updater
+  .collectionGroup("orders")
+  .where("status", "==", "pending")
+  .where("createdAt", "<", thirtyDaysAgo)
+  .update({ status: "expired" });
+
+console.log(`${result.successCount}개 주문 업데이트 완료`);
+
+// 참고: collectionGroup은 쿼리 필드에 대한 Firestore 인덱스가 필요합니다
+```
+
+> **참고:** 서로 다른 필드에 여러 `where()` 조건을 사용하거나, `where()`와 `orderBy()`를 다른 필드에 사용할 경우, Firestore에서 [복합 인덱스](https://firebase.google.com/docs/firestore/query-data/indexing)가 필요할 수 있습니다. `FAILED_PRECONDITION` 오류가 발생하면 오류 메시지의 링크를 통해 필요한 인덱스를 생성하세요.
 
 ### 에러 처리
 

package/README.md

@@ -1,5 +1,7 @@
 # Firestore Batch Updater
 
+[![npm version](https://img.shields.io/npm/v/firestore-batch-updater.svg)](https://www.npmjs.com/package/firestore-batch-updater)
+
 Easy batch updates for Firebase Firestore with query-based filtering and progress tracking.
 
 English | [한국어](./README.ko.md)
@@ -10,7 +12,12 @@ English | [한국어](./README.ko.md)
 - No 500 document limit - Uses Firebase Admin SDK's BulkWriter
 - Preview changes - See before/after comparison before updating
 - Progress tracking - Real-time progress callbacks
-- Batch create/upsert - Create or upsert multiple documents at once
+- Batch create/upsert/delete - Create, upsert, or delete multiple documents at once
+- Sorting and limiting - Use `orderBy()` and `limit()` for precise control
+- FieldValue support - Use `increment()`, `arrayUnion()`, `delete()`, `serverTimestamp()`, etc.
+- Subcollection & Collection Group - Query subcollections or all collections with the same name
+- Dry run mode - Simulate operations without making changes
+- Count documents - Quickly count matching documents without loading them
 - Log file generation - Optional detailed operation logs for auditing
 
 ## Installation
@@ -71,13 +78,18 @@ console.log(`Updated ${result.successCount} documents`);
 
 | Method | Description | Returns |
 |--------|-------------|---------|
-| `collection(path)` | Select collection to operate on | `this` |
+| `collection(path)` | Select collection to operate on (supports subcollection paths) | `this` |
+| `collectionGroup(id)` | Query all collections with the same ID | `this` |
 | `where(field, op, value)` | Add filter condition (chainable) | `this` |
+| `orderBy(field, direction?)` | Add sorting (chainable) | `this` |
+| `limit(count)` | Limit number of documents (chainable) | `this` |
+| `count()` | Count matching documents | `CountResult` |
 | `preview(data)` | Preview changes before update | `PreviewResult` |
 | `update(data, options?)` | Update matching documents | `UpdateResult` |
 | `create(docs, options?)` | Create new documents | `CreateResult` |
 | `upsert(data, options?)` | Update or create (set with merge) | `UpsertResult` |
-| `getFields(field)` | Get specific field values | `FieldValue[]` |
+| `delete(options?)` | Delete matching documents | `DeleteResult` |
+| `getFields(field)` | Get specific field values | `FieldValueResult[]` |
 
 ### Options
 
@@ -87,7 +99,8 @@ All write operations support an optional `options` parameter:
 {
   onProgress?: (progress: ProgressInfo) => void;
   log?: LogOptions;
-  batchSize?: number;  // For update/upsert only
+  batchSize?: number;  // For update/upsert/delete
+  dryRun?: boolean;    // For update/upsert/delete - simulate without writing
 }
 
 // ProgressInfo
@@ -109,15 +122,21 @@ All write operations support an optional `options` parameter:
 - When not set: All documents are loaded into memory at once (suitable for small collections)
 - When set (e.g., `batchSize: 1000`): Documents are processed in batches using cursor pagination (suitable for large collections to prevent memory issues)
 
+**dryRun option:**
+- When `true`: Returns `DryRunResult` with `wouldAffect` count and `sampleIds` without making any changes
+
 ### Return Types
 
 | Type | Fields |
 |------|--------|
+| `CountResult` | `count` |
+| `DryRunResult` | `wouldAffect`, `sampleIds[]`, `operation` |
 | `PreviewResult` | `affectedCount`, `samples[]`, `affectedFields[]` |
 | `UpdateResult` | `successCount`, `failureCount`, `totalCount`, `failedDocIds?`, `logFilePath?` |
 | `CreateResult` | `successCount`, `failureCount`, `totalCount`, `createdIds[]`, `failedDocIds?`, `logFilePath?` |
 | `UpsertResult` | `successCount`, `failureCount`, `totalCount`, `failedDocIds?`, `logFilePath?` |
-| `FieldValue` | `id`, `value` |
+| `DeleteResult` | `successCount`, `failureCount`, `totalCount`, `deletedIds[]`, `failedDocIds?`, `logFilePath?` |
+| `FieldValueResult` | `id`, `value` |
 
 ## Usage Examples
 
@@ -156,6 +175,18 @@ const result = await updater
   .upsert({ tier: "premium", updatedAt: new Date() });
 ```
 
+### Delete Documents
+
+```typescript
+const result = await updater
+  .collection("users")
+  .where("status", "==", "inactive")
+  .delete();
+
+console.log(`Deleted ${result.successCount} documents`);
+console.log("Deleted IDs:", result.deletedIds);
+```
+
 ### Preview Before Update
 
 ```typescript
@@ -215,7 +246,130 @@ const result = await updater
   .update({ status: "archived" });
 ```
 
-> **Note:** When using multiple `where()` conditions on different fields, Firestore may require a [composite index](https://firebase.google.com/docs/firestore/query-data/indexing). If you see a `FAILED_PRECONDITION` error, follow the link in the error message to create the required index.
+> **Note:** When using multiple `where()` conditions on different fields, or combining `where()` with `orderBy()` on different fields, Firestore may require a [composite index](https://firebase.google.com/docs/firestore/query-data/indexing). If you see a `FAILED_PRECONDITION` error, follow the link in the error message to create the required index.
+
+### Sorting and Limiting
+
+```typescript
+// Get top 10 users by score
+const result = await updater
+  .collection("users")
+  .orderBy("score", "desc")
+  .limit(10)
+  .update({ featured: true });
+
+// Delete oldest 100 inactive users
+const deleted = await updater
+  .collection("users")
+  .where("status", "==", "inactive")
+  .orderBy("createdAt", "asc")
+  .limit(100)
+  .delete();
+```
+
+### Using FieldValue
+
+```typescript
+import { BatchUpdater, FieldValue } from "firestore-batch-updater";
+
+// Increment a counter
+await updater
+  .collection("users")
+  .where("status", "==", "active")
+  .update({ loginCount: FieldValue.increment(1) });
+
+// Add to array
+await updater
+  .collection("users")
+  .where("tier", "==", "premium")
+  .update({ tags: FieldValue.arrayUnion("vip", "priority") });
+
+// Remove from array
+await updater
+  .collection("users")
+  .where("status", "==", "inactive")
+  .update({ tags: FieldValue.arrayRemove("active") });
+
+// Server timestamp
+await updater
+  .collection("users")
+  .where("status", "==", "active")
+  .update({ lastSeen: FieldValue.serverTimestamp() });
+
+// Delete a field
+await updater
+  .collection("users")
+  .where("status", "==", "inactive")
+  .update({ temporaryData: FieldValue.delete() });
+```
+
+### Count Documents
+
+```typescript
+// Quickly count matching documents without loading them
+const result = await updater
+  .collection("users")
+  .where("status", "==", "inactive")
+  .count();
+
+console.log(`Found ${result.count} inactive users`);
+```
+
+### Dry Run Mode
+
+```typescript
+// Simulate an operation without making any changes
+const simulation = await updater
+  .collection("users")
+  .where("status", "==", "inactive")
+  .update(
+    { status: "archived" },
+    { dryRun: true }
+  );
+
+console.log(`Would affect ${simulation.wouldAffect} documents`);
+console.log("Sample IDs:", simulation.sampleIds);
+
+// Also works with delete
+const deleteSimulation = await updater
+  .collection("logs")
+  .where("createdAt", "<", thirtyDaysAgo)
+  .delete({ dryRun: true });
+
+console.log(`Would delete ${deleteSimulation.wouldAffect} documents`);
+```
+
+### Subcollections
+
+```typescript
+// Query a specific subcollection path
+const result = await updater
+  .collection("users/user-123/orders")
+  .where("status", "==", "pending")
+  .update({ status: "cancelled" });
+
+// Or use dynamic paths
+const userId = "user-123";
+await updater
+  .collection(`users/${userId}/notifications`)
+  .where("read", "==", false)
+  .delete();
+```
+
+### Collection Group Queries
+
+```typescript
+// Query ALL "orders" subcollections across all users
+const result = await updater
+  .collectionGroup("orders")
+  .where("status", "==", "pending")
+  .where("createdAt", "<", thirtyDaysAgo)
+  .update({ status: "expired" });
+
+console.log(`Updated ${result.successCount} orders across all users`);
+
+// Note: collectionGroup requires a Firestore index on the queried fields
+```
 
 ### Error Handling
 

package/dist/index.d.mts

@@ -1,4 +1,5 @@
 import { WhereFilterOp, Firestore } from 'firebase-admin/firestore';
+export { FieldValue } from 'firebase-admin/firestore';
 
 /**
  * Firestore Batch Updater Type Definitions
@@ -31,6 +32,11 @@ interface UpdateOptions {
      * When not set, all documents are loaded at once
      */
     batchSize?: number;
+    /**
+     * Dry run mode - simulate the operation without actually writing
+     * Returns what would happen without making any changes
+     */
+    dryRun?: boolean;
 }
 /**
  * Result of batch update operation
@@ -66,9 +72,16 @@ interface WhereCondition {
     value: any;
 }
 /**
- * Field value result
+ * OrderBy clause condition
+ */
+interface OrderByCondition {
+    field: string;
+    direction: "asc" | "desc";
+}
+/**
+ * Field value result from getFields()
  */
-interface FieldValue {
+interface FieldValueResult {
     id: string;
     value: any;
 }
@@ -122,6 +135,11 @@ interface UpsertOptions {
      * When not set, all documents are loaded at once
      */
     batchSize?: number;
+    /**
+     * Dry run mode - simulate the operation without actually writing
+     * Returns what would happen without making any changes
+     */
+    dryRun?: boolean;
 }
 /**
  * Result of batch upsert operation
@@ -132,6 +150,55 @@ interface UpsertResult {
     totalCount: number;
     failedDocIds?: string[];
 }
+/**
+ * Options for delete operations
+ */
+interface DeleteOptions {
+    /**
+     * Callback function for progress updates
+     * @param progress - Current progress information
+     */
+    onProgress?: (progress: ProgressInfo) => void;
+    /**
+     * Log file generation options
+     */
+    log?: LogOptions;
+    /**
+     * Batch size for pagination (optional)
+     * When set, documents are processed in batches to prevent memory issues with large collections
+     * When not set, all documents are loaded at once
+     */
+    batchSize?: number;
+    /**
+     * Dry run mode - simulate the operation without actually writing
+     * Returns what would happen without making any changes
+     */
+    dryRun?: boolean;
+}
+/**
+ * Result of batch delete operation
+ */
+interface DeleteResult {
+    successCount: number;
+    failureCount: number;
+    totalCount: number;
+    deletedIds: string[];
+    failedDocIds?: string[];
+}
+/**
+ * Result of count operation
+ */
+interface CountResult {
+    count: number;
+}
+/**
+ * Result of dry run operation
+ */
+interface DryRunResult {
+    wouldAffect: number;
+    sampleIds: string[];
+    operation: "update" | "upsert" | "delete";
+}
 /**
  * Log options for batch operations
  */
@@ -153,7 +220,7 @@ interface LogEntry {
  * Complete log data for an operation
  */
 interface OperationLog {
-    operation: "update" | "create" | "upsert";
+    operation: "update" | "create" | "upsert" | "delete";
     collection: string;
     startedAt: string;
     completedAt: string;
@@ -177,7 +244,10 @@ interface OperationLog {
 declare class BatchUpdater {
     private firestore;
     private collectionPath?;
+    private isCollectionGroup;
     private conditions;
+    private orderByConditions;
+    private limitCount?;
     /**
      * Create a new BatchUpdater instance
      * @param firestore - Initialized Firestore instance from firebase-admin
@@ -185,10 +255,17 @@ declare class BatchUpdater {
     constructor(firestore: Firestore);
     /**
      * Select a collection to operate on
+     * Supports subcollection paths like "users/userId/orders"
      * @param path - Collection path
      * @returns This instance for chaining
      */
     collection(path: string): this;
+    /**
+     * Select a collection group to operate on (queries across all subcollections with the same name)
+     * @param collectionId - Collection ID (not a path, just the collection name)
+     * @returns This instance for chaining
+     */
+    collectionGroup(collectionId: string): this;
     /**
      * Add a where condition to filter documents
      * @param field - Field path
@@ -197,6 +274,24 @@ declare class BatchUpdater {
      * @returns This instance for chaining
      */
     where(field: string, operator: WhereFilterOp, value: any): this;
+    /**
+     * Add an orderBy clause to sort documents
+     * @param field - Field path to sort by
+     * @param direction - Sort direction ('asc' or 'desc'), defaults to 'asc'
+     * @returns This instance for chaining
+     */
+    orderBy(field: string, direction?: "asc" | "desc"): this;
+    /**
+     * Limit the number of documents to process
+     * @param count - Maximum number of documents
+     * @returns This instance for chaining
+     */
+    limit(count: number): this;
+    /**
+     * Count documents matching the query conditions
+     * @returns Count result with number of matching documents
+     */
+    count(): Promise<CountResult>;
     /**
      * Preview changes before executing update
      * @param updateData - Data to update
@@ -206,20 +301,21 @@ declare class BatchUpdater {
     /**
      * Execute batch update operation
      * @param updateData - Data to update
-     * @param options - Update options (e.g., progress callback, log options, batchSize for pagination)
-     * @returns Update result with success/failure counts and optional log file path
+     * @param options - Update options (e.g., progress callback, log options, batchSize for pagination, dryRun)
+     * @returns Update result with success/failure counts and optional log file path, or DryRunResult if dryRun is true
      */
-    update(updateData: Record<string, any>, options?: UpdateOptions): Promise<UpdateResult & {
+    update(updateData: Record<string, any>, options?: UpdateOptions): Promise<(UpdateResult & {
         logFilePath?: string;
-    }>;
+    }) | DryRunResult>;
     /**
      * Get specific field values from matching documents
      * @param fieldPath - Field path to retrieve
      * @returns Array of field values with document IDs
      */
-    getFields(fieldPath: string): Promise<FieldValue[]>;
+    getFields(fieldPath: string): Promise<FieldValueResult[]>;
     /**
      * Create multiple documents in batch
+     * Note: This method does not work with collectionGroup()
      * @param documents - Array of documents to create
      * @param options - Create options (e.g., progress callback, log options)
      * @returns Create result with success/failure counts, created IDs, and optional log file path
@@ -231,12 +327,20 @@ declare class BatchUpdater {
      * Upsert documents matching query conditions
      * Updates existing documents or creates them if they don't exist
      * @param updateData - Data to set/merge
-     * @param options - Upsert options (e.g., progress callback, log options, batchSize for pagination)
-     * @returns Upsert result with success/failure counts and optional log file path
+     * @param options - Upsert options (e.g., progress callback, log options, batchSize for pagination, dryRun)
+     * @returns Upsert result with success/failure counts and optional log file path, or DryRunResult if dryRun is true
      */
-    upsert(updateData: Record<string, any>, options?: UpsertOptions): Promise<UpsertResult & {
+    upsert(updateData: Record<string, any>, options?: UpsertOptions): Promise<(UpsertResult & {
         logFilePath?: string;
-    }>;
+    }) | DryRunResult>;
+    /**
+     * Delete documents matching query conditions
+     * @param options - Delete options (e.g., progress callback, log options, batchSize for pagination, dryRun)
+     * @returns Delete result with success/failure counts, deleted IDs, and optional log file path, or DryRunResult if dryRun is true
+     */
+    delete(options?: DeleteOptions): Promise<(DeleteResult & {
+        logFilePath?: string;
+    }) | DryRunResult>;
     /**
      * Validate that collection is set
      * @private
@@ -269,7 +373,7 @@ declare function writeOperationLog(log: OperationLog, options: LogOptions): stri
 /**
  * Create a log collector for tracking operation entries
  */
-declare function createLogCollector(operation: "update" | "create" | "upsert", collection: string, conditions?: WhereCondition[], updateData?: Record<string, any>): {
+declare function createLogCollector(operation: "update" | "create" | "upsert" | "delete", collection: string, conditions?: WhereCondition[], updateData?: Record<string, any>): {
     addEntry: (documentId: string, status: "success" | "failure", error?: string) => void;
     finalize: (options: LogOptions) => string;
     getLog: () => OperationLog;
@@ -313,4 +417,4 @@ declare function isValidUpdateData(value: any): value is Record<string, any>;
  */
 declare function formatError(error: unknown, context?: string): string;
 
-export { BatchUpdater, type CreateDocumentInput, type CreateOptions, type CreateResult, type DocumentSnapshot, type FieldValue, type LogEntry, type LogOptions, type OperationLog, type PreviewResult, type ProgressInfo, type UpdateOptions, type UpdateResult, type UpsertOptions, type UpsertResult, type WhereCondition, calculateProgress, createLogCollector, formatError, formatOperationLog, getAffectedFields, isValidUpdateData, mergeUpdateData, writeOperationLog };
+export { BatchUpdater, type CountResult, type CreateDocumentInput, type CreateOptions, type CreateResult, type DeleteOptions, type DeleteResult, type DocumentSnapshot, type DryRunResult, type FieldValueResult, type LogEntry, type LogOptions, type OperationLog, type OrderByCondition, type PreviewResult, type ProgressInfo, type UpdateOptions, type UpdateResult, type UpsertOptions, type UpsertResult, type WhereCondition, calculateProgress, createLogCollector, formatError, formatOperationLog, getAffectedFields, isValidUpdateData, mergeUpdateData, writeOperationLog };