Modular API

/**
 * Get the default Firestore instance
 * @returns Firestore instance
 */
function getFirestore(): FirebaseFirestoreTypes.Firestore;

/**
 * Get Firestore instance for a specific Firebase app
 * @param app - Firebase app instance
 * @returns Firestore instance for the app
 */
function getFirestore(app: FirebaseAppTypes.Module): FirebaseFirestoreTypes.Firestore;

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

/**
 * Initialize Firestore with settings
 * @param app - Firebase app instance
 * @param settings - Firestore configuration settings
 * @param databaseId - Optional database identifier
 * @returns Promise resolving to initialized Firestore instance
 */
function initializeFirestore(
  app: FirebaseAppTypes.Module,
  settings: FirebaseFirestoreTypes.FirestoreSettings,
  databaseId?: string
): Promise<FirebaseFirestoreTypes.Firestore>;

/**
 * Connect to Firestore emulator
 * @param firestore - Firestore instance
 * @param host - Emulator host
 * @param port - Emulator port
 * @param options - Optional connection options
 */
function connectFirestoreEmulator(
  firestore: FirebaseFirestoreTypes.Firestore,
  host: string,
  port: number,
  options?: { mockUserToken?: object | string }
): void;

import { initializeApp } from '@react-native-firebase/app';
import { 
  getFirestore, 
  initializeFirestore, 
  connectFirestoreEmulator 
} from '@react-native-firebase/firestore';

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

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

// Initialize with settings
const dbWithSettings = await initializeFirestore(customApp, {
  persistence: true,
  cacheSizeBytes: 50 * 1024 * 1024
});

// Connect to emulator (development)
if (__DEV__) {
  connectFirestoreEmulator(db, 'localhost', 8080);
}

// Multi-database setup
const mainDb = getFirestore();  // default database
const analyticsDb = getFirestore(undefined, 'analytics');  // custom database

/**
 * Get a document reference
 * @param firestore - Firestore instance
 * @param path - Document path
 * @param pathSegments - Additional path segments
 * @returns Document reference
 */
function doc(firestore: FirebaseFirestoreTypes.Firestore, path: string, ...pathSegments: string[]): FirebaseFirestoreTypes.DocumentReference;

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

/**
 * Get a document reference from another document
 * @param reference - Document reference
 * @param path - Subcollection and document path
 * @param pathSegments - Additional path segments
 * @returns Document reference
 */
function doc<T>(reference: FirebaseFirestoreTypes.DocumentReference<T>, path: string, ...pathSegments: string[]): FirebaseFirestoreTypes.DocumentReference;

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

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

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

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

/**
 * Set document data with options
 * @param reference - Document reference
 * @param data - Partial document data
 * @param options - Set options for merging
 * @returns Promise resolving when set completes
 */
function setDoc<T>(
  reference: FirebaseFirestoreTypes.DocumentReference<T>,
  data: FirebaseFirestoreTypes.PartialWithFieldValue<T>,
  options: FirebaseFirestoreTypes.SetOptions
): Promise<void>;

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

/**
 * Update document using field paths
 * @param reference - Document reference
 * @param field - Field path to update
 * @param value - New field value
 * @param more - Additional field-value pairs
 * @returns Promise resolving when update completes
 */
function updateDoc(
  reference: FirebaseFirestoreTypes.DocumentReference,
  field: string | FirebaseFirestoreTypes.FieldPath,
  value: unknown,
  ...more: unknown[]
): Promise<void>;

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

/**
 * Add a document to a collection
 * @param reference - Collection reference
 * @param data - Document data to add
 * @returns Promise resolving to the new document reference
 */
function addDoc<T>(reference: FirebaseFirestoreTypes.CollectionReference<T>, data: FirebaseFirestoreTypes.WithFieldValue<T>): Promise<FirebaseFirestoreTypes.DocumentReference<T>>;

import { 
  getFirestore, 
  doc, 
  getDoc, 
  setDoc, 
  updateDoc, 
  deleteDoc, 
  addDoc,
  collection
} from '@react-native-firebase/firestore';

const db = getFirestore();

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

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

// Set document
await setDoc(userRef, {
  name: 'John Doe',
  email: 'john@example.com',
  createdAt: serverTimestamp()
});

// Update document
await updateDoc(userRef, {
  lastLoginAt: serverTimestamp(),
  loginCount: increment(1)
});

// Delete document
await deleteDoc(userRef);

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

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

// Nested document paths
const postRef = doc(db, 'users', 'userId', 'posts', 'postId');
const commentRef = doc(postRef, 'comments', 'commentId');

/**
 * Get a collection reference
 * @param firestore - Firestore instance
 * @param path - Collection path
 * @param pathSegments - Additional path segments
 * @returns Collection reference
 */
function collection(firestore: FirebaseFirestoreTypes.Firestore, path: string, ...pathSegments: string[]): FirebaseFirestoreTypes.CollectionReference;

/**
 * Get a subcollection reference from a collection
 * @param reference - Parent collection reference
 * @param path - Subcollection path
 * @param pathSegments - Additional path segments
 * @returns Collection reference
 */
function collection<T>(reference: FirebaseFirestoreTypes.CollectionReference<T>, path: string, ...pathSegments: string[]): FirebaseFirestoreTypes.CollectionReference;

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

/**
 * Query across collection groups
 * @param firestore - Firestore instance
 * @param collectionId - Collection identifier
 * @returns Query for collection group
 */
function collectionGroup(firestore: FirebaseFirestoreTypes.Firestore, collectionId: string): FirebaseFirestoreTypes.Query;

import { 
  getFirestore, 
  collection, 
  collectionGroup, 
  doc, 
  getDocs 
} from '@react-native-firebase/firestore';

const db = getFirestore();

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

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

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

// Collection group query
const allCommentsQuery = collectionGroup(db, 'comments');
const allCommentsSnapshot = await getDocs(allCommentsQuery);

/**
 * Create a query with constraints
 * @param query - Base query
 * @param queryConstraints - Query constraints to apply
 * @returns New query with constraints applied
 */
function query<T>(query: FirebaseFirestoreTypes.Query<T>, ...queryConstraints: FirebaseFirestoreTypes.QueryConstraint[]): FirebaseFirestoreTypes.Query<T>;

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

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

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

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

/**
 * Create limit constraint
 * @param limit - Maximum number of documents
 * @returns Query limit constraint
 */
function limit(limit: number): FirebaseFirestoreTypes.QueryLimitConstraint;

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

/**
 * Create start at constraint
 * @param fieldValues - Field values to start at
 * @returns Query start at constraint
 */
function startAt(...fieldValues: unknown[]): FirebaseFirestoreTypes.QueryStartAtConstraint;

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

/**
 * Create end at constraint
 * @param fieldValues - Field values to end at
 * @returns Query end at constraint
 */
function endAt(...fieldValues: unknown[]): FirebaseFirestoreTypes.QueryEndAtConstraint;

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

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

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

/**
 * Execute query and get results from server
 * @param query - Query to execute
 * @returns Promise resolving to server query snapshot
 */
function getDocsFromServer<T>(query: FirebaseFirestoreTypes.Query<T>): Promise<FirebaseFirestoreTypes.QuerySnapshot<T>>;

import { 
  getFirestore, 
  collection, 
  query, 
  where, 
  orderBy, 
  limit, 
  getDocs,
  and,
  or
} from '@react-native-firebase/firestore';

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

// Basic query
const activeUsersQuery = query(
  usersRef,
  where('active', '==', true),
  orderBy('createdAt', 'desc'),
  limit(10)
);

const activeUsersSnapshot = await getDocs(activeUsersQuery);

// Complex composite queries
const complexQuery = query(
  usersRef,
  and(
    or(
      where('role', '==', 'admin'),
      where('role', '==', 'moderator')
    ),
    where('active', '==', true)
  ),
  orderBy('lastLoginAt', 'desc')
);

// Pagination
const firstPage = query(
  usersRef,
  orderBy('createdAt'),
  limit(20)
);

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

const nextPage = query(
  usersRef,
  orderBy('createdAt'),
  startAfter(lastDoc),
  limit(20)
);

// Different data sources
const cacheResults = await getDocsFromCache(activeUsersQuery);
const serverResults = await getDocsFromServer(activeUsersQuery);

/**
 * Listen to document changes
 * @param reference - Document reference
 * @param observer - Observer with next, error, complete handlers
 * @returns Unsubscribe function
 */
function onSnapshot<T>(
  reference: FirebaseFirestoreTypes.DocumentReference<T>,
  observer: {
    next?: (snapshot: FirebaseFirestoreTypes.DocumentSnapshot<T>) => void;
    error?: (error: Error) => void;
    complete?: () => void;
  }
): FirebaseFirestoreTypes.Unsubscribe;

/**
 * Listen to query changes
 * @param query - Query to listen to
 * @param observer - Observer with next, error, complete handlers
 * @returns Unsubscribe function
 */
function onSnapshot<T>(
  query: FirebaseFirestoreTypes.Query<T>,
  observer: {
    next?: (snapshot: FirebaseFirestoreTypes.QuerySnapshot<T>) => void;
    error?: (error: Error) => void;
    complete?: () => void;
  }
): FirebaseFirestoreTypes.Unsubscribe;

/**
 * Listen to snapshots in sync
 * @param firestore - Firestore instance
 * @param observer - Observer for sync events
 * @returns Unsubscribe function
 */
function onSnapshotsInSync(
  firestore: FirebaseFirestoreTypes.Firestore,
  observer: {
    next?: () => void;
    error?: (error: Error) => void;
    complete?: () => void;
  }
): FirebaseFirestoreTypes.Unsubscribe;

import { 
  getFirestore, 
  doc, 
  collection, 
  query, 
  where, 
  onSnapshot,
  onSnapshotsInSync
} from '@react-native-firebase/firestore';

const db = getFirestore();

// Document listener
const userRef = doc(db, 'users', 'userId');
const unsubscribeUser = onSnapshot(userRef, {
  next: (snapshot) => {
    if (snapshot.exists()) {
      console.log('User data:', snapshot.data());
    }
  },
  error: (error) => {
    console.error('User listener error:', error);
  }
});

// Query listener
const activeUsersQuery = query(
  collection(db, 'users'),
  where('active', '==', true)
);

const unsubscribeUsers = onSnapshot(activeUsersQuery, {
  next: (snapshot) => {
    snapshot.docChanges().forEach((change) => {
      console.log(change.type, change.doc.data());
    });
  }
});

// Snapshots in sync listener
const unsubscribeSync = onSnapshotsInSync(db, {
  next: () => {
    console.log('All snapshots are in sync');
  }
});

// Cleanup
unsubscribeUser();
unsubscribeUsers();
unsubscribeSync();

/**
 * Get count of documents matching a query from server
 * @param query - Query to count documents for
 * @returns Promise resolving to aggregate query snapshot with count
 */
function getCountFromServer<T>(query: FirebaseFirestoreTypes.Query<T>): Promise<FirebaseFirestoreTypes.AggregateQuerySnapshot<{count: FirebaseFirestoreTypes.AggregateField<number>}, T>>;

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

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

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

/**
 * Create count aggregation field
 * @returns AggregateField for count operation
 */
function count(): FirebaseFirestoreTypes.AggregateField<number>;

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

interface AggregateQuerySnapshot<T> {
  /**
   * Get the aggregated data
   * @returns Object containing aggregation results
   */
  data(): T;
}

interface AggregateField<T> {
  /**
   * Get the aggregated value
   * @returns The aggregated result
   */
  value(): T;
}

import { 
  getFirestore, 
  collection, 
  query, 
  where, 
  getCountFromServer,
  getAggregateFromServer,
  sum,
  average,
  count
} from '@react-native-firebase/firestore';

const db = getFirestore();

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

// Multiple aggregations
const ordersQuery = query(collection(db, 'orders'), where('status', '==', 'completed'));
const aggregateSnapshot = await getAggregateFromServer(ordersQuery, {
  totalRevenue: sum('amount'),
  averageOrderValue: average('amount'),
  orderCount: count()
});

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

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

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

/**
 * Load a data bundle
 * @param firestore - Firestore instance
 * @param bundleData - Bundle data as string, ArrayBuffer, or ReadableStream
 * @returns LoadBundleTask for monitoring progress
 */
function loadBundle(
  firestore: FirebaseFirestoreTypes.Firestore, 
  bundleData: ReadableStream<Uint8Array> | ArrayBuffer | string
): FirebaseFirestoreTypes.LoadBundleTask;

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

interface LoadBundleTask {
  /**
   * Promise that resolves when the bundle loading completes
   */
  then(onFulfilled?: (progress: FirebaseFirestoreTypes.LoadBundleTaskProgress) => any): Promise<any>;
  
  /**
   * Catch errors during bundle loading
   */
  catch(onRejected?: (error: Error) => any): Promise<any>;
}

import { 
  getFirestore, 
  loadBundle, 
  namedQuery,
  getDocs
} from '@react-native-firebase/firestore';

const db = getFirestore();

// Load bundle with progress monitoring
async function loadDataBundle() {
  try {
    const bundleData = await fetch('/api/data-bundle').then(r => r.text());
    
    const loadTask = loadBundle(db, bundleData);
    const progress = await loadTask;
    
    console.log('Bundle loaded:', progress.taskState);
    
    // Use named queries
    const featuredQuery = await namedQuery(db, 'featured-products');
    if (featuredQuery) {
      const snapshot = await getDocs(featuredQuery);
      console.log(`Featured products: ${snapshot.size}`);
    }
  } catch (error) {
    console.error('Bundle loading failed:', error);
  }
}

/**
 * Execute a transaction
 * @param firestore - Firestore instance
 * @param updateFunction - Function that performs transaction operations
 * @returns Promise resolving to transaction result
 */
function runTransaction<T>(
  firestore: FirebaseFirestoreTypes.Firestore,
  updateFunction: (transaction: FirebaseFirestoreTypes.Transaction) => Promise<T>
): Promise<T>;

/**
 * Create a write batch
 * @param firestore - Firestore instance
 * @returns WriteBatch instance
 */
function writeBatch(firestore: FirebaseFirestoreTypes.Firestore): FirebaseFirestoreTypes.WriteBatch;

import { 
  getFirestore, 
  doc, 
  runTransaction, 
  writeBatch,
  serverTimestamp,
  increment
} from '@react-native-firebase/firestore';

const db = getFirestore();

// Transaction
const result = await runTransaction(db, async (transaction) => {
  const userRef = doc(db, 'users', 'userId');
  const userDoc = await transaction.get(userRef);
  
  if (!userDoc.exists()) {
    throw new Error('User does not exist');
  }
  
  transaction.update(userRef, {
    loginCount: increment(1),
    lastLoginAt: serverTimestamp()
  });
  
  return { newLoginCount: userDoc.data().loginCount + 1 };
});

// Write batch
const batch = writeBatch(db);

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

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

await batch.commit();

/**
 * Server timestamp placeholder for modular API
 * @returns FieldValue representing server timestamp
 */
function serverTimestamp(): FirebaseFirestoreTypes.FieldValue;

/**
 * Field deletion marker for modular API
 * @returns FieldValue that deletes the field
 */
function deleteField(): FirebaseFirestoreTypes.FieldValue;

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

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

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

import { 
  getFirestore, 
  doc, 
  setDoc, 
  updateDoc,
  serverTimestamp,
  deleteField,
  increment,
  arrayUnion,
  arrayRemove
} from '@react-native-firebase/firestore';

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

// Server timestamps
await setDoc(userRef, {
  name: 'John Doe',
  createdAt: serverTimestamp(),
  updatedAt: serverTimestamp()
});

// Increment/decrement operations
await updateDoc(userRef, {
  loginCount: increment(1),
  credits: increment(-10) // Deduct 10 credits
});

// Array operations
await updateDoc(userRef, {
  // Add tags (only if not already present)
  tags: arrayUnion('premium', 'verified'),
  
  // Remove tags (all instances)
  blockedUsers: arrayRemove('spam-user-1', 'spam-user-2')
});

// Delete fields
await updateDoc(userRef, {
  temporaryField: deleteField(),
  updatedAt: serverTimestamp()
});

// Complex update with multiple field values
await updateDoc(doc(db, 'products', 'productId'), {
  viewCount: increment(1),
  categories: arrayUnion('featured'),
  lastViewedAt: serverTimestamp(),
  oldField: deleteField()
});

/**
 * Enable network connectivity for Firestore
 * @param firestore - Firestore instance
 * @returns Promise resolving when network is enabled
 */
function enableNetwork(firestore: FirebaseFirestoreTypes.Firestore): Promise<void>;

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

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

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

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

/**
 * Terminate the Firestore instance and clean up resources
 * @param firestore - Firestore instance
 * @returns Promise resolving when termination is complete
 */
function terminate(firestore: FirebaseFirestoreTypes.Firestore): Promise<void>;

import { 
  getFirestore, 
  enableNetwork, 
  disableNetwork,
  clearPersistence,
  waitForPendingWrites,
  terminate
} from '@react-native-firebase/firestore';

const db = getFirestore();

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

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

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

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

// Clean shutdown
await terminate(db);
console.log('Firestore terminated');

/**
 * Check if two snapshots are equal
 * @param left - First snapshot
 * @param right - Second snapshot
 * @returns True if snapshots are equal
 */
function snapshotEqual<T>(
  left: FirebaseFirestoreTypes.DocumentSnapshot<T> | FirebaseFirestoreTypes.QuerySnapshot<T>,
  right: FirebaseFirestoreTypes.DocumentSnapshot<T> | FirebaseFirestoreTypes.QuerySnapshot<T>
): boolean;

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

/**
 * Check if two references are equal
 * @param left - First reference
 * @param right - Second reference
 * @returns True if references are equal
 */
function refEqual<T>(
  left: FirebaseFirestoreTypes.DocumentReference<T> | FirebaseFirestoreTypes.CollectionReference<T>,
  right: FirebaseFirestoreTypes.DocumentReference<T> | FirebaseFirestoreTypes.CollectionReference<T>
): boolean;

/**
 * Set log level for Firestore
 * @param logLevel - Logging level
 */
function setLogLevel(logLevel: FirebaseFirestoreTypes.LogLevel): void;

import { 
  getFirestore, 
  doc, 
  query, 
  collection, 
  where,
  snapshotEqual, 
  queryEqual, 
  refEqual,
  setLogLevel
} from '@react-native-firebase/firestore';

const db = getFirestore();

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

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

// Set logging level
setLogLevel('debug'); // 'debug' | 'error' | 'silent'

type Unsubscribe = () => void;
type LogLevel = 'debug' | 'error' | 'silent';
type OrderByDirection = 'desc' | 'asc';
type WhereFilterOp = '<' | '<=' | '==' | '>' | '>=' | '!=' | 'array-contains' | 'array-contains-any' | 'in' | 'not-in';

interface FirestoreSettings {
  persistence?: boolean;
  cacheSizeBytes?: number;
  host?: string;
  ssl?: boolean;
  ignoreUndefinedProperties?: boolean;
  serverTimestampBehavior?: 'estimate' | 'previous' | 'none';
}

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

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

interface UpdateData<T> {
  // Complex type for update operations with nested field support
}