@react-native-firebase/app 26.3.3 → 27.0.0

package/ios/RNFBAppUnitTests/RNFBUtilsModuleShellTests.mm

@@ -0,0 +1,282 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <Photos/Photos.h>
+#import <XCTest/XCTest.h>
+#import <objc/runtime.h>
+
+#import "RNFBAppTurboModules.h"
+#import "RNFBUtilsModule.h"
+#import "RNFBUtilsModuleImplementation.h"
+
+/**
+ * Exercises the shipped `RNFBUtilsModule.mm` shell, the Android-only stubs in
+ * `RNFBUtilsModuleImplementation.m` and the PhotoKit category in
+ * `RNFBUtilsModule+PhotoAssets.m`. All three are compiled into this target.
+ */
+@interface RNFBUtilsModule (ShellTesting)
+- (facebook::react::ModuleConstants<JS::NativeRNFBTurboUtils::Constants>)constantsToExport;
+- (facebook::react::ModuleConstants<JS::NativeRNFBTurboUtils::Constants>)getConstants;
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params;
++ (BOOL)requiresMainQueueSetup;
++ (NSString *)moduleName;
+- (void)androidGetPlayServicesStatus:(RCTPromiseResolveBlock)resolve
+                              reject:(RCTPromiseRejectBlock)reject;
+- (void)androidPromptForPlayServices:(RCTPromiseResolveBlock)resolve
+                              reject:(RCTPromiseRejectBlock)reject;
+- (void)androidResolutionForPlayServices:(RCTPromiseResolveBlock)resolve
+                                  reject:(RCTPromiseRejectBlock)reject;
+- (void)androidMakePlayServicesAvailable:(RCTPromiseResolveBlock)resolve
+                                  reject:(RCTPromiseRejectBlock)reject;
+@end
+
+/** `PHFetchResult` stand-in whose `firstObject` is controlled by the test. */
+@interface RNFBFakeFetchResult : PHFetchResult
+@property(nonatomic, strong, nullable) PHAsset *stubbedFirstObject;
+@end
+
+@implementation RNFBFakeFetchResult
+- (id)firstObject {
+  return self.stubbedFirstObject;
+}
+@end
+
+static SEL PHAssetFetchSelector(void) {
+  return @selector(fetchAssetsWithLocalIdentifiers:options:);
+}
+
+@interface RNFBUtilsModuleShellTests : XCTestCase
+@property(nonatomic, strong) PHAsset *fakeAsset;
+@property(nonatomic, strong) NSMutableArray<NSArray<NSString *> *> *fetchedIdentifiers;
+@property(nonatomic, strong) NSMutableArray<NSNumber *> *fetchedOptionsWereNil;
+@property(nonatomic, assign) IMP originalFetchImplementation;
+@end
+
+@implementation RNFBUtilsModuleShellTests
+
+#pragma mark - Module shell
+
+- (void)testExportedModuleNameAndMainQueueSetup {
+  XCTAssertEqualObjects([RNFBUtilsModule moduleName], @"NativeRNFBTurboUtils");
+  XCTAssertFalse([RNFBUtilsModule requiresMainQueueSetup]);
+}
+
+- (void)testGetTurboModuleCreatesTheUtilsSpecModule {
+  RNFBUtilsModule *module = [[RNFBUtilsModule alloc] init];
+  facebook::react::ObjCTurboModule::InitParams params;
+
+  auto turboModule = [module getTurboModule:params];
+
+  XCTAssertTrue(turboModule != nullptr);
+  XCTAssertTrue(std::dynamic_pointer_cast<facebook::react::NativeRNFBTurboUtilsSpecJSI>(
+                    turboModule) != nullptr);
+}
+
+- (void)testConstantsToExportAndGetConstantsReturnUtilsConstants {
+  RNFBUtilsModule *module = [[RNFBUtilsModule alloc] init];
+
+  auto exported = [module constantsToExport];
+  auto fetched = [module getConstants];
+
+  for (NSDictionary *constants in @[ exported.dictionary, fetched.dictionary ]) {
+    XCTAssertEqualObjects(constants[@"isRunningInTestLab"], @NO);
+    XCTAssertNotNil(constants[@"MAIN_BUNDLE"]);
+    XCTAssertNotNil(constants[@"TEMP_DIRECTORY"]);
+    XCTAssertNotNil(constants[@"CACHES_DIRECTORY"]);
+  }
+  XCTAssertEqualObjects(RNFBUtilsModuleConstantsDictionary()[@"isRunningInTestLab"], @NO);
+}
+
+#pragma mark - Android-only stubs
+
+- (void)testAndroidPlayServicesStatusReportsAvailableOnIOS {
+  RNFBUtilsModule *module = [[RNFBUtilsModule alloc] init];
+  __block NSDictionary *viaModule = nil;
+  __block NSDictionary *viaFunction = nil;
+
+  [module
+      androidGetPlayServicesStatus:^(id result) {
+        viaModule = result;
+      }
+      reject:^(NSString *code, NSString *message, NSError *error) {
+        XCTFail(@"unexpected reject %@", message);
+      }];
+  RNFBUtilsModuleAndroidGetPlayServicesStatus(
+      ^(id result) {
+        viaFunction = result;
+      },
+      ^(NSString *code, NSString *message, NSError *error) {
+        XCTFail(@"unexpected reject %@", message);
+      });
+
+  NSDictionary *expected = @{
+    @"isAvailable" : @YES,
+    @"status" : @0,
+    @"hasResolution" : @NO,
+    @"isUserResolvableError" : @NO,
+  };
+  XCTAssertEqualObjects(viaModule, expected);
+  XCTAssertEqualObjects(viaFunction, expected);
+}
+
+- (void)testAndroidPromptResolutionAndMakeAvailableResolveNil {
+  RNFBUtilsModule *module = [[RNFBUtilsModule alloc] init];
+  RCTPromiseRejectBlock failOnReject = ^(NSString *code, NSString *message, NSError *error) {
+    XCTFail(@"unexpected reject %@", message);
+  };
+  __block NSUInteger resolveCount = 0;
+  __block BOOL sawNonNil = NO;
+  RCTPromiseResolveBlock countNil = ^(id result) {
+    resolveCount += 1;
+    sawNonNil = sawNonNil || result != nil;
+  };
+
+  [module androidPromptForPlayServices:countNil reject:failOnReject];
+  [module androidResolutionForPlayServices:countNil reject:failOnReject];
+  [module androidMakePlayServicesAvailable:countNil reject:failOnReject];
+  RNFBUtilsModuleAndroidPromptForPlayServices(countNil, failOnReject);
+  RNFBUtilsModuleAndroidResolutionForPlayServices(countNil, failOnReject);
+  RNFBUtilsModuleAndroidMakePlayServicesAvailable(countNil, failOnReject);
+
+  XCTAssertEqual(resolveCount, 6);
+  XCTAssertFalse(sawNonNil);
+}
+
+#pragma mark - PhotoKit category
+
+- (void)testAssetsLibraryPathsAreUnsupportedAndNeverQueryPhotos {
+  [self stubPhotoLibraryReturning:[self fetchResultContaining:self.fakeAsset]];
+
+  // The one-time warning is suppressed on later calls; the result stays nil and PhotoKit is never
+  // consulted for the removed `assets-library://` scheme, even when an id is present.
+  XCTAssertNil([RNFBUtilsModule fetchAssetForPath:@"assets-library://asset/asset.JPG?id=1"]);
+  XCTAssertNil([RNFBUtilsModule fetchAssetForPath:@"assets-library://asset/asset.JPG?id=2"]);
+
+  XCTAssertEqual(self.fetchedIdentifiers.count, 0);
+}
+
+- (void)testPhotoLibraryPathPassesEverythingAfterTheSchemeToPhotoKit {
+  [self stubPhotoLibraryReturning:[self fetchResultContaining:self.fakeAsset]];
+
+  PHAsset *asset = [RNFBUtilsModule fetchAssetForPath:@"ph://ABC-123/L0/001"];
+
+  XCTAssertEqual(asset, self.fakeAsset);
+  XCTAssertEqualObjects(self.fetchedIdentifiers, @[ @[ @"ABC-123/L0/001" ] ]);
+  XCTAssertEqual(self.fetchedOptionsWereNil.count, 1);
+  XCTAssertEqualObjects(self.fetchedOptionsWereNil.firstObject, @YES);
+}
+
+- (void)testPhotoLibraryPathWithNoMatchingAssetReturnsNil {
+  [self stubPhotoLibraryReturning:[self fetchResultContaining:nil]];
+
+  XCTAssertNil([RNFBUtilsModule fetchAssetForPath:@"ph://missing-local-identifier"]);
+  XCTAssertEqualObjects(self.fetchedIdentifiers, @[ @[ @"missing-local-identifier" ] ]);
+}
+
+- (void)testPhotoLibraryPathWithNoIdentifierLooksUpTheEmptyIdentifier {
+  [self stubPhotoLibraryReturning:[self fetchResultContaining:nil]];
+
+  XCTAssertNil([RNFBUtilsModule fetchAssetForPath:@"ph://"]);
+  XCTAssertEqualObjects(self.fetchedIdentifiers, @[ @[ @"" ] ]);
+}
+
+- (void)testOtherPathsLookUpTheIdQueryItem {
+  [self stubPhotoLibraryReturning:[self fetchResultContaining:self.fakeAsset]];
+
+  PHAsset *asset =
+      [RNFBUtilsModule fetchAssetForPath:@"file:///asset.jpg?w=100&id=local-identifier&h=50"];
+
+  XCTAssertEqual(asset, self.fakeAsset);
+  XCTAssertEqualObjects(self.fetchedIdentifiers, @[ @[ @"local-identifier" ] ]);
+  XCTAssertEqualObjects(self.fetchedOptionsWereNil.firstObject, @YES);
+}
+
+- (void)testOtherPathsWithNoMatchingAssetReturnNil {
+  [self stubPhotoLibraryReturning:[self fetchResultContaining:nil]];
+
+  XCTAssertNil(
+      [RNFBUtilsModule fetchAssetForPath:@"file:///asset.jpg?id=missing-local-identifier"]);
+  XCTAssertEqualObjects(self.fetchedIdentifiers, @[ @[ @"missing-local-identifier" ] ]);
+}
+
+- (void)testOtherPathsWithoutAnIdQueryItemRaiseBeforeQueryingPhotos {
+  [self stubPhotoLibraryReturning:[self fetchResultContaining:self.fakeAsset]];
+
+  // Pre-port parity: a missing `id` yields a nil identifier and the `@[ assetId ]` literal
+  // raises. `RNFBStorageCommon` only reaches this method for `ph://` / `assets-library://`
+  // paths (`isRemoteAsset:`), so this is not reachable from the storage upload flow.
+  for (NSString *path in @[ @"file:///asset.jpg", @"file:///asset.jpg?other=1", @"" ]) {
+    XCTAssertThrowsSpecificNamed([RNFBUtilsModule fetchAssetForPath:path], NSException,
+                                 NSInvalidArgumentException, @"%@", path);
+  }
+  XCTAssertEqual(self.fetchedIdentifiers.count, 0);
+}
+
+- (void)testUnknownIdentifiersReturnNilWhenPhotoKitFindsNothing {
+  // Hostless macOS XCTest has no NSPhotoLibraryUsageDescription; never touch live PhotoKit.
+  // Stub an empty fetch for both lookup branches (`ph://` and `file://?id=`).
+  [self stubPhotoLibraryReturning:[self fetchResultContaining:nil]];
+
+  XCTAssertNil([RNFBUtilsModule fetchAssetForPath:@"ph://missing-local-identifier"]);
+  XCTAssertNil(
+      [RNFBUtilsModule fetchAssetForPath:@"file:///asset.jpg?id=missing-local-identifier"]);
+  XCTAssertEqualObjects(self.fetchedIdentifiers, (@[
+                          @[ @"missing-local-identifier" ],
+                          @[ @"missing-local-identifier" ],
+                        ]));
+}
+
+#pragma mark - PhotoKit stubbing
+
+- (void)setUp {
+  [super setUp];
+  self.fakeAsset = (PHAsset *)class_createInstance([PHAsset class], 0);
+  self.fetchedIdentifiers = [NSMutableArray array];
+  self.fetchedOptionsWereNil = [NSMutableArray array];
+}
+
+- (void)tearDown {
+  if (self.originalFetchImplementation != NULL) {
+    Method method = class_getClassMethod([PHAsset class], PHAssetFetchSelector());
+    method_setImplementation(method, self.originalFetchImplementation);
+    self.originalFetchImplementation = NULL;
+  }
+  [super tearDown];
+}
+
+- (id)fetchResultContaining:(PHAsset *)asset {
+  RNFBFakeFetchResult *result =
+      (RNFBFakeFetchResult *)class_createInstance([RNFBFakeFetchResult class], 0);
+  result.stubbedFirstObject = asset;
+  return result;
+}
+
+/** Replaces `+[PHAsset fetchAssetsWithLocalIdentifiers:options:]`, recording each call. */
+- (void)stubPhotoLibraryReturning:(id)fetchResult {
+  Method method = class_getClassMethod([PHAsset class], PHAssetFetchSelector());
+  self.originalFetchImplementation = method_getImplementation(method);
+  __weak RNFBUtilsModuleShellTests *weakSelf = self;
+  IMP stub = imp_implementationWithBlock(
+      ^id(id _self, NSArray<NSString *> *identifiers, PHFetchOptions *options) {
+        [weakSelf.fetchedIdentifiers addObject:identifiers];
+        [weakSelf.fetchedOptionsWereNil addObject:@(options == nil)];
+        return fetchResult;
+      });
+  method_setImplementation(method, stub);
+}
+
+@end

package/ios/RNFBFirebase/Package.swift

@@ -0,0 +1,53 @@
+// swift-tools-version: 5.9
+//
+// CI probe only (RNFB_TEST_RN_BARE_DYNAMIC_FIREBASE=1). Shipped podspecs keep
+// spm_dependency on firebase-ios-sdk. Exact pin tracks packages/app/package.json
+// sdkVersions.ios.firebase (checked by .github/workflows/scripts/check-ios-probe-sdk-pin.js).
+//
+// This package resolver rejects mixed Swift and Objective-C sources in one
+// target. SDK calls live in RNFBFirebaseBridge. The dynamic product links that
+// target beside the Swift target. The Swift target does not depend on it, so
+// the emitted module does not record FirebaseCore for clients.
+
+import PackageDescription
+
+let package = Package(
+  name: "RNFBFirebase",
+  platforms: [
+    .iOS(.v15),
+    .macOS(.v11),
+    .tvOS(.v15),
+  ],
+  products: [
+    .library(
+      name: "RNFBFirebase",
+      type: .dynamic,
+      targets: ["RNFBFirebase", "RNFBFirebaseBridge"]
+    ),
+  ],
+  dependencies: [
+    .package(
+      url: "https://github.com/firebase/firebase-ios-sdk.git",
+      exact: "13.0.0"
+    ),
+  ],
+  targets: [
+    .target(
+      name: "RNFBFirebaseBridge",
+      dependencies: [
+        .product(name: "FirebaseCore", package: "firebase-ios-sdk"),
+        .product(name: "FirebaseInstallations", package: "firebase-ios-sdk"),
+      ],
+      // Public headers stay empty so this clang target does not publish a
+      // module. The dynamic product still links the object file. The Swift
+      // target does not depend on it, so clients do not inherit FirebaseCore.
+      publicHeadersPath: "Public",
+      cSettings: [
+        .headerSearchPath("include"),
+      ]
+    ),
+    .target(
+      name: "RNFBFirebase"
+    ),
+  ]
+)

package/ios/RNFBFirebase/Sources/RNFBFirebase/RNFBFirebase.swift

@@ -0,0 +1,285 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Foundation
+
+/// Foundation-only snapshot of a live app for RNFBApp mapping code.
+public final class RNFBFirebaseAppSnapshot: NSObject {
+  public let name: String
+  public let apiKey: String?
+  public let googleAppID: String?
+  public let projectID: String?
+  public let databaseURL: String?
+  public let storageBucket: String?
+  public let gcmSenderID: String?
+  public let clientID: String?
+  public let isDataCollectionDefaultEnabled: Bool
+
+  public init(
+    name: String,
+    apiKey: String?,
+    googleAppID: String?,
+    projectID: String?,
+    databaseURL: String?,
+    storageBucket: String?,
+    gcmSenderID: String?,
+    clientID: String?,
+    isDataCollectionDefaultEnabled: Bool
+  ) {
+    self.name = name
+    self.apiKey = apiKey
+    self.googleAppID = googleAppID
+    self.projectID = projectID
+    self.databaseURL = databaseURL
+    self.storageBucket = storageBucket
+    self.gcmSenderID = gcmSenderID
+    self.clientID = clientID
+    self.isDataCollectionDefaultEnabled = isDataCollectionDefaultEnabled
+  }
+}
+
+/// Live options operations. Public signatures stay Foundation types.
+public enum RNFBFirebaseOptionsClient {
+  public static func create(googleAppID: String?, gcmSenderID: String?) -> NSObject {
+    rnfbWithCString(googleAppID) { appID in
+      rnfbWithCString(gcmSenderID) { senderID in
+        rnfbRetainedObject(RNFBFirebaseCreateOptions(appID, senderID))
+      }
+    }
+  }
+
+  public static func apiKey(_ options: NSObject) -> String? {
+    rnfbString(RNFBFirebaseOptionsAPIKey(options))
+  }
+
+  public static func setAPIKey(_ value: String?, on options: NSObject) {
+    rnfbWithCString(value) { RNFBFirebaseOptionsSetAPIKey(options, $0) }
+  }
+
+  public static func projectID(_ options: NSObject) -> String? {
+    rnfbString(RNFBFirebaseOptionsProjectID(options))
+  }
+
+  public static func setProjectID(_ value: String?, on options: NSObject) {
+    rnfbWithCString(value) { RNFBFirebaseOptionsSetProjectID(options, $0) }
+  }
+
+  public static func clientID(_ options: NSObject) -> String? {
+    rnfbString(RNFBFirebaseOptionsClientID(options))
+  }
+
+  public static func setClientID(_ value: String?, on options: NSObject) {
+    rnfbWithCString(value) { RNFBFirebaseOptionsSetClientID(options, $0) }
+  }
+
+  public static func databaseURL(_ options: NSObject) -> String? {
+    rnfbString(RNFBFirebaseOptionsDatabaseURL(options))
+  }
+
+  public static func setDatabaseURL(_ value: String?, on options: NSObject) {
+    rnfbWithCString(value) { RNFBFirebaseOptionsSetDatabaseURL(options, $0) }
+  }
+
+  public static func storageBucket(_ options: NSObject) -> String? {
+    rnfbString(RNFBFirebaseOptionsStorageBucket(options))
+  }
+
+  public static func setStorageBucket(_ value: String?, on options: NSObject) {
+    rnfbWithCString(value) { RNFBFirebaseOptionsSetStorageBucket(options, $0) }
+  }
+
+  public static func bundleID(_ options: NSObject) -> String? {
+    rnfbString(RNFBFirebaseOptionsBundleID(options))
+  }
+
+  public static func setBundleID(_ value: String?, on options: NSObject) {
+    rnfbWithCString(value) { RNFBFirebaseOptionsSetBundleID(options, $0) }
+  }
+
+  public static func appGroupID(_ options: NSObject) -> String? {
+    rnfbString(RNFBFirebaseOptionsAppGroupID(options))
+  }
+
+  public static func setAppGroupID(_ value: String?, on options: NSObject) {
+    rnfbWithCString(value) { RNFBFirebaseOptionsSetAppGroupID(options, $0) }
+  }
+}
+
+/// Live app operations. No SDK types cross this boundary.
+public enum RNFBFirebaseAppClient {
+  public static func defaultApp() -> NSObject? {
+    rnfbObject(RNFBFirebaseDefaultApp())
+  }
+
+  public static func app(named name: String) -> NSObject? {
+    name.withCString { rnfbObject(RNFBFirebaseAppNamed($0)) }
+  }
+
+  public static func allApps() -> [AnyHashable: Any]? {
+    guard let apps = rnfbDictionary(RNFBFirebaseAllApps()) else { return nil }
+    var result: [AnyHashable: Any] = [:]
+    for (key, value) in apps {
+      guard let key = key as? AnyHashable else { continue }
+      result[key] = value
+    }
+    return result
+  }
+
+  /// Default-plist configure. The dynamic probe app cannot name the SDK app type.
+  public static func configure() {
+    RNFBFirebaseConfigure()
+  }
+
+  public static func configure(options: NSObject) {
+    RNFBFirebaseConfigureWithOptions(options)
+  }
+
+  public static func configure(name: String, options: NSObject) {
+    name.withCString { RNFBFirebaseConfigureWithName($0, options) }
+  }
+
+  public static func snapshot(of app: NSObject) -> RNFBFirebaseAppSnapshot {
+    let raw = rnfbDictionary(RNFBFirebaseSnapshot(app)) ?? [:]
+    return RNFBFirebaseAppSnapshot(
+      name: raw["name"] as? String ?? "",
+      apiKey: snapshotString(raw, "apiKey"),
+      googleAppID: snapshotString(raw, "googleAppID"),
+      projectID: snapshotString(raw, "projectID"),
+      databaseURL: snapshotString(raw, "databaseURL"),
+      storageBucket: snapshotString(raw, "storageBucket"),
+      gcmSenderID: snapshotString(raw, "gcmSenderID"),
+      clientID: snapshotString(raw, "clientID"),
+      isDataCollectionDefaultEnabled: raw["isDataCollectionDefaultEnabled"] as? Bool ?? false
+    )
+  }
+
+  /// Returns false when `app` is not a live app (caller no-ops).
+  public static func setDataCollectionDefaultEnabled(_ enabled: Bool, forApp app: NSObject) -> Bool {
+    RNFBFirebaseSetDataCollectionDefaultEnabled(ObjCBool(enabled), app).boolValue
+  }
+
+  /// Returns false when `app` is not a live app. Does not invoke `completion` in that case.
+  public static func deleteApp(_ app: NSObject, completion: @escaping (Bool) -> Void) -> Bool {
+    RNFBFirebaseDeleteApp(app) { success in
+      completion(success.boolValue)
+    }.boolValue
+  }
+
+  public static func setLoggerLevel(_ level: Int) {
+    RNFBFirebaseSetLoggerLevel(level)
+  }
+
+  public static func registerLibrary(name: String, version: String) {
+    name.withCString { libraryName in
+      version.withCString { libraryVersion in
+        RNFBFirebaseRegisterLibrary(libraryName, libraryVersion)
+      }
+    }
+  }
+
+  private static func snapshotString(_ raw: NSDictionary, _ key: String) -> String? {
+    guard let value = raw[key], !(value is NSNull) else { return nil }
+    return value as? String
+  }
+}
+
+// `@_silgen_name` sees the C ABI directly. Class optionals are not null
+// pointers here, so object results cross as `OpaquePointer`. +0 results use
+// `takeUnretainedValue`. The Create result is +1 and uses `takeRetainedValue`.
+
+private func rnfbWithCString<T>(_ value: String?, _ body: (UnsafePointer<CChar>?) -> T) -> T {
+  guard let value else { return body(nil) }
+  return value.withCString(body)
+}
+
+private func rnfbRetainedObject(_ pointer: OpaquePointer) -> NSObject {
+  Unmanaged<NSObject>.fromOpaque(UnsafeMutableRawPointer(pointer)).takeRetainedValue()
+}
+
+private func rnfbObject(_ pointer: OpaquePointer?) -> NSObject? {
+  guard let pointer else { return nil }
+  return Unmanaged<NSObject>.fromOpaque(UnsafeMutableRawPointer(pointer)).takeUnretainedValue()
+}
+
+private func rnfbString(_ pointer: OpaquePointer?) -> String? {
+  guard let pointer else { return nil }
+  let value = Unmanaged<NSString>.fromOpaque(UnsafeMutableRawPointer(pointer)).takeUnretainedValue()
+  return value as String
+}
+
+private func rnfbDictionary(_ pointer: OpaquePointer?) -> NSDictionary? {
+  guard let pointer else { return nil }
+  return Unmanaged<NSDictionary>.fromOpaque(UnsafeMutableRawPointer(pointer)).takeUnretainedValue()
+}
+
+@_silgen_name("RNFBFirebaseCreateOptions")
+private func RNFBFirebaseCreateOptions(
+  _ googleAppID: UnsafePointer<CChar>?,
+  _ senderID: UnsafePointer<CChar>?
+) -> OpaquePointer
+@_silgen_name("RNFBFirebaseOptionsAPIKey")
+private func RNFBFirebaseOptionsAPIKey(_ options: NSObject) -> OpaquePointer?
+@_silgen_name("RNFBFirebaseOptionsSetAPIKey")
+private func RNFBFirebaseOptionsSetAPIKey(_ options: NSObject, _ value: UnsafePointer<CChar>?)
+@_silgen_name("RNFBFirebaseOptionsProjectID")
+private func RNFBFirebaseOptionsProjectID(_ options: NSObject) -> OpaquePointer?
+@_silgen_name("RNFBFirebaseOptionsSetProjectID")
+private func RNFBFirebaseOptionsSetProjectID(_ options: NSObject, _ value: UnsafePointer<CChar>?)
+@_silgen_name("RNFBFirebaseOptionsClientID")
+private func RNFBFirebaseOptionsClientID(_ options: NSObject) -> OpaquePointer?
+@_silgen_name("RNFBFirebaseOptionsSetClientID")
+private func RNFBFirebaseOptionsSetClientID(_ options: NSObject, _ value: UnsafePointer<CChar>?)
+@_silgen_name("RNFBFirebaseOptionsDatabaseURL")
+private func RNFBFirebaseOptionsDatabaseURL(_ options: NSObject) -> OpaquePointer?
+@_silgen_name("RNFBFirebaseOptionsSetDatabaseURL")
+private func RNFBFirebaseOptionsSetDatabaseURL(_ options: NSObject, _ value: UnsafePointer<CChar>?)
+@_silgen_name("RNFBFirebaseOptionsStorageBucket")
+private func RNFBFirebaseOptionsStorageBucket(_ options: NSObject) -> OpaquePointer?
+@_silgen_name("RNFBFirebaseOptionsSetStorageBucket")
+private func RNFBFirebaseOptionsSetStorageBucket(_ options: NSObject, _ value: UnsafePointer<CChar>?)
+@_silgen_name("RNFBFirebaseOptionsBundleID")
+private func RNFBFirebaseOptionsBundleID(_ options: NSObject) -> OpaquePointer?
+@_silgen_name("RNFBFirebaseOptionsSetBundleID")
+private func RNFBFirebaseOptionsSetBundleID(_ options: NSObject, _ value: UnsafePointer<CChar>?)
+@_silgen_name("RNFBFirebaseOptionsAppGroupID")
+private func RNFBFirebaseOptionsAppGroupID(_ options: NSObject) -> OpaquePointer?
+@_silgen_name("RNFBFirebaseOptionsSetAppGroupID")
+private func RNFBFirebaseOptionsSetAppGroupID(_ options: NSObject, _ value: UnsafePointer<CChar>?)
+@_silgen_name("RNFBFirebaseDefaultApp")
+private func RNFBFirebaseDefaultApp() -> OpaquePointer?
+@_silgen_name("RNFBFirebaseAppNamed")
+private func RNFBFirebaseAppNamed(_ name: UnsafePointer<CChar>) -> OpaquePointer?
+@_silgen_name("RNFBFirebaseAllApps")
+private func RNFBFirebaseAllApps() -> OpaquePointer?
+@_silgen_name("RNFBFirebaseConfigure")
+private func RNFBFirebaseConfigure()
+@_silgen_name("RNFBFirebaseConfigureWithOptions")
+private func RNFBFirebaseConfigureWithOptions(_ options: NSObject)
+@_silgen_name("RNFBFirebaseConfigureWithName")
+private func RNFBFirebaseConfigureWithName(_ name: UnsafePointer<CChar>, _ options: NSObject)
+@_silgen_name("RNFBFirebaseSnapshot")
+private func RNFBFirebaseSnapshot(_ app: NSObject) -> OpaquePointer
+@_silgen_name("RNFBFirebaseSetDataCollectionDefaultEnabled")
+private func RNFBFirebaseSetDataCollectionDefaultEnabled(_ enabled: ObjCBool, _ app: NSObject) -> ObjCBool
+@_silgen_name("RNFBFirebaseDeleteApp")
+private func RNFBFirebaseDeleteApp(
+  _ app: NSObject,
+  _ completion: @convention(block) (ObjCBool) -> Void
+) -> ObjCBool
+@_silgen_name("RNFBFirebaseSetLoggerLevel")
+private func RNFBFirebaseSetLoggerLevel(_ level: Int)
+@_silgen_name("RNFBFirebaseRegisterLibrary")
+private func RNFBFirebaseRegisterLibrary(_ name: UnsafePointer<CChar>, _ version: UnsafePointer<CChar>)