@react-native-firebase/auth 21.6.0 → 21.6.2

package/plugin/__tests__/fixtures/AppDelegate_sdk44.m

@@ -0,0 +1,79 @@
+// This AppDelegate prebuild template is used in Expo SDK 44+
+// It has the RCTBridge to be created by Expo ReactDelegate
+
+#import "AppDelegate.h"
+
+#import <React/RCTBridge.h>
+#import <React/RCTBundleURLProvider.h>
+#import <React/RCTRootView.h>
+#import <React/RCTLinkingManager.h>
+#import <React/RCTConvert.h>
+
+#if defined(FB_SONARKIT_ENABLED) && __has_include(<FlipperKit/FlipperClient.h>)
+#import <FlipperKit/FlipperClient.h>
+#import <FlipperKitLayoutPlugin/FlipperKitLayoutPlugin.h>
+#import <FlipperKitUserDefaultsPlugin/FKUserDefaultsPlugin.h>
+#import <FlipperKitNetworkPlugin/FlipperKitNetworkPlugin.h>
+#import <SKIOSNetworkPlugin/SKIOSNetworkAdapter.h>
+#import <FlipperKitReactPlugin/FlipperKitReactPlugin.h>
+
+static void InitializeFlipper(UIApplication *application) {
+  FlipperClient *client = [FlipperClient sharedClient];
+  SKDescriptorMapper *layoutDescriptorMapper = [[SKDescriptorMapper alloc] initWithDefaults];
+  [client addPlugin:[[FlipperKitLayoutPlugin alloc] initWithRootNode:application withDescriptorMapper:layoutDescriptorMapper]];
+  [client addPlugin:[[FKUserDefaultsPlugin alloc] initWithSuiteName:nil]];
+  [client addPlugin:[FlipperKitReactPlugin new]];
+  [client addPlugin:[[FlipperKitNetworkPlugin alloc] initWithNetworkAdapter:[SKIOSNetworkAdapter new]]];
+  [client start];
+}
+#endif
+
+@implementation AppDelegate
+
+- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
+{
+#if defined(FB_SONARKIT_ENABLED) && __has_include(<FlipperKit/FlipperClient.h>)
+  InitializeFlipper(application);
+#endif
+  
+  RCTBridge *bridge = [self.reactDelegate createBridgeWithDelegate:self launchOptions:launchOptions];
+  RCTRootView *rootView = [self.reactDelegate createRootViewWithBridge:bridge moduleName:@"main" initialProperties:nil];
+  rootView.backgroundColor = [UIColor whiteColor];
+  self.window = [[UIWindow alloc] initWithFrame:[UIScreen mainScreen].bounds];
+  UIViewController *rootViewController = [self.reactDelegate createRootViewController];
+  rootViewController.view = rootView;
+  self.window.rootViewController = rootViewController;
+  [self.window makeKeyAndVisible];
+
+  [super application:application didFinishLaunchingWithOptions:launchOptions];
+
+  return YES;
+ }
+
+- (NSArray<id<RCTBridgeModule>> *)extraModulesForBridge:(RCTBridge *)bridge
+{
+  // If you'd like to export some custom RCTBridgeModules, add them here!
+  return @[];
+}
+
+- (NSURL *)sourceURLForBridge:(RCTBridge *)bridge {
+ #ifdef DEBUG
+  return [[RCTBundleURLProvider sharedSettings] jsBundleURLForBundleRoot:@"index" fallbackResource:nil];
+ #else
+  return [[NSBundle mainBundle] URLForResource:@"main" withExtension:@"jsbundle"];
+ #endif
+}
+
+// Linking API
+- (BOOL)application:(UIApplication *)application openURL:(NSURL *)url options:(NSDictionary<UIApplicationOpenURLOptionsKey,id> *)options {
+  return [RCTLinkingManager application:application openURL:url options:options];
+}
+
+// Universal Links
+- (BOOL)application:(UIApplication *)application continueUserActivity:(nonnull NSUserActivity *)userActivity restorationHandler:(nonnull void (^)(NSArray<id<UIUserActivityRestoring>> * _Nullable))restorationHandler {
+  return [RCTLinkingManager application:application
+                   continueUserActivity:userActivity
+                     restorationHandler:restorationHandler];
+}
+
+@end

package/plugin/__tests__/fixtures/AppDelegate_sdk45.mm

@@ -0,0 +1,129 @@
+// RN 0.68.1, Expo SDK 45 template
+// The main difference between this and the SDK 44 one is that this is
+// using React Native 0.68 and is written in Objective-C++
+
+#import "AppDelegate.h"
+
+#import <React/RCTBridge.h>
+#import <React/RCTBundleURLProvider.h>
+#import <React/RCTRootView.h>
+#import <React/RCTLinkingManager.h>
+#import <React/RCTConvert.h>
+
+#import <React/RCTAppSetupUtils.h>
+
+#if RCT_NEW_ARCH_ENABLED
+#import <React/CoreModulesPlugins.h>
+#import <React/RCTCxxBridgeDelegate.h>
+#import <React/RCTFabricSurfaceHostingProxyRootView.h>
+#import <React/RCTSurfacePresenter.h>
+#import <React/RCTSurfacePresenterBridgeAdapter.h>
+#import <ReactCommon/RCTTurboModuleManager.h>
+
+#import <react/config/ReactNativeConfig.h>
+
+@interface AppDelegate () <RCTCxxBridgeDelegate, RCTTurboModuleManagerDelegate> {
+  RCTTurboModuleManager *_turboModuleManager;
+  RCTSurfacePresenterBridgeAdapter *_bridgeAdapter;
+  std::shared_ptr<const facebook::react::ReactNativeConfig> _reactNativeConfig;
+  facebook::react::ContextContainer::Shared _contextContainer;
+}
+@end
+#endif
+
+@implementation AppDelegate
+
+- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
+{
+  RCTAppSetupPrepareApp(application);
+
+  RCTBridge *bridge = [self.reactDelegate createBridgeWithDelegate:self launchOptions:launchOptions];
+
+#if RCT_NEW_ARCH_ENABLED
+  _contextContainer = std::make_shared<facebook::react::ContextContainer const>();
+  _reactNativeConfig = std::make_shared<facebook::react::EmptyReactNativeConfig const>();
+  _contextContainer->insert("ReactNativeConfig", _reactNativeConfig);
+  _bridgeAdapter = [[RCTSurfacePresenterBridgeAdapter alloc] initWithBridge:bridge contextContainer:_contextContainer];
+  bridge.surfacePresenter = _bridgeAdapter.surfacePresenter;
+#endif
+
+  UIView *rootView = [self.reactDelegate createRootViewWithBridge:bridge moduleName:@"main" initialProperties:nil];
+
+  rootView.backgroundColor = [UIColor whiteColor];
+  self.window = [[UIWindow alloc] initWithFrame:[UIScreen mainScreen].bounds];
+  UIViewController *rootViewController = [self.reactDelegate createRootViewController];
+  rootViewController.view = rootView;
+  self.window.rootViewController = rootViewController;
+  [self.window makeKeyAndVisible];
+
+  [super application:application didFinishLaunchingWithOptions:launchOptions];
+
+  return YES;
+}
+
+- (NSArray<id<RCTBridgeModule>> *)extraModulesForBridge:(RCTBridge *)bridge
+{
+  // If you'd like to export some custom RCTBridgeModules, add them here!
+  return @[];
+}
+
+- (NSURL *)sourceURLForBridge:(RCTBridge *)bridge
+{
+#if DEBUG
+  return [[RCTBundleURLProvider sharedSettings] jsBundleURLForBundleRoot:@"index"];
+#else
+  return [[NSBundle mainBundle] URLForResource:@"main" withExtension:@"jsbundle"];
+#endif
+}
+
+// Linking API
+- (BOOL)application:(UIApplication *)application openURL:(NSURL *)url options:(NSDictionary<UIApplicationOpenURLOptionsKey,id> *)options {
+  return [super application:application openURL:url options:options] || [RCTLinkingManager application:application openURL:url options:options];
+}
+
+// Universal Links
+- (BOOL)application:(UIApplication *)application continueUserActivity:(nonnull NSUserActivity *)userActivity restorationHandler:(nonnull void (^)(NSArray<id<UIUserActivityRestoring>> * _Nullable))restorationHandler {
+  BOOL result = [RCTLinkingManager application:application continueUserActivity:userActivity restorationHandler:restorationHandler];
+  return [super application:application continueUserActivity:userActivity restorationHandler:restorationHandler] || result;
+}
+
+#if RCT_NEW_ARCH_ENABLED
+
+#pragma mark - RCTCxxBridgeDelegate
+
+- (std::unique_ptr<facebook::react::JSExecutorFactory>)jsExecutorFactoryForBridge:(RCTBridge *)bridge
+{
+  _turboModuleManager = [[RCTTurboModuleManager alloc] initWithBridge:bridge
+                                                             delegate:self
+                                                            jsInvoker:bridge.jsCallInvoker];
+  return RCTAppSetupDefaultJsExecutorFactory(bridge, _turboModuleManager);
+}
+
+#pragma mark RCTTurboModuleManagerDelegate
+
+- (Class)getModuleClassFromName:(const char *)name
+{
+  return RCTCoreModulesClassProvider(name);
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const std::string &)name
+                                                      jsInvoker:(std::shared_ptr<facebook::react::CallInvoker>)jsInvoker
+{
+  return nullptr;
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const std::string &)name
+                                                     initParams:
+                                                         (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return nullptr;
+}
+
+- (id<RCTTurboModule>)getModuleInstanceFromClass:(Class)moduleClass
+{
+  return RCTAppSetupDefaultModuleFromClass(moduleClass);
+}
+
+#endif
+
+@end

package/plugin/__tests__/iosPlugin_openUrlFix.test.ts

@@ -0,0 +1,343 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { beforeEach, describe, expect, it, jest } from '@jest/globals';
+import { WarningAggregator } from '@expo/config-plugins';
+import type { AppDelegateProjectFile } from '@expo/config-plugins/build/ios/Paths';
+import {
+  shouldApplyIosOpenUrlFix,
+  modifyObjcAppDelegate,
+  withOpenUrlFixForAppDelegate,
+  ensureFirebaseSwizzlingIsEnabled,
+  appDelegateOpenUrlInsertionPointAfter,
+  multiline_appDelegateOpenUrlInsertionPointAfter,
+} from '../src/ios/openUrlFix';
+import type { ExpoConfigPluginEntry } from '../src/ios/openUrlFix';
+
+describe('Config Plugin iOS Tests - openUrlFix', () => {
+  beforeEach(function () {
+    jest.resetAllMocks();
+  });
+
+  it('is disabled by default', async () => {
+    const config = {
+      name: 'TestName',
+      slug: 'TestSlug',
+    };
+
+    expect(
+      shouldApplyIosOpenUrlFix({
+        config,
+      }),
+    ).toBe(false);
+
+    expect(
+      shouldApplyIosOpenUrlFix({
+        config,
+        props: {},
+      }),
+    ).toBe(false);
+
+    expect(
+      shouldApplyIosOpenUrlFix({
+        config,
+        props: {
+          ios: {},
+        },
+      }),
+    ).toBe(false);
+
+    expect(
+      shouldApplyIosOpenUrlFix({
+        config,
+        props: {
+          ios: {
+            captchaOpenUrlFix: undefined,
+          },
+        },
+      }),
+    ).toBe(false);
+
+    expect(
+      shouldApplyIosOpenUrlFix({
+        config,
+        props: {
+          ios: {
+            captchaOpenUrlFix: 'default',
+          },
+        },
+      }),
+    ).toBe(false);
+
+    expect(
+      shouldApplyIosOpenUrlFix({
+        config,
+        props: {
+          ios: {
+            captchaOpenUrlFix: false,
+          },
+        },
+      }),
+    ).toBe(false);
+
+    expect(
+      shouldApplyIosOpenUrlFix({
+        config,
+        props: {
+          ios: {
+            captchaOpenUrlFix: true,
+          },
+        },
+      }),
+    ).toBe(true);
+  });
+
+  it('is enabled by default when expo-router is found', async () => {
+    const cases: ExpoConfigPluginEntry[] = ['expo-router', ['expo-router'], ['expo-router', {}]];
+
+    for (const routerPluginEntry of cases) {
+      const plugins: ExpoConfigPluginEntry[] = [
+        'something',
+        [],
+        ['something-else', { foo: 'bar' }],
+        routerPluginEntry,
+      ];
+
+      const config = {
+        name: 'TestName',
+        slug: 'TestSlug',
+        plugins,
+      };
+
+      expect(
+        shouldApplyIosOpenUrlFix({
+          config,
+          props: {},
+        }),
+      ).toBe(true);
+
+      expect(
+        shouldApplyIosOpenUrlFix({
+          config,
+          props: {
+            ios: {},
+          },
+        }),
+      ).toBe(true);
+
+      expect(
+        shouldApplyIosOpenUrlFix({
+          config,
+          props: {
+            ios: {
+              captchaOpenUrlFix: undefined,
+            },
+          },
+        }),
+      ).toBe(true);
+
+      expect(
+        shouldApplyIosOpenUrlFix({
+          config,
+          props: {
+            ios: {
+              captchaOpenUrlFix: 'default',
+            },
+          },
+        }),
+      ).toBe(true);
+
+      expect(
+        shouldApplyIosOpenUrlFix({
+          config,
+          props: {
+            ios: {
+              captchaOpenUrlFix: false,
+            },
+          },
+        }),
+      ).toBe(false);
+
+      expect(
+        shouldApplyIosOpenUrlFix({
+          config,
+          props: {
+            ios: {
+              captchaOpenUrlFix: true,
+            },
+          },
+        }),
+      ).toBe(true);
+    }
+  });
+
+  it('throws an error for invalid config', () => {
+    expect(() =>
+      shouldApplyIosOpenUrlFix({
+        config: {
+          name: 'TestName',
+          slug: 'TestSlug',
+        },
+        props: {
+          ios: {
+            // @ts-ignore testing invalid argument
+            captchaOpenUrlFix: Math.PI,
+          },
+        },
+      }),
+    ).toThrow("Unexpected value for 'captchaOpenUrlFix' config option");
+  });
+
+  const appDelegateFixturesPatch = [
+    'AppDelegate_bare_sdk43.m',
+    'AppDelegate_sdk44.m',
+    'AppDelegate_sdk45.mm',
+  ];
+  appDelegateFixturesPatch.forEach(fixtureName => {
+    it(`munges AppDelegate correctly - ${fixtureName}`, async () => {
+      const fixturePath = path.join(__dirname, 'fixtures', fixtureName);
+      const appDelegate = await fs.readFile(fixturePath, { encoding: 'utf-8' });
+      const result = modifyObjcAppDelegate(appDelegate);
+      expect(result).toMatchSnapshot();
+    });
+
+    it(`prints warning message when configured to default and AppDelegate is modified`, async () => {
+      const fixturePath = path.join(__dirname, 'fixtures', fixtureName);
+      const appDelegate = await fs.readFile(fixturePath, { encoding: 'utf-8' });
+      const config = {
+        name: 'TestName',
+        slug: 'TestSlug',
+        modRequest: { projectRoot: path.join(__dirname, 'fixtures') } as any,
+        modResults: {
+          path: fixturePath,
+          language: 'objc',
+          contents: appDelegate,
+        } as AppDelegateProjectFile,
+        modRawConfig: { name: 'TestName', slug: 'TestSlug' },
+      };
+      const props = undefined;
+      const spy = jest
+        .spyOn(WarningAggregator, 'addWarningIOS')
+        .mockImplementation(() => undefined);
+      withOpenUrlFixForAppDelegate({ config, props });
+      expect(spy).toHaveBeenCalledWith(
+        '@react-native-firebase/auth',
+        'modifying iOS AppDelegate openURL method to ignore firebaseauth reCAPTCHA redirect URLs',
+      );
+    });
+  });
+
+  const appDelegateFixturesNoop = ['AppDelegate_sdk42.m', 'AppDelegate_fallback.m'];
+  appDelegateFixturesNoop.forEach(fixtureName => {
+    it(`skips AppDelegate without openURL - ${fixtureName}`, async () => {
+      const fixturePath = path.join(__dirname, 'fixtures', fixtureName);
+      const appDelegate = await fs.readFile(fixturePath, { encoding: 'utf-8' });
+      const config = {
+        name: 'TestName',
+        slug: 'TestSlug',
+        plugins: ['expo-router'],
+        modRequest: { projectRoot: path.join(__dirname, 'fixtures') } as any,
+        modResults: {
+          path: fixturePath,
+          language: 'objc',
+          contents: appDelegate,
+        } as AppDelegateProjectFile,
+        modRawConfig: { name: 'TestName', slug: 'TestSlug' },
+      };
+      const props = undefined;
+      const spy = jest
+        .spyOn(WarningAggregator, 'addWarningIOS')
+        .mockImplementation(() => undefined);
+      const result = withOpenUrlFixForAppDelegate({ config, props });
+      expect(result.modResults.contents).toBe(appDelegate);
+      expect(spy).toHaveBeenCalledWith(
+        '@react-native-firebase/auth',
+        "Skipping iOS openURL fix because no 'openURL' method was found",
+      );
+    });
+
+    it(`errors when enabled but openURL not found - ${fixtureName}`, async () => {
+      const fixturePath = path.join(__dirname, 'fixtures', fixtureName);
+      const appDelegate = await fs.readFile(fixturePath, { encoding: 'utf-8' });
+      const config = {
+        name: 'TestName',
+        slug: 'TestSlug',
+        modRequest: { projectRoot: path.join(__dirname, 'fixtures') } as any,
+        modResults: {
+          path: fixturePath,
+          language: 'objc',
+          contents: appDelegate,
+        } as AppDelegateProjectFile,
+        modRawConfig: { name: 'TestName', slug: 'TestSlug' },
+      };
+      const props = {
+        ios: {
+          captchaOpenUrlFix: true,
+        },
+      };
+      expect(() => withOpenUrlFixForAppDelegate({ config, props })).toThrow(
+        "Failed to apply iOS openURL fix because no 'openURL' method was found",
+      );
+    });
+  });
+
+  it(`should issue error when openURL is found but patching fails`, () => {
+    const snippet = [
+      '// preamble goes here\nint theAnswer()\n{\n\treturn 42;\n}',
+      '- (BOOL)application:(UIApplication *)application options:(NSDictionary<UIApplicationOpenURLOptionsKey,id> *)options openURL:(NSURL *)url\n{',
+      'int x = theAnswer();\n',
+    ].join('');
+    expect(() => modifyObjcAppDelegate(snippet)).toThrow(
+      "Failed to apply 'captchaOpenUrlFix' but detected 'openURL' method.",
+    );
+  });
+
+  const positiveTemplateCases = [
+    '- (BOOL)application:(UIApplication *)application openURL:(NSURL *)url options:(NSDictionary<UIApplicationOpenURLOptionsKey,id> *)options {\n\tint x=3;',
+    '- (BOOL)application:(UIApplication *)application openURL:(NSURL *)url options:(NSDictionary<UIApplicationOpenURLOptionsKey,id> *)options',
+    '\t- (\tBOOL ) application : ( UIApplication*\t)   application openURL : ( NSURL*) url   options :  (  NSDictionary < UIApplicationOpenURLOptionsKey , id > *)\toptions',
+    '  - ( BOOL ) application : ( UIApplication*\t)   application openURL : ( NSURL*) url   options :  (  NSDictionary < UIApplicationOpenURLOptionsKey , id > *)\toptions\n\n{\n\n',
+  ];
+  positiveTemplateCases.forEach((snippet, caseIdx) => {
+    it(`must match positiveTemplateCases[${caseIdx}]`, () => {
+      expect(appDelegateOpenUrlInsertionPointAfter.test(snippet)).toBe(true);
+      if (snippet.match(/{/)) {
+        expect(multiline_appDelegateOpenUrlInsertionPointAfter.test(snippet)).toBe(true);
+        expect(modifyObjcAppDelegate(snippet)).toMatchSnapshot();
+      }
+    });
+  });
+
+  const negativeTemplateCases = [
+    '- (BOOL)application:(UIApplication *)application continueUserActivity:(nonnull NSUserActivity *)userActivity {',
+    '- (BOOL)application:(UIApplication *)application openURL:(NSURL *)url',
+    '\t( BOOL ) application : ( UIApplication*\t)   application openURL : ( NSURL*) url   options :  (  NSDictionary < UIApplicationOpenURLOptionsKey , id > *)\toptions',
+  ];
+  negativeTemplateCases.forEach((snippet, caseIdx) => {
+    it(`must not match negativeTemplateCases[${caseIdx}]`, () => {
+      expect(appDelegateOpenUrlInsertionPointAfter.test(snippet)).toBe(false);
+    });
+  });
+
+  it(`rejects projects with swizzling disabled`, () => {
+    const config = {
+      name: 'TestName',
+      slug: 'TestSlug',
+      plugins: ['expo-router'],
+      modRequest: { projectRoot: path.join(__dirname, 'fixtures') } as any,
+      modResults: {
+        path: path.join(__dirname, 'fixtures', '/path/to/Info.plist'),
+        language: 'plist',
+        contents: '',
+      },
+      modRawConfig: { name: 'TestName', slug: 'TestSlug' },
+      ios: {
+        infoPlist: {
+          FirebaseAppDelegateProxyEnabled: false,
+        },
+      },
+    };
+    expect(() => ensureFirebaseSwizzlingIsEnabled(config)).toThrow(
+      'Your app has disabled swizzling by setting FirebaseAppDelegateProxyEnabled=false in its Info.plist.',
+    );
+  });
+});

package/plugin/__tests__/{iosPlugin.test.ts → iosPlugin_urlTypes.test.ts}

@@ -2,7 +2,7 @@ import path from 'path';
 import { beforeEach, describe, expect, it, jest } from '@jest/globals';
 import { setUrlTypesForCaptcha } from '../src/ios/urlTypes';
 
-describe('Config Plugin iOS Tests', () => {
+describe('Config Plugin iOS Tests - urlTypes', () => {
   beforeEach(function () {
     jest.resetAllMocks();
   });

package/plugin/build/index.d.ts

@@ -1,3 +1,4 @@
 import { ConfigPlugin } from '@expo/config-plugins';
-declare const _default: ConfigPlugin<void>;
+import { PluginConfigType } from './pluginConfig';
+declare const _default: ConfigPlugin<PluginConfigType>;
 export default _default;

package/plugin/build/index.js

@@ -5,10 +5,11 @@ const ios_1 = require("./ios");
 /**
  * A config plugin for configuring `@react-native-firebase/auth`
  */
-const withRnFirebaseAuth = config => {
+const withRnFirebaseAuth = (config, props) => {
     return (0, config_plugins_1.withPlugins)(config, [
         // iOS
-        ios_1.withIosCaptchaUrlTypes,
+        [ios_1.withIosCaptchaUrlTypes, props],
+        [ios_1.withIosCaptchaOpenUrlFix, props],
     ]);
 };
 const pak = require('@react-native-firebase/auth/package.json');

package/plugin/build/ios/index.d.ts

@@ -1,2 +1,3 @@
 import { withIosCaptchaUrlTypes } from './urlTypes';
-export { withIosCaptchaUrlTypes };
+import { withIosCaptchaOpenUrlFix } from './openUrlFix';
+export { withIosCaptchaUrlTypes, withIosCaptchaOpenUrlFix };

package/plugin/build/ios/index.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.withIosCaptchaUrlTypes = void 0;
+exports.withIosCaptchaOpenUrlFix = exports.withIosCaptchaUrlTypes = void 0;
 const urlTypes_1 = require("./urlTypes");
 Object.defineProperty(exports, "withIosCaptchaUrlTypes", { enumerable: true, get: function () { return urlTypes_1.withIosCaptchaUrlTypes; } });
+const openUrlFix_1 = require("./openUrlFix");
+Object.defineProperty(exports, "withIosCaptchaOpenUrlFix", { enumerable: true, get: function () { return openUrlFix_1.withIosCaptchaOpenUrlFix; } });

package/plugin/build/ios/openUrlFix.d.ts

@@ -0,0 +1,20 @@
+import { ConfigPlugin, ExportedConfigWithProps } from '@expo/config-plugins';
+import type { ExpoConfig } from '@expo/config/build/Config.types';
+import type { AppDelegateProjectFile } from '@expo/config-plugins/build/ios/Paths';
+import type { InfoPlist } from '@expo/config-plugins/build/ios/IosConfig.types';
+import { PluginConfigType } from '../pluginConfig';
+export declare const withIosCaptchaOpenUrlFix: ConfigPlugin<PluginConfigType>;
+export declare function shouldApplyIosOpenUrlFix({ config, props, }: {
+    config: ExpoConfig;
+    props?: PluginConfigType;
+}): boolean;
+export declare function withOpenUrlFixForAppDelegate({ config, props, }: {
+    config: ExportedConfigWithProps<AppDelegateProjectFile>;
+    props?: PluginConfigType;
+}): ExportedConfigWithProps<AppDelegateProjectFile>;
+export declare const appDelegateOpenUrlInsertionPointAfter: RegExp;
+export declare const multiline_appDelegateOpenUrlInsertionPointAfter: RegExp;
+export declare function modifyObjcAppDelegate(contents: string): string | null;
+export type ExpoConfigPluginEntry = string | [] | [string] | [string, any];
+export declare function isFirebaseSwizzlingDisabled(config: ExportedConfigWithProps<InfoPlist>): boolean;
+export declare function ensureFirebaseSwizzlingIsEnabled(config: ExportedConfigWithProps<InfoPlist>): boolean;