@@ -229,7 +229,7 @@ scripts:
 melos exec -- "flutter pub run pigeon --input ./pigeons/messages.dart" && \
 melos run generate:pigeon:macos --no-select && \
 melos run generate:pigeon:android --no-select && \
-melos run format --no-select
+melos run format-ci --no-select
  packageFilters:
 fileExists: 'pigeons/messages.dart'
 description: Generate the pigeon messages for all the supported packages.

@@ -9,6 +9,7 @@
 import static com.google.firebase.firestore.AggregateField.sum;
 
 import android.app.Activity;
+import android.util.Log;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import com.google.android.gms.tasks.Task;
@@ -24,6 +25,7 @@
 import com.google.firebase.firestore.FirebaseFirestore;
 import com.google.firebase.firestore.FirebaseFirestoreSettings;
 import com.google.firebase.firestore.MemoryCacheSettings;
+import com.google.firebase.firestore.PersistentCacheIndexManager;
 import com.google.firebase.firestore.PersistentCacheSettings;
 import com.google.firebase.firestore.Query;
 import com.google.firebase.firestore.QuerySnapshot;
@@ -64,7 +66,7 @@ public class FlutterFirebaseFirestorePlugin
 GeneratedAndroidFirebaseFirestore.FirebaseFirestoreHostApi {
 protected static final HashMap<FirebaseFirestore, FlutterFirebaseFirestoreExtension>
 firestoreInstanceCache = new HashMap<>();
-
+public static final String TAG = "FlutterFirestorePlugin";
 public static final String DEFAULT_ERROR_CODE = "firebase_firestore";
 
 private static final String METHOD_CHANNEL_NAME = "plugins.flutter.io/firebase_firestore";
@@ -473,6 +475,35 @@ public void setIndexConfiguration(
 });
 }
 
+@Override
+public void persistenceCacheIndexManagerRequest(
+@NonNull GeneratedAndroidFirebaseFirestore.FirestorePigeonFirebaseApp app,
+@NonNull GeneratedAndroidFirebaseFirestore.PersistenceCacheIndexManagerRequest request,
+@NonNull GeneratedAndroidFirebaseFirestore.Result<Void> result) {
+cachedThreadPool.execute(
+() -> {
+PersistentCacheIndexManager indexManager =
+getFirestoreFromPigeon(app).getPersistentCacheIndexManager();
+if (indexManager != null) {
+switch (request) {
+case ENABLE_INDEX_AUTO_CREATION:
+indexManager.enableIndexAutoCreation();
+break;
+case DISABLE_INDEX_AUTO_CREATION:
+indexManager.disableIndexAutoCreation();
+break;
+case DELETE_ALL_INDEXES:
+indexManager.deleteAllIndexes();
+break;
+}
+} else {
+Log.d(TAG, "`PersistentCacheIndexManager` is not available.");
+}
+
+result.success(null);
+});
+}
+
 @Override
 public void setLoggingEnabled(
 @NonNull Boolean loggingEnabled,

@@ -166,6 +166,22 @@ private AggregateSource(final int index) {
 }
 }
 
+/**
+* [PersistenceCacheIndexManagerRequest] represents the request types for the persistence cache
+* index manager.
+*/
+public enum PersistenceCacheIndexManagerRequest {
+ENABLE_INDEX_AUTO_CREATION(0),
+DISABLE_INDEX_AUTO_CREATION(1),
+DELETE_ALL_INDEXES(2);
+
+final int index;
+
+private PersistenceCacheIndexManagerRequest(final int index) {
+this.index = index;
+}
+}
+
 public enum PigeonTransactionResult {
 SUCCESS(0),
 FAILURE(1);
@@ -1815,6 +1831,11 @@ void documentReferenceSnapshot(
 @NonNull ListenSource source,
 @NonNull Result<String> result);
 
+void persistenceCacheIndexManagerRequest(
+@NonNull FirestorePigeonFirebaseApp app,
+@NonNull PersistenceCacheIndexManagerRequest request,
+@NonNull Result<Void> result);
+
 /** The codec used by FirebaseFirestoreHostApi. */
 static @NonNull MessageCodec<Object> getCodec() {
 return FirebaseFirestoreHostApiCodec.INSTANCE;
@@ -2570,6 +2591,39 @@ public void error(Throwable error) {
 channel.setMessageHandler(null);
 }
 }
+{
+BasicMessageChannel<Object> channel =
+new BasicMessageChannel<>(
+binaryMessenger,
+"dev.flutter.pigeon.cloud_firestore_platform_interface.FirebaseFirestoreHostApi.persistenceCacheIndexManagerRequest",
+getCodec());
+if (api != null) {
+channel.setMessageHandler(
+(message, reply) -> {
+ArrayList<Object> wrapped = new ArrayList<Object>();
+ArrayList<Object> args = (ArrayList<Object>) message;
+FirestorePigeonFirebaseApp appArg = (FirestorePigeonFirebaseApp) args.get(0);
+PersistenceCacheIndexManagerRequest requestArg =
+PersistenceCacheIndexManagerRequest.values()[(int) args.get(1)];
+Result<Void> resultCallback =
+new Result<Void>() {
+public void success(Void result) {
+wrapped.add(0, null);
+reply.reply(wrapped);
+}
+
+public void error(Throwable error) {
+ArrayList<Object> wrappedError = wrapError(error);
+reply.reply(wrappedError);
+}
+};
+
+api.persistenceCacheIndexManagerRequest(appArg, requestArg, resultCallback);
+});
+} else {
+channel.setMessageHandler(null);
+}
+}
 }
 }
 }

@@ -6,6 +6,7 @@ import 'dart:async';
 import 'dart:convert';
 
 import 'package:cloud_firestore/cloud_firestore.dart';
+import 'package:firebase_core/firebase_core.dart';
 import 'package:flutter/foundation.dart';
 import 'package:flutter_test/flutter_test.dart';
 
@@ -312,6 +313,121 @@ void runInstanceTests() {
 {'some': 'data'},
 );
 });
+testWidgets(
+'`PersistenceCacheIndexManager` with default persistence settings for each platform',
+(widgetTester) async {
+if (defaultTargetPlatform == TargetPlatform.windows) {
+try {
+// Windows does not have `PersistenceCacheIndexManager` support
+FirebaseFirestore.instance.persistentCacheIndexManager();
+} catch (e) {
+expect(e, isInstanceOf<UnimplementedError>());
+}
+} else {
+if (kIsWeb) {
+// persistence is disabled by default on web
+final firestore = FirebaseFirestore.instanceFor(
+app: Firebase.app(),
+// Use different firestore instance to test behavior
+databaseId: 'default-web',
+);
+PersistentCacheIndexManager? indexManager =
+firestore.persistentCacheIndexManager();
+expect(indexManager, isNull);
+} else {
+final firestore = FirebaseFirestore.instanceFor(
+app: Firebase.app(),
+// Use different firestore instance to test behavior
+databaseId: 'default-other-platform-test',
+);
+// macOS, android, iOS have persistence enabled by default
+PersistentCacheIndexManager? indexManager =
+firestore.persistentCacheIndexManager();
+await indexManager!.enableIndexAutoCreation();
+await indexManager.disableIndexAutoCreation();
+await indexManager.deleteAllIndexes();
+}
+}
+},
+);
+
+testWidgets(
+'`PersistenceCacheIndexManager` with persistence enabled for each platform',
+(widgetTester) async {
+if (kIsWeb) {
+final firestore = FirebaseFirestore.instanceFor(
+app: Firebase.app(),
+databaseId: 'web-enabled',
+);
+// persistence is disabled by default so we enable it
+firestore.settings = const Settings(persistenceEnabled: true);
+
+PersistentCacheIndexManager? indexManager =
+firestore.persistentCacheIndexManager();
+
+await indexManager!.enableIndexAutoCreation();
+await indexManager.disableIndexAutoCreation();
+await indexManager.deleteAllIndexes();
+
+final firestore2 = FirebaseFirestore.instanceFor(
+app: Firebase.app(),
+databaseId: 'web-disabled-2',
+);
+
+// Now try using `enablePersistence()`, web only API
+await firestore2.enablePersistence();
+
+PersistentCacheIndexManager? indexManager2 =
+firestore2.persistentCacheIndexManager();
+
+await indexManager2!.enableIndexAutoCreation();
+await indexManager2.disableIndexAutoCreation();
+await indexManager2.deleteAllIndexes();
+} else {
+final firestore = FirebaseFirestore.instanceFor(
+app: Firebase.app(),
+databaseId: 'other-platform-enabled',
+);
+firestore.settings = const Settings(persistenceEnabled: true);
+PersistentCacheIndexManager? indexManager =
+firestore.persistentCacheIndexManager();
+await indexManager!.enableIndexAutoCreation();
+await indexManager.disableIndexAutoCreation();
+await indexManager.deleteAllIndexes();
+}
+},
+skip: defaultTargetPlatform == TargetPlatform.windows,
+);
+
+testWidgets(
+'`PersistenceCacheIndexManager` with persistence disabled for each platform',
+(widgetTester) async {
+if (kIsWeb) {
+final firestore = FirebaseFirestore.instanceFor(
+app: Firebase.app(),
+databaseId: 'web-disabled-1',
+);
+// persistence is disabled by default so we enable it
+firestore.settings = const Settings(persistenceEnabled: false);
+
+PersistentCacheIndexManager? indexManager =
+firestore.persistentCacheIndexManager();
+
+expect(indexManager, isNull);
+} else {
+final firestore = FirebaseFirestore.instanceFor(
+app: Firebase.app(),
+databaseId: 'other-platform-disabled',
+);
+// macOS, android, iOS have persistence enabled by default so we disable it
+firestore.settings = const Settings(persistenceEnabled: false);
+PersistentCacheIndexManager? indexManager =
+firestore.persistentCacheIndexManager();
+expect(indexManager, isNull);
+}
+},
+skip: defaultTargetPlatform == TargetPlatform.windows,
+);
 },
 );
 }

@@ -6,6 +6,7 @@
 #import <firebase_core/FLTFirebasePluginRegistry.h>
 
 #import <TargetConditionals.h>
+#import "FirebaseFirestoreInternal/FIRPersistentCacheIndexManager.h"
 #import "Private/FLTDocumentSnapshotStreamHandler.h"
 #import "Private/FLTFirebaseFirestoreReader.h"
 #import "Private/FLTFirebaseFirestoreUtils.h"
@@ -566,6 +567,31 @@ - (void)setIndexConfigurationApp:(nonnull FirestorePigeonFirebaseApp *)app
 }];
 }
 
+- (void)persistenceCacheIndexManagerRequestApp:(FirestorePigeonFirebaseApp *)app
+request:(PersistenceCacheIndexManagerRequest)request
+completion:(void (^)(FlutterError *_Nullable))completion {
+FIRPersistentCacheIndexManager *persistentCacheIndexManager =
+[self getFIRFirestoreFromAppNameFromPigeon:app].persistentCacheIndexManager;
+
+if (persistentCacheIndexManager) {
+switch (request) {
+case PersistenceCacheIndexManagerRequestEnableIndexAutoCreation:
+[persistentCacheIndexManager enableIndexAutoCreation];
+break;
+case PersistenceCacheIndexManagerRequestDisableIndexAutoCreation:
+[persistentCacheIndexManager disableIndexAutoCreation];
+break;
+case PersistenceCacheIndexManagerRequestDeleteAllIndexes:
+[persistentCacheIndexManager deleteAllIndexes];
+break;
+}
+} else {
+// Put because `persistentCacheIndexManager` is a nullable property
+NSLog(@"FLTFirebaseFirestore: `PersistentCacheIndexManager` is not available.");
+}
+completion(nil);
+}
+
 - (void)setLoggingEnabledLoggingEnabled:(nonnull NSNumber *)loggingEnabled
 completion:(nonnull void (^)(FlutterError *_Nullable))completion {
 [FIRFirestore enableLogging:[loggingEnabled boolValue]];

@@ -77,6 +77,18 @@ - (instancetype)initWithValue:(AggregateSource)value {
 }
 @end
 
+/// [PersistenceCacheIndexManagerRequest] represents the request types for the persistence cache
+/// index manager.
+@implementation PersistenceCacheIndexManagerRequestBox
+- (instancetype)initWithValue:(PersistenceCacheIndexManagerRequest)value {
+self = [super init];
+if (self) {
+_value = value;
+}
+return self;
+}
+@end
+
 @implementation PigeonTransactionResultBox
 - (instancetype)initWithValue:(PigeonTransactionResult)value {
 self = [super init];
@@ -1340,4 +1352,31 @@ void FirebaseFirestoreHostApiSetup(id<FlutterBinaryMessenger> binaryMessenger,
 [channel setMessageHandler:nil];
 }
 }
+{
+FlutterBasicMessageChannel *channel = [[FlutterBasicMessageChannel alloc]
+initWithName:@"dev.flutter.pigeon.cloud_firestore_platform_interface."
+@"FirebaseFirestoreHostApi.persistenceCacheIndexManagerRequest"
+binaryMessenger:binaryMessenger
+codec:FirebaseFirestoreHostApiGetCodec()];
+if (api) {
+NSCAssert([api respondsToSelector:@selector
+(persistenceCacheIndexManagerRequestApp:request:completion:)],
+@"FirebaseFirestoreHostApi api (%@) doesn't respond to "
+@"@selector(persistenceCacheIndexManagerRequestApp:request:completion:)",
+api);
+[channel setMessageHandler:^(id _Nullable message, FlutterReply callback) {
+NSArray *args = message;
+FirestorePigeonFirebaseApp *arg_app = GetNullableObjectAtIndex(args, 0);
+PersistenceCacheIndexManagerRequest arg_request =
+[GetNullableObjectAtIndex(args, 1) integerValue];
+[api persistenceCacheIndexManagerRequestApp:arg_app
+request:arg_request
+completion:^(FlutterError *_Nullable error) {
+callback(wrapResult(nil, error));
+}];
+}];
+} else {
+[channel setMessageHandler:nil];
+}
+}
 }

@@ -109,6 +109,20 @@ typedef NS_ENUM(NSUInteger, AggregateSource) {
 - (instancetype)initWithValue:(AggregateSource)value;
 @end
 
+/// [PersistenceCacheIndexManagerRequest] represents the request types for the persistence cache
+/// index manager.
+typedef NS_ENUM(NSUInteger, PersistenceCacheIndexManagerRequest) {
+PersistenceCacheIndexManagerRequestEnableIndexAutoCreation = 0,
+PersistenceCacheIndexManagerRequestDisableIndexAutoCreation = 1,
+PersistenceCacheIndexManagerRequestDeleteAllIndexes = 2,
+};
+
+/// Wrapper for PersistenceCacheIndexManagerRequest to allow for nullability.
+@interface PersistenceCacheIndexManagerRequestBox : NSObject
+@property(nonatomic, assign) PersistenceCacheIndexManagerRequest value;
+- (instancetype)initWithValue:(PersistenceCacheIndexManagerRequest)value;
+@end
+
 typedef NS_ENUM(NSUInteger, PigeonTransactionResult) {
 PigeonTransactionResultSuccess = 0,
 PigeonTransactionResultFailure = 1,
@@ -399,6 +413,9 @@ NSObject<FlutterMessageCodec> *FirebaseFirestoreHostApiGetCodec(void);
 source:(ListenSource)source
 completion:
 (void (^)(NSString *_Nullable, FlutterError *_Nullable))completion;
+- (void)persistenceCacheIndexManagerRequestApp:(FirestorePigeonFirebaseApp *)app
+request:(PersistenceCacheIndexManagerRequest)request
+completion:(void (^)(FlutterError *_Nullable))completion;
 @end
 
 extern void FirebaseFirestoreHostApiSetup(id<FlutterBinaryMessenger> binaryMessenger,