0
# Modular API
1

2
Modern Firebase v9+ style functional API providing tree-shakable imports and improved developer experience.
3

4
## Capabilities
5

6
### Firestore Initialization
7

8
Initialize and configure Firestore instances using the modular approach.
9

10
```typescript { .api }
11
/**
12
 * Get the default Firestore instance
13
 * @returns Firestore instance
14
 */
15
function getFirestore(): FirebaseFirestoreTypes.Firestore;
16

17
/**
18
 * Get Firestore instance for a specific Firebase app
19
 * @param app - Firebase app instance
20
 * @returns Firestore instance for the app
21
 */
22
function getFirestore(app: FirebaseAppTypes.Module): FirebaseFirestoreTypes.Firestore;
23

24
/**
25
 * Get Firestore instance with specific database ID
26
 * @param app - Optional Firebase app instance
27
 * @param databaseId - Database identifier
28
 * @returns Firestore instance for the specified database
29
 */
30
function getFirestore(app?: FirebaseAppTypes.Module, databaseId?: string): FirebaseFirestoreTypes.Firestore;
31

32
/**
33
 * Initialize Firestore with settings
34
 * @param app - Firebase app instance
35
 * @param settings - Firestore configuration settings
36
 * @param databaseId - Optional database identifier
37
 * @returns Promise resolving to initialized Firestore instance
38
 */
39
function initializeFirestore(
40
  app: FirebaseAppTypes.Module,
41
  settings: FirebaseFirestoreTypes.FirestoreSettings,
42
  databaseId?: string
43
): Promise<FirebaseFirestoreTypes.Firestore>;
44

45
/**
46
 * Connect to Firestore emulator
47
 * @param firestore - Firestore instance
48
 * @param host - Emulator host
49
 * @param port - Emulator port
50
 * @param options - Optional connection options
51
 */
52
function connectFirestoreEmulator(
53
  firestore: FirebaseFirestoreTypes.Firestore,
54
  host: string,
55
  port: number,
56
  options?: { mockUserToken?: object | string }
57
): void;
58
```
59

60
**Usage Examples:**
61

62
```typescript
63
import { initializeApp } from '@react-native-firebase/app';
64
import { 
65
  getFirestore, 
66
  initializeFirestore, 
67
  connectFirestoreEmulator 
68
} from '@react-native-firebase/firestore';
69

70
// Get default Firestore instance
71
const db = getFirestore();
72

73
// Get Firestore for specific app
74
const customApp = initializeApp(customConfig, 'customApp');
75
const customDb = getFirestore(customApp);
76

77
// Initialize with settings
78
const dbWithSettings = await initializeFirestore(customApp, {
79
  persistence: true,
80
  cacheSizeBytes: 50 * 1024 * 1024
81
});
82

83
// Connect to emulator (development)
84
if (__DEV__) {
85
  connectFirestoreEmulator(db, 'localhost', 8080);
86
}
87

88
// Multi-database setup
89
const mainDb = getFirestore();  // default database
90
const analyticsDb = getFirestore(undefined, 'analytics');  // custom database
91
```
92

93
### Document Operations
94

95
Core document operations using functional approach with explicit Firestore instance.
96

97
```typescript { .api }
98
/**
99
 * Get a document reference
100
 * @param firestore - Firestore instance
101
 * @param path - Document path
102
 * @param pathSegments - Additional path segments
103
 * @returns Document reference
104
 */
105
function doc(firestore: FirebaseFirestoreTypes.Firestore, path: string, ...pathSegments: string[]): FirebaseFirestoreTypes.DocumentReference;
106

107
/**
108
 * Get a document reference from a collection
109
 * @param reference - Collection reference
110
 * @param path - Optional document path
111
 * @param pathSegments - Additional path segments
112
 * @returns Document reference
113
 */
114
function doc<T>(reference: FirebaseFirestoreTypes.CollectionReference<T>, path?: string, ...pathSegments: string[]): FirebaseFirestoreTypes.DocumentReference<T>;
115

116
/**
117
 * Get a document reference from another document
118
 * @param reference - Document reference
119
 * @param path - Subcollection and document path
120
 * @param pathSegments - Additional path segments
121
 * @returns Document reference
122
 */
123
function doc<T>(reference: FirebaseFirestoreTypes.DocumentReference<T>, path: string, ...pathSegments: string[]): FirebaseFirestoreTypes.DocumentReference;
124

125
/**
126
 * Get document data
127
 * @param reference - Document reference
128
 * @returns Promise resolving to document snapshot
129
 */
130
function getDoc<T>(reference: FirebaseFirestoreTypes.DocumentReference<T>): Promise<FirebaseFirestoreTypes.DocumentSnapshot<T>>;
131

132
/**
133
 * Get document data from cache
134
 * @param reference - Document reference
135
 * @returns Promise resolving to cached document snapshot
136
 */
137
function getDocFromCache<T>(reference: FirebaseFirestoreTypes.DocumentReference<T>): Promise<FirebaseFirestoreTypes.DocumentSnapshot<T>>;
138

139
/**
140
 * Get document data from server
141
 * @param reference - Document reference
142
 * @returns Promise resolving to server document snapshot
143
 */
144
function getDocFromServer<T>(reference: FirebaseFirestoreTypes.DocumentReference<T>): Promise<FirebaseFirestoreTypes.DocumentSnapshot<T>>;
145

146
/**
147
 * Set document data
148
 * @param reference - Document reference
149
 * @param data - Document data to set
150
 * @returns Promise resolving when set completes
151
 */
152
function setDoc<T>(reference: FirebaseFirestoreTypes.DocumentReference<T>, data: FirebaseFirestoreTypes.WithFieldValue<T>): Promise<void>;
153

154
/**
155
 * Set document data with options
156
 * @param reference - Document reference
157
 * @param data - Partial document data
158
 * @param options - Set options for merging
159
 * @returns Promise resolving when set completes
160
 */
161
function setDoc<T>(
162
  reference: FirebaseFirestoreTypes.DocumentReference<T>,
163
  data: FirebaseFirestoreTypes.PartialWithFieldValue<T>,
164
  options: FirebaseFirestoreTypes.SetOptions
165
): Promise<void>;
166

167
/**
168
 * Update document fields
169
 * @param reference - Document reference
170
 * @param data - Update data
171
 * @returns Promise resolving when update completes
172
 */
173
function updateDoc<T>(reference: FirebaseFirestoreTypes.DocumentReference<T>, data: FirebaseFirestoreTypes.UpdateData<T>): Promise<void>;
174

175
/**
176
 * Update document using field paths
177
 * @param reference - Document reference
178
 * @param field - Field path to update
179
 * @param value - New field value
180
 * @param more - Additional field-value pairs
181
 * @returns Promise resolving when update completes
182
 */
183
function updateDoc(
184
  reference: FirebaseFirestoreTypes.DocumentReference,
185
  field: string | FirebaseFirestoreTypes.FieldPath,
186
  value: unknown,
187
  ...more: unknown[]
188
): Promise<void>;
189

190
/**
191
 * Delete a document
192
 * @param reference - Document reference
193
 * @returns Promise resolving when deletion completes
194
 */
195
function deleteDoc(reference: FirebaseFirestoreTypes.DocumentReference): Promise<void>;
196

197
/**
198
 * Add a document to a collection
199
 * @param reference - Collection reference
200
 * @param data - Document data to add
201
 * @returns Promise resolving to the new document reference
202
 */
203
function addDoc<T>(reference: FirebaseFirestoreTypes.CollectionReference<T>, data: FirebaseFirestoreTypes.WithFieldValue<T>): Promise<FirebaseFirestoreTypes.DocumentReference<T>>;
204
```
205

206
**Usage Examples:**
207

208
```typescript
209
import { 
210
  getFirestore, 
211
  doc, 
212
  getDoc, 
213
  setDoc, 
214
  updateDoc, 
215
  deleteDoc, 
216
  addDoc,
217
  collection
218
} from '@react-native-firebase/firestore';
219

220
const db = getFirestore();
221

222
// Document operations
223
const userRef = doc(db, 'users', 'userId');
224
const userSnapshot = await getDoc(userRef);
225

226
if (userSnapshot.exists()) {
227
  console.log('User data:', userSnapshot.data());
228
}
229

230
// Set document
231
await setDoc(userRef, {
232
  name: 'John Doe',
233
  email: 'john@example.com',
234
  createdAt: serverTimestamp()
235
});
236

237
// Update document
238
await updateDoc(userRef, {
239
  lastLoginAt: serverTimestamp(),
240
  loginCount: increment(1)
241
});
242

243
// Delete document
244
await deleteDoc(userRef);
245

246
// Add document to collection
247
const usersRef = collection(db, 'users');
248
const newUserRef = await addDoc(usersRef, {
249
  name: 'Jane Doe',
250
  email: 'jane@example.com'
251
});
252

253
// Get document from different sources
254
const cacheSnapshot = await getDocFromCache(userRef);
255
const serverSnapshot = await getDocFromServer(userRef);
256

257
// Nested document paths
258
const postRef = doc(db, 'users', 'userId', 'posts', 'postId');
259
const commentRef = doc(postRef, 'comments', 'commentId');
260
```
261

262
### Collection Operations
263

264
Work with collections using the modular API pattern.
265

266
```typescript { .api }
267
/**
268
 * Get a collection reference
269
 * @param firestore - Firestore instance
270
 * @param path - Collection path
271
 * @param pathSegments - Additional path segments
272
 * @returns Collection reference
273
 */
274
function collection(firestore: FirebaseFirestoreTypes.Firestore, path: string, ...pathSegments: string[]): FirebaseFirestoreTypes.CollectionReference;
275

276
/**
277
 * Get a subcollection reference from a collection
278
 * @param reference - Parent collection reference
279
 * @param path - Subcollection path
280
 * @param pathSegments - Additional path segments
281
 * @returns Collection reference
282
 */
283
function collection<T>(reference: FirebaseFirestoreTypes.CollectionReference<T>, path: string, ...pathSegments: string[]): FirebaseFirestoreTypes.CollectionReference;
284

285
/**
286
 * Get a subcollection reference from a document
287
 * @param reference - Parent document reference
288
 * @param path - Subcollection path
289
 * @param pathSegments - Additional path segments
290
 * @returns Collection reference
291
 */
292
function collection<T>(reference: FirebaseFirestoreTypes.DocumentReference<T>, path: string, ...pathSegments: string[]): FirebaseFirestoreTypes.CollectionReference;
293

294
/**
295
 * Query across collection groups
296
 * @param firestore - Firestore instance
297
 * @param collectionId - Collection identifier
298
 * @returns Query for collection group
299
 */
300
function collectionGroup(firestore: FirebaseFirestoreTypes.Firestore, collectionId: string): FirebaseFirestoreTypes.Query;
301
```
302

303
**Usage Examples:**
304

305
```typescript
306
import { 
307
  getFirestore, 
308
  collection, 
309
  collectionGroup, 
310
  doc, 
311
  getDocs 
312
} from '@react-native-firebase/firestore';
313

314
const db = getFirestore();
315

316
// Collection references
317
const usersRef = collection(db, 'users');
318
const postsRef = collection(db, 'posts');
319

320
// Subcollection from document
321
const userRef = doc(db, 'users', 'userId');
322
const userPostsRef = collection(userRef, 'posts');
323

324
// Nested collections
325
const commentsRef = collection(db, 'users', 'userId', 'posts', 'postId', 'comments');
326

327
// Collection group query
328
const allCommentsQuery = collectionGroup(db, 'comments');
329
const allCommentsSnapshot = await getDocs(allCommentsQuery);
330
```
331

332
### Query Operations
333

334
Build and execute queries using composable query constraints.
335

336
```typescript { .api }
337
/**
338
 * Create a query with constraints
339
 * @param query - Base query
340
 * @param queryConstraints - Query constraints to apply
341
 * @returns New query with constraints applied
342
 */
343
function query<T>(query: FirebaseFirestoreTypes.Query<T>, ...queryConstraints: FirebaseFirestoreTypes.QueryConstraint[]): FirebaseFirestoreTypes.Query<T>;
344

345
/**
346
 * Create where constraint
347
 * @param fieldPath - Field to filter on
348
 * @param opStr - Comparison operator
349
 * @param value - Value to compare against
350
 * @returns Query field filter constraint
351
 */
352
function where(fieldPath: string | FirebaseFirestoreTypes.FieldPath, opStr: FirebaseFirestoreTypes.WhereFilterOp, value: unknown): FirebaseFirestoreTypes.QueryFieldFilterConstraint;
353

354
/**
355
 * Create AND composite filter
356
 * @param queries - Filter constraints to combine with AND
357
 * @returns Composite AND filter constraint
358
 */
359
function and(...queries: FirebaseFirestoreTypes.QueryFilterConstraint[]): FirebaseFirestoreTypes.QueryCompositeFilterConstraint;
360

361
/**
362
 * Create OR composite filter
363
 * @param queries - Filter constraints to combine with OR
364
 * @returns Composite OR filter constraint
365
 */
366
function or(...queries: FirebaseFirestoreTypes.QueryFilterConstraint[]): FirebaseFirestoreTypes.QueryCompositeFilterConstraint;
367

368
/**
369
 * Create order by constraint
370
 * @param fieldPath - Field to order by
371
 * @param directionStr - Sort direction
372
 * @returns Query order by constraint
373
 */
374
function orderBy(fieldPath: string | FirebaseFirestoreTypes.FieldPath, directionStr?: FirebaseFirestoreTypes.OrderByDirection): FirebaseFirestoreTypes.QueryOrderByConstraint;
375

376
/**
377
 * Create limit constraint
378
 * @param limit - Maximum number of documents
379
 * @returns Query limit constraint
380
 */
381
function limit(limit: number): FirebaseFirestoreTypes.QueryLimitConstraint;
382

383
/**
384
 * Create limit to last constraint
385
 * @param limit - Number of documents from the end
386
 * @returns Query constraint
387
 */
388
function limitToLast(limit: number): FirebaseFirestoreTypes.QueryConstraint;
389

390
/**
391
 * Create start at constraint
392
 * @param fieldValues - Field values to start at
393
 * @returns Query start at constraint
394
 */
395
function startAt(...fieldValues: unknown[]): FirebaseFirestoreTypes.QueryStartAtConstraint;
396

397
/**
398
 * Create start after constraint
399
 * @param fieldValues - Field values to start after
400
 * @returns Query start at constraint
401
 */
402
function startAfter(...fieldValues: unknown[]): FirebaseFirestoreTypes.QueryStartAtConstraint;
403

404
/**
405
 * Create end at constraint
406
 * @param fieldValues - Field values to end at
407
 * @returns Query end at constraint
408
 */
409
function endAt(...fieldValues: unknown[]): FirebaseFirestoreTypes.QueryEndAtConstraint;
410

411
/**
412
 * Create end before constraint
413
 * @param fieldValues - Field values to end before
414
 * @returns Query end at constraint
415
 */
416
function endBefore(...fieldValues: unknown[]): FirebaseFirestoreTypes.QueryEndAtConstraint;
417

418
/**
419
 * Execute query and get results
420
 * @param query - Query to execute
421
 * @returns Promise resolving to query snapshot
422
 */
423
function getDocs<T>(query: FirebaseFirestoreTypes.Query<T>): Promise<FirebaseFirestoreTypes.QuerySnapshot<T>>;
424

425
/**
426
 * Execute query and get results from cache
427
 * @param query - Query to execute
428
 * @returns Promise resolving to cached query snapshot
429
 */
430
function getDocsFromCache<T>(query: FirebaseFirestoreTypes.Query<T>): Promise<FirebaseFirestoreTypes.QuerySnapshot<T>>;
431

432
/**
433
 * Execute query and get results from server
434
 * @param query - Query to execute
435
 * @returns Promise resolving to server query snapshot
436
 */
437
function getDocsFromServer<T>(query: FirebaseFirestoreTypes.Query<T>): Promise<FirebaseFirestoreTypes.QuerySnapshot<T>>;
438
```
439

440
**Usage Examples:**
441

442
```typescript
443
import { 
444
  getFirestore, 
445
  collection, 
446
  query, 
447
  where, 
448
  orderBy, 
449
  limit, 
450
  getDocs,
451
  and,
452
  or
453
} from '@react-native-firebase/firestore';
454

455
const db = getFirestore();
456
const usersRef = collection(db, 'users');
457

458
// Basic query
459
const activeUsersQuery = query(
460
  usersRef,
461
  where('active', '==', true),
462
  orderBy('createdAt', 'desc'),
463
  limit(10)
464
);
465

466
const activeUsersSnapshot = await getDocs(activeUsersQuery);
467

468
// Complex composite queries
469
const complexQuery = query(
470
  usersRef,
471
  and(
472
    or(
473
      where('role', '==', 'admin'),
474
      where('role', '==', 'moderator')
475
    ),
476
    where('active', '==', true)
477
  ),
478
  orderBy('lastLoginAt', 'desc')
479
);
480

481
// Pagination
482
const firstPage = query(
483
  usersRef,
484
  orderBy('createdAt'),
485
  limit(20)
486
);
487

488
const firstPageSnapshot = await getDocs(firstPage);
489
const lastDoc = firstPageSnapshot.docs[firstPageSnapshot.docs.length - 1];
490

491
const nextPage = query(
492
  usersRef,
493
  orderBy('createdAt'),
494
  startAfter(lastDoc),
495
  limit(20)
496
);
497

498
// Different data sources
499
const cacheResults = await getDocsFromCache(activeUsersQuery);
500
const serverResults = await getDocsFromServer(activeUsersQuery);
501
```
502

503
### Real-time Listeners
504

505
Set up real-time listeners using the modular API.
506

507
```typescript { .api }
508
/**
509
 * Listen to document changes
510
 * @param reference - Document reference
511
 * @param observer - Observer with next, error, complete handlers
512
 * @returns Unsubscribe function
513
 */
514
function onSnapshot<T>(
515
  reference: FirebaseFirestoreTypes.DocumentReference<T>,
516
  observer: {
517
    next?: (snapshot: FirebaseFirestoreTypes.DocumentSnapshot<T>) => void;
518
    error?: (error: Error) => void;
519
    complete?: () => void;
520
  }
521
): FirebaseFirestoreTypes.Unsubscribe;
522

523
/**
524
 * Listen to query changes
525
 * @param query - Query to listen to
526
 * @param observer - Observer with next, error, complete handlers
527
 * @returns Unsubscribe function
528
 */
529
function onSnapshot<T>(
530
  query: FirebaseFirestoreTypes.Query<T>,
531
  observer: {
532
    next?: (snapshot: FirebaseFirestoreTypes.QuerySnapshot<T>) => void;
533
    error?: (error: Error) => void;
534
    complete?: () => void;
535
  }
536
): FirebaseFirestoreTypes.Unsubscribe;
537

538
/**
539
 * Listen to snapshots in sync
540
 * @param firestore - Firestore instance
541
 * @param observer - Observer for sync events
542
 * @returns Unsubscribe function
543
 */
544
function onSnapshotsInSync(
545
  firestore: FirebaseFirestoreTypes.Firestore,
546
  observer: {
547
    next?: () => void;
548
    error?: (error: Error) => void;
549
    complete?: () => void;
550
  }
551
): FirebaseFirestoreTypes.Unsubscribe;
552
```
553

554
**Usage Examples:**
555

556
```typescript
557
import { 
558
  getFirestore, 
559
  doc, 
560
  collection, 
561
  query, 
562
  where, 
563
  onSnapshot,
564
  onSnapshotsInSync
565
} from '@react-native-firebase/firestore';
566

567
const db = getFirestore();
568

569
// Document listener
570
const userRef = doc(db, 'users', 'userId');
571
const unsubscribeUser = onSnapshot(userRef, {
572
  next: (snapshot) => {
573
    if (snapshot.exists()) {
574
      console.log('User data:', snapshot.data());
575
    }
576
  },
577
  error: (error) => {
578
    console.error('User listener error:', error);
579
  }
580
});
581

582
// Query listener
583
const activeUsersQuery = query(
584
  collection(db, 'users'),
585
  where('active', '==', true)
586
);
587

588
const unsubscribeUsers = onSnapshot(activeUsersQuery, {
589
  next: (snapshot) => {
590
    snapshot.docChanges().forEach((change) => {
591
      console.log(change.type, change.doc.data());
592
    });
593
  }
594
});
595

596
// Snapshots in sync listener
597
const unsubscribeSync = onSnapshotsInSync(db, {
598
  next: () => {
599
    console.log('All snapshots are in sync');
600
  }
601
});
602

603
// Cleanup
604
unsubscribeUser();
605
unsubscribeUsers();
606
unsubscribeSync();
607
```
608

609
### Aggregation Operations
610

611
Server-side aggregation functions for counting, summing, and averaging without downloading all documents.
612

613
```typescript { .api }
614
/**
615
 * Get count of documents matching a query from server
616
 * @param query - Query to count documents for
617
 * @returns Promise resolving to aggregate query snapshot with count
618
 */
619
function getCountFromServer<T>(query: FirebaseFirestoreTypes.Query<T>): Promise<FirebaseFirestoreTypes.AggregateQuerySnapshot<{count: FirebaseFirestoreTypes.AggregateField<number>}, T>>;
620

621
/**
622
 * Get aggregated data from server based on aggregate specification
623
 * @param query - Query to aggregate documents for
624
 * @param aggregateSpec - Specification of aggregations to perform
625
 * @returns Promise resolving to aggregate query snapshot
626
 */
627
function getAggregateFromServer<T>(query: FirebaseFirestoreTypes.Query<T>, aggregateSpec: FirebaseFirestoreTypes.AggregateSpec): Promise<FirebaseFirestoreTypes.AggregateQuerySnapshot<T>>;
628

629
/**
630
 * Create sum aggregation field
631
 * @param field - Field path to sum
632
 * @returns AggregateField for sum operation
633
 */
634
function sum(field: string | FirebaseFirestoreTypes.FieldPath): FirebaseFirestoreTypes.AggregateField<number>;
635

636
/**
637
 * Create average aggregation field
638
 * @param field - Field path to average
639
 * @returns AggregateField for average operation
640
 */
641
function average(field: string | FirebaseFirestoreTypes.FieldPath): FirebaseFirestoreTypes.AggregateField<number | null>;
642

643
/**
644
 * Create count aggregation field
645
 * @returns AggregateField for count operation
646
 */
647
function count(): FirebaseFirestoreTypes.AggregateField<number>;
648

649
interface AggregateSpec {
650
  [key: string]: FirebaseFirestoreTypes.AggregateField<any>;
651
}
652

653
interface AggregateQuerySnapshot<T> {
654
  /**
655
   * Get the aggregated data
656
   * @returns Object containing aggregation results
657
   */
658
  data(): T;
659
}
660

661
interface AggregateField<T> {
662
  /**
663
   * Get the aggregated value
664
   * @returns The aggregated result
665
   */
666
  value(): T;
667
}
668
```
669

670
**Usage Examples:**
671

672
```typescript
673
import { 
674
  getFirestore, 
675
  collection, 
676
  query, 
677
  where, 
678
  getCountFromServer,
679
  getAggregateFromServer,
680
  sum,
681
  average,
682
  count
683
} from '@react-native-firebase/firestore';
684

685
const db = getFirestore();
686

687
// Count documents
688
const usersQuery = query(collection(db, 'users'), where('active', '==', true));
689
const countSnapshot = await getCountFromServer(usersQuery);
690
console.log('Active users count:', countSnapshot.data().count);
691

692
// Multiple aggregations
693
const ordersQuery = query(collection(db, 'orders'), where('status', '==', 'completed'));
694
const aggregateSnapshot = await getAggregateFromServer(ordersQuery, {
695
  totalRevenue: sum('amount'),
696
  averageOrderValue: average('amount'),
697
  orderCount: count()
698
});
699

700
const results = aggregateSnapshot.data();
701
console.log('Total revenue:', results.totalRevenue.value());
702
console.log('Average order:', results.averageOrderValue.value());
703
console.log('Order count:', results.orderCount.value());
704

705
// Product analytics aggregation
706
const productQuery = query(collection(db, 'products'), where('category', '==', 'electronics'));
707
const productStats = await getAggregateFromServer(productQuery, {
708
  totalInventory: sum('stock'),
709
  averagePrice: average('price'),
710
  productCount: count()
711
});
712

713
const stats = productStats.data();
714
console.log(`Electronics: ${stats.productCount.value()} products`);
715
console.log(`Total inventory: ${stats.totalInventory.value()} units`);
716
console.log(`Average price: $${stats.averagePrice.value()?.toFixed(2) || 0}`);
717
```
718

719
### Bundle Operations
720

721
Load and work with data bundles using the modular API.
722

723
```typescript { .api }
724
/**
725
 * Load a data bundle
726
 * @param firestore - Firestore instance
727
 * @param bundleData - Bundle data as string, ArrayBuffer, or ReadableStream
728
 * @returns LoadBundleTask for monitoring progress
729
 */
730
function loadBundle(
731
  firestore: FirebaseFirestoreTypes.Firestore, 
732
  bundleData: ReadableStream<Uint8Array> | ArrayBuffer | string
733
): FirebaseFirestoreTypes.LoadBundleTask;
734

735
/**
736
 * Get a named query from a loaded bundle
737
 * @param firestore - Firestore instance
738
 * @param name - Name of the query in the bundle
739
 * @returns Promise resolving to Query or null if not found
740
 */
741
function namedQuery(firestore: FirebaseFirestoreTypes.Firestore, name: string): Promise<FirebaseFirestoreTypes.Query | null>;
742

743
interface LoadBundleTask {
744
  /**
745
   * Promise that resolves when the bundle loading completes
746
   */
747
  then(onFulfilled?: (progress: FirebaseFirestoreTypes.LoadBundleTaskProgress) => any): Promise<any>;
748
  
749
  /**
750
   * Catch errors during bundle loading
751
   */
752
  catch(onRejected?: (error: Error) => any): Promise<any>;
753
}
754
```
755

756
**Usage Examples:**
757

758
```typescript
759
import { 
760
  getFirestore, 
761
  loadBundle, 
762
  namedQuery,
763
  getDocs
764
} from '@react-native-firebase/firestore';
765

766
const db = getFirestore();
767

768
// Load bundle with progress monitoring
769
async function loadDataBundle() {
770
  try {
771
    const bundleData = await fetch('/api/data-bundle').then(r => r.text());
772
    
773
    const loadTask = loadBundle(db, bundleData);
774
    const progress = await loadTask;
775
    
776
    console.log('Bundle loaded:', progress.taskState);
777
    
778
    // Use named queries
779
    const featuredQuery = await namedQuery(db, 'featured-products');
780
    if (featuredQuery) {
781
      const snapshot = await getDocs(featuredQuery);
782
      console.log(`Featured products: ${snapshot.size}`);
783
    }
784
  } catch (error) {
785
    console.error('Bundle loading failed:', error);
786
  }
787
}
788
```
789

790
### Transactions & Batches
791

792
Atomic operations using the modular API.
793

794
```typescript { .api }
795
/**
796
 * Execute a transaction
797
 * @param firestore - Firestore instance
798
 * @param updateFunction - Function that performs transaction operations
799
 * @returns Promise resolving to transaction result
800
 */
801
function runTransaction<T>(
802
  firestore: FirebaseFirestoreTypes.Firestore,
803
  updateFunction: (transaction: FirebaseFirestoreTypes.Transaction) => Promise<T>
804
): Promise<T>;
805

806
/**
807
 * Create a write batch
808
 * @param firestore - Firestore instance
809
 * @returns WriteBatch instance
810
 */
811
function writeBatch(firestore: FirebaseFirestoreTypes.Firestore): FirebaseFirestoreTypes.WriteBatch;
812
```
813

814
**Usage Examples:**
815

816
```typescript
817
import { 
818
  getFirestore, 
819
  doc, 
820
  runTransaction, 
821
  writeBatch,
822
  serverTimestamp,
823
  increment
824
} from '@react-native-firebase/firestore';
825

826
const db = getFirestore();
827

828
// Transaction
829
const result = await runTransaction(db, async (transaction) => {
830
  const userRef = doc(db, 'users', 'userId');
831
  const userDoc = await transaction.get(userRef);
832
  
833
  if (!userDoc.exists()) {
834
    throw new Error('User does not exist');
835
  }
836
  
837
  transaction.update(userRef, {
838
    loginCount: increment(1),
839
    lastLoginAt: serverTimestamp()
840
  });
841
  
842
  return { newLoginCount: userDoc.data().loginCount + 1 };
843
});
844

845
// Write batch
846
const batch = writeBatch(db);
847

848
const user1Ref = doc(db, 'users', 'user1');
849
const user2Ref = doc(db, 'users', 'user2');
850

851
batch.set(user1Ref, { name: 'John', active: true });
852
batch.update(user2Ref, { lastUpdated: serverTimestamp() });
853

854
await batch.commit();
855
```
856

857
### Field Value Operations
858

859
Modular functions for special field operations like server timestamps, increments, and array modifications.
860

861
```typescript { .api }
862
/**
863
 * Server timestamp placeholder for modular API
864
 * @returns FieldValue representing server timestamp
865
 */
866
function serverTimestamp(): FirebaseFirestoreTypes.FieldValue;
867

868
/**
869
 * Field deletion marker for modular API
870
 * @returns FieldValue that deletes the field
871
 */
872
function deleteField(): FirebaseFirestoreTypes.FieldValue;
873

874
/**
875
 * Numeric increment operation for modular API
876
 * @param n - Number to increment by (can be negative for decrement)
877
 * @returns FieldValue that increments the field
878
 */
879
function increment(n: number): FirebaseFirestoreTypes.FieldValue;
880

881
/**
882
 * Array union operation for modular API (adds elements not already present)
883
 * @param elements - Elements to add to the array
884
 * @returns FieldValue that performs array union
885
 */
886
function arrayUnion(...elements: unknown[]): FirebaseFirestoreTypes.FieldValue;
887

888
/**
889
 * Array remove operation for modular API (removes all instances of elements)
890
 * @param elements - Elements to remove from the array
891
 * @returns FieldValue that performs array removal
892
 */
893
function arrayRemove(...elements: unknown[]): FirebaseFirestoreTypes.FieldValue;
894
```
895

896
**Usage Examples:**
897

898
```typescript
899
import { 
900
  getFirestore, 
901
  doc, 
902
  setDoc, 
903
  updateDoc,
904
  serverTimestamp,
905
  deleteField,
906
  increment,
907
  arrayUnion,
908
  arrayRemove
909
} from '@react-native-firebase/firestore';
910

911
const db = getFirestore();
912
const userRef = doc(db, 'users', 'userId');
913

914
// Server timestamps
915
await setDoc(userRef, {
916
  name: 'John Doe',
917
  createdAt: serverTimestamp(),
918
  updatedAt: serverTimestamp()
919
});
920

921
// Increment/decrement operations
922
await updateDoc(userRef, {
923
  loginCount: increment(1),
924
  credits: increment(-10) // Deduct 10 credits
925
});
926

927
// Array operations
928
await updateDoc(userRef, {
929
  // Add tags (only if not already present)
930
  tags: arrayUnion('premium', 'verified'),
931
  
932
  // Remove tags (all instances)
933
  blockedUsers: arrayRemove('spam-user-1', 'spam-user-2')
934
});
935

936
// Delete fields
937
await updateDoc(userRef, {
938
  temporaryField: deleteField(),
939
  updatedAt: serverTimestamp()
940
});
941

942
// Complex update with multiple field values
943
await updateDoc(doc(db, 'products', 'productId'), {
944
  viewCount: increment(1),
945
  categories: arrayUnion('featured'),
946
  lastViewedAt: serverTimestamp(),
947
  oldField: deleteField()
948
});
949
```
950

951
### Network & Persistence Operations
952

953
Modular functions for network and persistence management.
954

955
```typescript { .api }
956
/**
957
 * Enable network connectivity for Firestore
958
 * @param firestore - Firestore instance
959
 * @returns Promise resolving when network is enabled
960
 */
961
function enableNetwork(firestore: FirebaseFirestoreTypes.Firestore): Promise<void>;
962

963
/**
964
 * Disable network connectivity for Firestore
965
 * @param firestore - Firestore instance
966
 * @returns Promise resolving when network is disabled
967
 */
968
function disableNetwork(firestore: FirebaseFirestoreTypes.Firestore): Promise<void>;
969

970
/**
971
 * Clear all cached data and pending writes
972
 * @param firestore - Firestore instance
973
 * @returns Promise resolving when persistence is cleared
974
 */
975
function clearPersistence(firestore: FirebaseFirestoreTypes.Firestore): Promise<void>;
976

977
/**
978
 * Clear IndexedDB persistence (web platform)
979
 * @param firestore - Firestore instance
980
 * @returns Promise resolving when IndexedDB persistence is cleared
981
 */
982
function clearIndexedDbPersistence(firestore: FirebaseFirestoreTypes.Firestore): Promise<void>;
983

984
/**
985
 * Wait for all pending writes to complete
986
 * @param firestore - Firestore instance
987
 * @returns Promise resolving when all writes are committed
988
 */
989
function waitForPendingWrites(firestore: FirebaseFirestoreTypes.Firestore): Promise<void>;
990

991
/**
992
 * Terminate the Firestore instance and clean up resources
993
 * @param firestore - Firestore instance
994
 * @returns Promise resolving when termination is complete
995
 */
996
function terminate(firestore: FirebaseFirestoreTypes.Firestore): Promise<void>;
997
```
998

999
**Usage Examples:**
1000

1001
```typescript
1002
import { 
1003
  getFirestore, 
1004
  enableNetwork, 
1005
  disableNetwork,
1006
  clearPersistence,
1007
  waitForPendingWrites,
1008
  terminate
1009
} from '@react-native-firebase/firestore';
1010

1011
const db = getFirestore();
1012

1013
// Network management
1014
await disableNetwork(db); // Go offline
1015
console.log('Network disabled');
1016

1017
await enableNetwork(db); // Go online
1018
console.log('Network enabled');
1019

1020
// Persistence management
1021
await waitForPendingWrites(db);
1022
console.log('All writes committed');
1023

1024
await clearPersistence(db);
1025
console.log('Cache cleared');
1026

1027
// Clean shutdown
1028
await terminate(db);
1029
console.log('Firestore terminated');
1030
```
1031

1032
### Utility Functions
1033

1034
Helper functions for common operations and comparisons.
1035

1036
```typescript { .api }
1037
/**
1038
 * Check if two snapshots are equal
1039
 * @param left - First snapshot
1040
 * @param right - Second snapshot
1041
 * @returns True if snapshots are equal
1042
 */
1043
function snapshotEqual<T>(
1044
  left: FirebaseFirestoreTypes.DocumentSnapshot<T> | FirebaseFirestoreTypes.QuerySnapshot<T>,
1045
  right: FirebaseFirestoreTypes.DocumentSnapshot<T> | FirebaseFirestoreTypes.QuerySnapshot<T>
1046
): boolean;
1047

1048
/**
1049
 * Check if two queries are equal
1050
 * @param left - First query
1051
 * @param right - Second query
1052
 * @returns True if queries are equal
1053
 */
1054
function queryEqual<T>(left: FirebaseFirestoreTypes.Query<T>, right: FirebaseFirestoreTypes.Query<T>): boolean;
1055

1056
/**
1057
 * Check if two references are equal
1058
 * @param left - First reference
1059
 * @param right - Second reference
1060
 * @returns True if references are equal
1061
 */
1062
function refEqual<T>(
1063
  left: FirebaseFirestoreTypes.DocumentReference<T> | FirebaseFirestoreTypes.CollectionReference<T>,
1064
  right: FirebaseFirestoreTypes.DocumentReference<T> | FirebaseFirestoreTypes.CollectionReference<T>
1065
): boolean;
1066

1067
/**
1068
 * Set log level for Firestore
1069
 * @param logLevel - Logging level
1070
 */
1071
function setLogLevel(logLevel: FirebaseFirestoreTypes.LogLevel): void;
1072
```
1073

1074
**Usage Examples:**
1075

1076
```typescript
1077
import { 
1078
  getFirestore, 
1079
  doc, 
1080
  query, 
1081
  collection, 
1082
  where,
1083
  snapshotEqual, 
1084
  queryEqual, 
1085
  refEqual,
1086
  setLogLevel
1087
} from '@react-native-firebase/firestore';
1088

1089
const db = getFirestore();
1090

1091
// Reference equality
1092
const userRef1 = doc(db, 'users', 'userId');
1093
const userRef2 = doc(db, 'users', 'userId');
1094
console.log('Refs equal:', refEqual(userRef1, userRef2)); // true
1095

1096
// Query equality
1097
const query1 = query(collection(db, 'users'), where('active', '==', true));
1098
const query2 = query(collection(db, 'users'), where('active', '==', true));
1099
console.log('Queries equal:', queryEqual(query1, query2)); // true
1100

1101
// Set logging level
1102
setLogLevel('debug'); // 'debug' | 'error' | 'silent'
1103
```
1104

1105
## Types
1106

1107
```typescript { .api }
1108
type Unsubscribe = () => void;
1109
type LogLevel = 'debug' | 'error' | 'silent';
1110
type OrderByDirection = 'desc' | 'asc';
1111
type WhereFilterOp = '<' | '<=' | '==' | '>' | '>=' | '!=' | 'array-contains' | 'array-contains-any' | 'in' | 'not-in';
1112

1113
interface FirestoreSettings {
1114
  persistence?: boolean;
1115
  cacheSizeBytes?: number;
1116
  host?: string;
1117
  ssl?: boolean;
1118
  ignoreUndefinedProperties?: boolean;
1119
  serverTimestampBehavior?: 'estimate' | 'previous' | 'none';
1120
}
1121

1122
interface WithFieldValue<T> {
1123
  // Complex type allowing FieldValue in place of field values
1124
}
1125

1126
interface PartialWithFieldValue<T> {
1127
  // Complex type for partial updates with FieldValue support
1128
}
1129

1130
interface UpdateData<T> {
1131
  // Complex type for update operations with nested field support
1132
}
1133
```