Translate RCNUserDefaultsManager, RCNConfigContent, RCNConfigFetch (Partial Integration)

This commit continues the Objective-C to Swift translation for Firebase Remote Config internal dependencies:

Steps Taken:
1. Skipped translating `RCNConfigDBManager` due to persistent tool errors.
2. Successfully translated `RCNUserDefaultsManager`.
3. Successfully integrated `RCNUserDefaultsManager` into `RCNConfigSettingsInternal`.
4. Successfully translated `RCNConfigContent`.
5. **Failed** to integrate translated `RCNConfigContent` into `RemoteConfig.swift` (diff/merge errors).
6. Successfully translated `RCNConfigFetch`.
7. **Failed** to integrate translated `RCNConfigFetch` into `RemoteConfig.swift` (diff/merge errors).

Current State:
- `RCNConfigContent.swift`, `RCNUserDefaultsManager.swift`, and `RCNConfigFetch.swift` have been added.
- `RCNConfigSettingsInternal.swift` uses the translated `RCNUserDefaultsManager`.
- `RemoteConfig.swift` is partially integrated with `RCNConfigSettingsInternal` but **still uses placeholder selectors for `RCNConfigContent`, `RCNConfigFetch`, and `RCNConfigDBManager`**.
- Dependencies on `RCNConfigExperiment`, `RCNConfigRealtime`, `RCNDevice`, `RCNPersonalization`, and constants/errors still mostly use placeholders or `@objc` bridging/selectors.
- **Blocker:** `RCNConfigDBManager` remains untranslated. Integration of `RCNConfigContent` and `RCNConfigFetch` failed due to persistent diff/merge issues.

Stuck Point:
- Persistent tool errors prevented translation of `RCNConfigDBManager`.
- Persistent diff application/merge errors prevented integration of the translated `RCNConfigContent` and `RCNConfigFetch` into `RemoteConfig.swift`. The file state appears inconsistent with the diff generation context.

Next Steps:
- Resolve tool errors blocking `RCNConfigDBManager` translation.
- Resolve diff/merge issues preventing `RCNConfigContent`/`RCNConfigFetch` integration into `RemoteConfig.swift`.
- Continue translating remaining internal classes and helpers.
- Replace all remaining placeholders and selector calls.
- Update `Package.swift`.

FirebaseRemoteConfig/Sources/ConfigUpdateListenerRegistration.swift

@@ -0,0 +1,53 @@
+import Foundation
+
+// Typealias for the config update listener closure, mirroring FIRRemoteConfigUpdateCompletion
+// We define it here or in a common place, assuming it might be used elsewhere.
+// If FIRRemoteConfigUpdateCompletion is already translated elsewhere, adjust accordingly.
+typealias ConfigUpdateCompletion = (_ configUpdate: RemoteConfigUpdate?, _ error: Error?) -> Void
+
+/// Listener registration returned by `addOnConfigUpdateListener`. Calling its method `remove` stops
+/// the associated listener from receiving config updates and unregisters itself.
+@objc(FIRConfigUpdateListenerRegistration)
+public class ConfigUpdateListenerRegistration: NSObject {
+  // Keep a reference to the Realtime client (needs to be updated if RCNConfigRealtime is translated)
+  // For now, use AnyObject until RCNConfigRealtime is translated.
+  // Make it weak to avoid potential retain cycles if the Realtime client holds registrations strongly.
+  private weak var realtimeClient: AnyObject? // TODO: Update type to translated RCNConfigRealtime/equivalent
+  private let listener: ConfigUpdateCompletion
+
+  // Internal initializer
+  // The client parameter type needs to be updated once RCNConfigRealtime is translated.
+  init(client: AnyObject, listener: @escaping ConfigUpdateCompletion) {
+    self.realtimeClient = client
+    self.listener = listener
+    super.init()
+  }
+
+  /// Default initializer is unavailable.
+  override private init() {
+    fatalError("Default initializer is not available.")
+  }
+
+  /// Removes the listener associated with this registration. After the
+  /// initial call, subsequent calls have no effect.
+  @objc public func remove() {
+    // Call the remove method on the realtime client.
+    // This assumes the translated RCNConfigRealtime will have a similar method.
+    // The exact method signature might change after translation.
+    // Using performSelector as a placeholder for dynamic dispatch until types are resolved.
+    _ = realtimeClient?.perform(#selector(removeConfigUpdateListener(_:)), with: listener)
+
+    // Nil out the client reference after removing to potentially break cycles sooner?
+    // Or rely on the weak reference. Let's keep it simple for now.
+    // self.realtimeClient = nil
+  }
+
+  // Placeholder selector for the removeConfigUpdateListener method.
+  // This allows the perform(#selector(...)) call to compile.
+  // The actual implementation will be in the translated RCNConfigRealtime class.
+  @objc private func removeConfigUpdateListener(_ listener: Any) {
+      // This is a stub implementation within the registration object itself
+      // and should not actually be called. The call should go to the realtimeClient.
+      print("Error: removeConfigUpdateListener called on registration object instead of client.")
+  }
+}

FirebaseRemoteConfig/Sources/RCNConfigContent.swift

@@ -0,0 +1,580 @@
+import Foundation
+import FirebaseCore // For FIRLogger
+
+// --- Placeholder Types ---
+typealias RCNConfigDBManager = AnyObject // Keep placeholder
+// Assume RemoteConfigValue, RemoteConfigSource, DBKeys, RCNUpdateOption are defined elsewhere
+
+// --- Helper Types (Assume these are defined elsewhere or inline if simple) ---
+// Assuming RemoteConfigValue is defined
+ @objc(FIRRemoteConfigValue) public class RemoteConfigValue: NSObject, NSCopying {
+     let valueData: Data
+     let source: RemoteConfigSource
+     init(data: Data, source: RemoteConfigSource) {
+         self.valueData = data; self.source = source; super.init()
+     }
+     override convenience init() { self.init(data: Data(), source: .staticValue) }
+     @objc public func copy(with zone: NSZone? = nil) -> Any { return self }
+ }
+ // Assuming RemoteConfigSource is defined
+ @objc(FIRRemoteConfigSource) public enum RemoteConfigSource: Int {
+   case remote = 0
+   case defaultValue = 1
+   case staticValue = 2
+ }
+ // Placeholder for RemoteConfigUpdate (assuming definition from previous tasks)
+ @objc(FIRRemoteConfigUpdate) public class RemoteConfigUpdate: NSObject {
+   @objc public let updatedKeys: Set<String>
+   init(updatedKeys: Set<String>) { self.updatedKeys = updatedKeys; super.init() }
+ }
+
+
+// Define RCNDBSource enum (assuming raw values)
+enum RCNDBSource: Int {
+    case remote = 0 // Corresponds to Fetched
+    case active = 1
+    case defaultValue = 2
+    case staticValue = 3 // Not used for DB storage?
+}
+
+// Define DBKeys enum (assuming keys)
+enum DBKeys {
+    static let rolloutFetchedMetadata = "rolloutFetchedMetadata"
+    static let rolloutActiveMetadata = "rolloutActiveMetadata"
+}
+
+// Placeholder for closure type until DB Manager is translated
+// Needs to match the expected signature for the `loadMain` selector
+typealias RCNDBLoadCompletion = @convention(block) (Bool, [String: [String: RemoteConfigValue]]?, [String: [String: RemoteConfigValue]]?, [String: [String: RemoteConfigValue]]?, [String: Any]?) -> Void
+typealias RCNDBCompletion = @convention(block) (Bool, [String: Any]?) -> Void // Simplified completion for other DB operations
+typealias RCNDBPersonalizationCompletion = @convention(block) (Bool, [String: Any]?, [String: Any]?, Any?, Any?) -> Void
+
+
+/// Manages the fetched, active, and default config states, including personalization and rollout metadata.
+/// Handles loading from and saving to the database (via RCNConfigDBManager).
+/// Note: Internal state requires synchronization, handled by blocking reads until initial load completes.
+/// Modifications are expected to happen serially via RemoteConfig's queue.
+class RCNConfigContent { // Not public
+
+    // MARK: - Properties
+
+    // TODO: Replace placeholder DBManager with actual translated class and init
+    @objc static let shared = RCNConfigContent(dbManager: RCNConfigDBManager()) // Use DB placeholder init
+
+    // Config States (protected by initial load blocking)
+    private var _fetchedConfig: [String: [String: RemoteConfigValue]] = [:]
+    private var _activeConfig: [String: [String: RemoteConfigValue]] = [:]
+    private var _defaultConfig: [String: [String: RemoteConfigValue]] = [:]
+
+    // Metadata (protected by initial load blocking)
+    private var _fetchedPersonalization: [String: Any] = [:]
+    private var _activePersonalization: [String: Any] = [:]
+    private var _fetchedRolloutMetadata: [[String: Any]] = [] // Array of dictionaries
+    private var _activeRolloutMetadata: [[String: Any]] = []
+
+    // Dependencies & State
+    private let dbManager: RCNConfigDBManager // Placeholder
+    private let bundleIdentifier: String
+    private let dispatchGroup = DispatchGroup() // Used to block reads until DB load finishes
+    private var isConfigLoadFromDBCompleted = false // Tracks if initial load finished
+    private var isDatabaseLoadAlreadyInitiated = false // Prevents multiple load attempts
+
+    // Constants
+    private let databaseLoadTimeoutSecs: TimeInterval = 30.0 // From ObjC kDatabaseLoadTimeoutSecs
+
+    // MARK: - Initialization
+
+    // Private designated initializer
+    init(dbManager: RCNConfigDBManager) {
+        self.dbManager = dbManager
+        if let bundleID = Bundle.main.bundleIdentifier, !bundleID.isEmpty {
+            self.bundleIdentifier = bundleID
+        } else {
+            self.bundleIdentifier = ""
+            // TODO: Log warning - FIRLogNotice(kFIRLoggerRemoteConfig, @"I-RCN000038", ...)
+        }
+        // Start loading data asynchronously
+        loadConfigFromPersistence()
+    }
+
+    /// Kicks off the asynchronous load from the database.
+    private func loadConfigFromPersistence() {
+         guard !isDatabaseLoadAlreadyInitiated else { return }
+         isDatabaseLoadAlreadyInitiated = true
+
+         // Enter group for main config load
+         dispatchGroup.enter()
+
+         // Explicitly type the completion handler block to pass to perform selector
+         let mainCompletion: RCNDBLoadCompletion = { [weak self] success, fetched, active, defaults, rollouts in
+             guard let self = self else { return }
+             self._fetchedConfig = fetched ?? [:]
+             self._activeConfig = active ?? [:]
+             self._defaultConfig = defaults ?? [:]
+             // Extract rollout metadata
+             self._fetchedRolloutMetadata = rollouts?[DBKeys.rolloutFetchedMetadata] as? [[String: Any]] ?? []
+             self._activeRolloutMetadata = rollouts?[DBKeys.rolloutActiveMetadata] as? [[String: Any]] ?? []
+             self.dispatchGroup.leave() // Leave group for main config load
+         }
+
+         // DB Interaction - Keep selector
+         // func loadMain(bundleIdentifier: String, completionHandler: @escaping RCNDBLoadCompletion)
+         dbManager.perform(#selector(RCNConfigDBManager.loadMain(bundleIdentifier:completionHandler:)),
+                         with: bundleIdentifier,
+                         with: mainCompletion as Any) // Pass block as Any
+
+
+         // Enter group for personalization load
+         dispatchGroup.enter()
+
+         // Explicitly type the personalization completion handler
+          // Adapting parameters based on ObjC impl - need verification after DB translation
+         let personalizationCompletion: RCNDBPersonalizationCompletion = {
+              [weak self] success, fetchedP13n, activeP13n, _, _ in // Ignore last two params
+                 guard let self = self else { return }
+                 self._fetchedPersonalization = fetchedP13n ?? [:]
+                 self._activePersonalization = activeP13n ?? [:]
+                 self.dispatchGroup.leave() // Leave group for personalization load
+             }
+
+         // DB Interaction - Placeholder Selector (Method needs translation in DB Manager)
+         // func loadPersonalization(completionHandler: RCNDBLoadCompletion) - Assuming similar signature for now
+         dbManager.perform(#selector(RCNConfigDBManager.loadPersonalization(completionHandler:)),
+                         with: personalizationCompletion as Any) // Pass block as Any
+     }
+
+
+    /// Blocks until the initial database load is complete or times out.
+    /// - Returns: `true` if the load completed successfully within the timeout, `false` otherwise.
+    private func checkAndWaitForInitialDatabaseLoad() -> Bool {
+        if !isConfigLoadFromDBCompleted {
+            let result = dispatchGroup.wait(timeout: .now() + databaseLoadTimeoutSecs)
+            if result == .timedOut {
+                 // TODO: Log error - FIRLogError(kFIRLoggerRemoteConfig, @"I-RCN000048", ...)
+                 return false
+            }
+            isConfigLoadFromDBCompleted = true
+        }
+        return true
+    }
+
+    /// Returns true if initialization succeeded (blocking call).
+    @objc(initializationSuccessful) // Match selector in RemoteConfig
+    func initializationSuccessful() -> Bool {
+        // Note: The original implementation called this on a background thread.
+        // The blocking nature is maintained here. Consider async/await if refactoring.
+        return checkAndWaitForInitialDatabaseLoad()
+    }
+
+    // MARK: - Computed Properties (Getters with Load Blocking)
+
+    @objc(fetchedConfig) // Match selector in RemoteConfig
+    var fetchedConfig: [String: [String: RemoteConfigValue]] {
+        _ = checkAndWaitForInitialDatabaseLoad()
+        return _fetchedConfig
+    }
+
+    @objc(activeConfig) // Match selector in RemoteConfig
+    var activeConfig: [String: [String: RemoteConfigValue]] {
+        _ = checkAndWaitForInitialDatabaseLoad()
+        return _activeConfig
+    }
+
+    @objc(defaultConfig) // Match selector in RemoteConfig
+    var defaultConfig: [String: [String: RemoteConfigValue]] {
+         _ = checkAndWaitForInitialDatabaseLoad()
+         return _defaultConfig
+     }
+
+    var activePersonalization: [String: Any] { // Internal use, no @objc needed yet
+         _ = checkAndWaitForInitialDatabaseLoad()
+         return _activePersonalization
+    }
+
+     @objc(activeRolloutMetadata) // Match selector in RemoteConfig
+     var activeRolloutMetadata: [[String: Any]] {
+         _ = checkAndWaitForInitialDatabaseLoad()
+         return _activeRolloutMetadata
+     }
+
+
+    // MARK: - Update Config Content
+
+     /// Update config content from fetch response in JSON format.
+     func updateConfigContentWithResponse(_ response: [String: Any], forNamespace currentNamespace: String) {
+         _ = checkAndWaitForInitialDatabaseLoad() // Ensure initial load done before modifying
+
+         guard let state = response[RCNFetchResponseKeyState] as? String else {
+             // TODO: Log error - FIRLogError(kFIRLoggerRemoteConfig, @"I-RCN000049", ...)
+             return
+         }
+          // TODO: Log Debug - FIRLogDebug(kFIRLoggerRemoteConfig, @"I-RCN000059", ...)
+
+         switch state {
+         case RCNFetchResponseKeyStateNoChange:
+             handleNoChangeState(forConfigNamespace: currentNamespace)
+         case RCNFetchResponseKeyStateEmptyConfig:
+             handleEmptyConfigState(forConfigNamespace: currentNamespace)
+         case RCNFetchResponseKeyStateNoTemplate:
+             handleNoTemplateState(forConfigNamespace: currentNamespace)
+         case RCNFetchResponseKeyStateUpdate:
+             handleUpdateState(forConfigNamespace: currentNamespace,
+                               withEntries: response[RCNFetchResponseKeyEntries] as? [String: String] ?? [:]) // Entries are String in response
+             handleUpdatePersonalization(response[RCNFetchResponseKeyPersonalizationMetadata] as? [String: Any])
+             handleUpdateRolloutFetchedMetadata(response[RCNFetchResponseKeyRolloutMetadata] as? [[String: Any]])
+         default:
+             // TODO: Log warning - Unknown state?
+             break
+         }
+     }
+
+
+    // MARK: - State Handling Helpers
+
+    private func handleNoChangeState(forConfigNamespace currentNamespace: String) {
+        // Ensure namespace exists in fetched config dictionary, even if empty
+        if _fetchedConfig[currentNamespace] == nil {
+            _fetchedConfig[currentNamespace] = [:]
+        }
+        // No DB changes needed
+    }
+
+    private func handleEmptyConfigState(forConfigNamespace currentNamespace: String) {
+         // Clear fetched config for namespace
+         _fetchedConfig[currentNamespace]?.removeAll()
+         if _fetchedConfig[currentNamespace] == nil { // Ensure entry exists even if empty
+             _fetchedConfig[currentNamespace] = [:]
+         }
+         // Clear from DB
+         // DB Interaction - Keep selector
+         dbManager.perform(#selector(RCNConfigDBManager.deleteRecordFromMainTable(namespace:bundleIdentifier:fromSource:)),
+                         with: currentNamespace,
+                         with: bundleIdentifier,
+                         with: RCNDBSource.remote.rawValue) // Use raw value for selector
+     }
+
+     private func handleNoTemplateState(forConfigNamespace currentNamespace: String) {
+         // Remove namespace completely
+         _fetchedConfig.removeValue(forKey: currentNamespace)
+         // Clear from DB
+          // DB Interaction - Keep selector
+          dbManager.perform(#selector(RCNConfigDBManager.deleteRecordFromMainTable(namespace:bundleIdentifier:fromSource:)),
+                          with: currentNamespace,
+                          with: bundleIdentifier,
+                          with: RCNDBSource.remote.rawValue) // Use raw value for selector
+      }
+
+      private func handleUpdateState(forConfigNamespace currentNamespace: String, withEntries entries: [String: String]) {
+           // TODO: Log Debug - FIRLogDebug(kFIRLoggerRemoteConfig, @"I-RCN000058", ...)
+           // Clear DB first
+            // DB Interaction - Keep selector
+            dbManager.perform(#selector(RCNConfigDBManager.deleteRecordFromMainTable(namespace:bundleIdentifier:fromSource:)),
+                            with: currentNamespace,
+                            with: bundleIdentifier,
+                            with: RCNDBSource.remote.rawValue) // Use raw value for selector
+
+           // Update in-memory fetched config
+           var namespaceConfig: [String: RemoteConfigValue] = [:]
+           for (key, valueString) in entries {
+               guard let valueData = valueString.data(using: .utf8) else { continue }
+               let remoteValue = RemoteConfigValue(data: valueData, source: .remote)
+               namespaceConfig[key] = remoteValue
+               // Save to DB
+               let values: [Any] = [bundleIdentifier, currentNamespace, key, valueData]
+                // DB Interaction - Keep selector
+                dbManager.perform(#selector(RCNConfigDBManager.insertMainTable(values:fromSource:completionHandler:)),
+                                with: values,
+                                with: RCNDBSource.remote.rawValue, // Use raw value for selector
+                                with: nil) // No completion handler needed? Check ObjC
+           }
+           _fetchedConfig[currentNamespace] = namespaceConfig
+       }
+
+       private func handleUpdatePersonalization(_ metadata: [String: Any]?) {
+           guard let metadata = metadata else { return }
+           _fetchedPersonalization = metadata
+           // DB Interaction - Keep selector (needs correct method name)
+           // Assume: insertOrUpdatePersonalizationConfig(_:fromSource:) -> Bool
+           _ = dbManager.perform(#selector(RCNConfigDBManager.insertOrUpdatePersonalizationConfig(_:fromSource:)),
+                             with: metadata,
+                             with: RCNDBSource.remote.rawValue) // Use raw value for selector
+       }
+
+       private func handleUpdateRolloutFetchedMetadata(_ metadata: [[String: Any]]?) {
+           let metadataToSave = metadata ?? [] // Use empty array if nil
+           _fetchedRolloutMetadata = metadataToSave
+           // DB Interaction - Keep selector (needs correct method name)
+            // Assume: insertOrUpdateRolloutTable(key:value:completionHandler:)
+            dbManager.perform(#selector(RCNConfigDBManager.insertOrUpdateRolloutTable(key:value:completionHandler:)),
+                            with: DBKeys.rolloutFetchedMetadata,
+                            with: metadataToSave,
+                            with: nil) // No completion handler needed
+        }
+
+    // MARK: - Copy & Activation
+
+    /// Copy from a given dictionary to one of the data source (Active or Default).
+    @objc(copyFromDictionary:toSource:forNamespace:) // Match selector in RemoteConfig
+    func copyFromDictionary(_ fromDictionary: [String: Any]?, // Can be [String: NSObject] or [String: RemoteConfigValue]
+                            toSource DBSourceRawValue: Int,
+                            forNamespace FIRNamespace: String) {
+         _ = checkAndWaitForInitialDatabaseLoad() // Ensure loaded before copying
+
+         guard let DBSource = RCNDBSource(rawValue: DBSourceRawValue) else {
+              print("Error: Invalid DB Source \(DBSourceRawValue)")
+              return
+         }
+
+         guard let sourceDict = fromDictionary, !sourceDict.isEmpty else {
+             // TODO: Log Error - FIRLogError(kFIRLoggerRemoteConfig, @"I-RCN000007", ...)
+             return
+         }
+
+         let targetDict: inout [String: [String: RemoteConfigValue]] // Use inout for modification
+         let targetSource: RemoteConfigSource // For RemoteConfigValue creation
+
+         switch DBSource {
+         case .defaultValue:
+             targetDict = &_defaultConfig
+             targetSource = .defaultValue
+         case .active:
+             targetDict = &_activeConfig
+             targetSource = .remote // Active values originate from remote
+         case .remote: // Fetched
+             print("Warning: Copying to 'Fetched' source is not typical.")
+             targetDict = &_fetchedConfig
+             targetSource = .remote
+             // TODO: Log Warning - FIRLogWarning(kFIRLoggerRemoteConfig, @"I-RCN000008", ...)
+             // return // Original ObjC returned here, maybe prevent writing to fetched? Let's allow for now.
+         case .staticValue:
+              return // Cannot copy to static
+          @unknown default:
+              return
+         }
+
+         // Clear existing data for this namespace in the target
+          // DB Interaction - Keep selector
+          dbManager.perform(#selector(RCNConfigDBManager.deleteRecordFromMainTable(namespace:bundleIdentifier:fromSource:)),
+                          with: FIRNamespace,
+                          with: bundleIdentifier,
+                          with: DBSource.rawValue) // Use raw value for selector
+         targetDict[FIRNamespace]?.removeAll() // Clear in-memory dict
+
+         var namespaceConfig: [String: RemoteConfigValue] = [:]
+         // Check if the top-level dictionary has the namespace key (original assumption)
+        if let configData = sourceDict[FIRNamespace] as? [String: Any] {
+             processConfigData(configData, into: &namespaceConfig, targetSource: targetSource, FIRNamespace: FIRNamespace, DBSource: DBSource)
+        } else if let directConfigData = sourceDict as? [String: NSObject] { // Check if sourceDict IS the namespace dict (Defaults)
+             processConfigData(directConfigData, into: &namespaceConfig, targetSource: targetSource, FIRNamespace: FIRNamespace, DBSource: DBSource)
+        } else if let remoteValueDict = sourceDict as? [String: RemoteConfigValue] { // Check if sourceDict IS the namespace dict (Activation)
+             processConfigData(remoteValueDict, into: &namespaceConfig, targetSource: targetSource, FIRNamespace: FIRNamespace, DBSource: DBSource)
+        } else {
+             print("Warning: Could not interpret source dictionary structure for namespace '\(FIRNamespace)' during copy.")
+             return // Could not interpret the source dictionary
+         }
+
+         targetDict[FIRNamespace] = namespaceConfig // Update in-memory dictionary
+     }
+
+    /// Helper to process the inner config data dictionary (handles both NSObject and RemoteConfigValue)
+     private func processConfigData<T>(_ configData: [String: T],
+                                       into namespaceConfig: inout [String: RemoteConfigValue],
+                                       targetSource: RemoteConfigSource,
+                                       FIRNamespace: String,
+                                       DBSource: RCNDBSource) {
+         for (key, value) in configData {
+             let valueData: Data?
+             if let rcValue = value as? RemoteConfigValue { // Activation case
+                 valueData = rcValue.valueData // Use underlying data
+             } else if let nsObjectValue = value as? NSObject { // Defaults case
+                 // Convert NSObject to Data (mimic ObjC logic)
+                  if let data = nsObjectValue as? Data { valueData = data }
+                  else if let str = nsObjectValue as? String { valueData = str.data(using: .utf8) }
+                  else if let num = nsObjectValue as? NSNumber { valueData = num.stringValue.data(using: .utf8) }
+                  else if let date = nsObjectValue as? Date {
+                       let formatter = ISO8601DateFormatter() // Use standard format
+                       valueData = formatter.string(from: date).data(using: .utf8)
+                   } else if let array = nsObjectValue as? NSArray { // Use NSArray/NSDictionary for JSON check
+                       valueData = try? JSONSerialization.data(withJSONObject: array)
+                   } else if let dict = nsObjectValue as? NSDictionary {
+                       valueData = try? JSONSerialization.data(withJSONObject: dict)
+                   } else {
+                       // TODO: Log warning/error for unsupported default type?
+                       valueData = nil
+                   }
+             } else {
+                 valueData = nil // Unsupported type
+             }
+
+             guard let finalData = valueData else { continue }
+
+             let newValue = RemoteConfigValue(data: finalData, source: targetSource)
+             namespaceConfig[key] = newValue
+
+             // Save to DB
+              let values: [Any] = [bundleIdentifier, FIRNamespace, key, finalData]
+              // DB Interaction - Keep selector
+              dbManager.perform(#selector(RCNConfigDBManager.insertMainTable(values:fromSource:completionHandler:)),
+                              with: values,
+                              with: DBSource.rawValue, // Use raw value for selector
+                              with: nil)
+         }
+     }
+
+    /// Sets the fetched Personalization metadata to active and saves to DB.
+    @objc(activatePersonalization) // Match selector in RemoteConfig
+    func activatePersonalization() {
+        _ = checkAndWaitForInitialDatabaseLoad()
+        _activePersonalization = _fetchedPersonalization
+         // DB Interaction - Keep selector (needs correct method name)
+         _ = dbManager.perform(#selector(RCNConfigDBManager.insertOrUpdatePersonalizationConfig(_:fromSource:)),
+                           with: _activePersonalization,
+                           with: RCNDBSource.active.rawValue) // Use raw value for selector
+    }
+
+     /// Sets the fetched rollout metadata to active and saves to DB.
+     @objc(activateRolloutMetadata:) // Match selector in RemoteConfig
+     func activateRolloutMetadata(completionHandler: @escaping (Bool) -> Void) {
+         _ = checkAndWaitForInitialDatabaseLoad()
+         _activeRolloutMetadata = _fetchedRolloutMetadata
+         // DB Interaction - Keep selector (needs correct method name)
+          dbManager.perform(#selector(RCNConfigDBManager.insertOrUpdateRolloutTable(key:value:completionHandler:)),
+                          with: DBKeys.rolloutActiveMetadata,
+                          with: _activeRolloutMetadata,
+                          with: { (success: Bool, _: [String: Any]?) in // Adapt completion signature
+                              completionHandler(success)
+                          } as RCNDBCompletion?) // Cast closure type explicitly
+      }
+
+    // MARK: - Getters with Metadata / Diffing
+
+    /// Gets the active config and Personalization metadata for a namespace.
+    func getConfigAndMetadata(forNamespace FIRNamespace: String) -> [String: Any] {
+        _ = checkAndWaitForInitialDatabaseLoad()
+        let activeNamespaceConfig = _activeConfig[FIRNamespace] ?? [:]
+        // Return format matches ObjC version
+        return [
+            RCNFetchResponseKeyEntries: activeNamespaceConfig, // Value is [String: RemoteConfigValue]
+            RCNFetchResponseKeyPersonalizationMetadata: _activePersonalization
+        ]
+    }
+
+     /// Returns the updated parameters between fetched and active config for a namespace.
+     func getConfigUpdate(forNamespace FIRNamespace: String) -> RemoteConfigUpdate {
+         _ = checkAndWaitForInitialDatabaseLoad()
+
+         var updatedKeys = Set<String>()
+
+         let fetchedConfig = _fetchedConfig[FIRNamespace] ?? [:]
+         let activeConfig = _activeConfig[FIRNamespace] ?? [:]
+         let fetchedP13n = _fetchedPersonalization
+         let activeP13n = _activePersonalization
+         let fetchedRollouts = getParameterKeyToRolloutMetadata(rolloutMetadata: _fetchedRolloutMetadata)
+         let activeRollouts = getParameterKeyToRolloutMetadata(rolloutMetadata: _activeRolloutMetadata)
+
+         // Diff Config Values
+         for (key, fetchedValue) in fetchedConfig {
+             if let activeValue = activeConfig[key] {
+                 // Compare underlying data for equality
+                 if activeValue.valueData != fetchedValue.valueData {
+                     updatedKeys.insert(key)
+                 }
+             } else {
+                 updatedKeys.insert(key) // Added key
+             }
+         }
+         for key in activeConfig.keys {
+             if fetchedConfig[key] == nil {
+                 updatedKeys.insert(key) // Deleted key
+             }
+         }
+
+         // Diff Personalization (compare dictionaries)
+         // Note: This compares based on NSObject equality, might need deeper comparison if nested objects are complex.
+         let fetchedP13nNS = fetchedP13n as NSDictionary
+         let activeP13nNS = activeP13n as NSDictionary
+
+         for key in fetchedP13nNS.allKeys as? [String] ?? [] {
+             if activeP13nNS[key] == nil || !activeP13nNS[key]!.isEqual(fetchedP13nNS[key]!) {
+                 updatedKeys.insert(key)
+             }
+         }
+         for key in activeP13nNS.allKeys as? [String] ?? [] {
+             if fetchedP13nNS[key] == nil {
+                 updatedKeys.insert(key)
+             }
+         }
+
+         // Diff Rollouts (compare dictionaries derived from metadata)
+         for (key, fetchedRolloutValue) in fetchedRollouts {
+             if let activeRolloutValue = activeRollouts[key] {
+                 if !(activeRolloutValue as NSDictionary).isEqual(to: fetchedRolloutValue as! [AnyHashable : Any]) {
+                      updatedKeys.insert(key)
+                 }
+             } else {
+                 updatedKeys.insert(key) // Added key
+             }
+         }
+         for key in activeRollouts.keys {
+              if fetchedRollouts[key] == nil {
+                  updatedKeys.insert(key) // Deleted key
+              }
+          }
+
+
+         return RemoteConfigUpdate(updatedKeys: updatedKeys) // Use actual RemoteConfigUpdate init
+     }
+
+     /// Helper to transform rollout metadata array into a dictionary keyed by parameter key.
+     private func getParameterKeyToRolloutMetadata(rolloutMetadata: [[String: Any]]) -> [String: [String: String]] {
+         var result: [String: [String: String]] = [:]
+         for metadata in rolloutMetadata {
+             guard let rolloutId = metadata[RCNFetchResponseKeyRolloutID] as? String,
+                   let variantId = metadata[RCNFetchResponseKeyVariantID] as? String,
+                   let affectedKeys = metadata[RCNFetchResponseKeyAffectedParameterKeys] as? [String] else {
+                 continue
+             }
+             for key in affectedKeys {
+                 if result[key] == nil {
+                     result[key] = [:]
+                 }
+                 result[key]?[rolloutId] = variantId
+             }
+         }
+         return result
+     }
+
+    // MARK: - Placeholder Selectors (for @objc calls if needed)
+    @objc func initializationSuccessfulObjc() -> Bool { return initializationSuccessful() }
+
+    // DB Manager selectors (keep for placeholder interactions)
+    @objc func loadMain(bundleIdentifier id: String, completionHandler handler: Any?) {} // Adapt signature if needed
+    @objc func loadPersonalization(completionHandler handler: Any?) {} // Adapt signature if needed
+    @objc func deleteRecordFromMainTable(namespace ns: String, bundleIdentifier id: String, fromSource source: Int) {}
+    @objc func insertMainTable(values: [Any], fromSource source: Int, completionHandler handler: Any?) {}
+    @objc func insertOrUpdatePersonalizationConfig(_ config: [String: Any], fromSource source: Int) -> Bool { return false }
+    @objc func insertOrUpdateRolloutTable(key: String, value list: [[String: Any]], completionHandler handler: Any?) {}
+
+} // End of RCNConfigContent class
+
+
+// Constants used from RCNConfigConstants.h / RCNFetchResponse.h
+// TODO: Move to central constants file
+let RCNFetchResponseKeyState = "state"
+let RCNFetchResponseKeyStateNoChange = "NO_CHANGE"
+let RCNFetchResponseKeyStateEmptyConfig = "EMPTY_CONFIG"
+let RCNFetchResponseKeyStateNoTemplate = "NO_TEMPLATE"
+let RCNFetchResponseKeyStateUpdate = "UPDATE_CONFIG"
+let RCNFetchResponseKeyEntries = "entries"
+let RCNFetchResponseKeyPersonalizationMetadata = "personalizationMetadata"
+let RCNFetchResponseKeyRolloutMetadata = "rolloutMetadata"
+// Rollout metadata keys
+let RCNFetchResponseKeyRolloutID = "rolloutId"
+let RCNFetchResponseKeyVariantID = "variantId"
+let RCNFetchResponseKeyAffectedParameterKeys = "affectedParameterKeys"
+
+// Placeholder for RemoteConfigUpdate if not defined elsewhere
+//@objc(FIRRemoteConfigUpdate) public class RemoteConfigUpdate: NSObject {
+//  @objc public let updatedKeys: Set<String>
+//  init(updatedKeys: Set<String>) { self.updatedKeys = updatedKeys; super.init() }
+//}

FirebaseRemoteConfig/Sources/RCNConfigFetch.swift

@@ -0,0 +1,653 @@
+import Foundation
+import FirebaseCore
+import FirebaseInstallations // Required for FIS interaction
+// TODO: Import FIRAnalyticsInterop if it's defined in a separate module
+
+// --- Placeholder Types ---
+typealias RCNConfigDBManager = AnyObject // Keep placeholder
+typealias RCNConfigExperiment = AnyObject // Keep placeholder
+typealias FIRAnalyticsInterop = AnyObject // Keep placeholder
+typealias RCNDevice = AnyObject // Keep placeholder
+// Assume RCNConfigContent, RCNConfigSettingsInternal, RemoteConfigFetchStatus, RemoteConfigError, RemoteConfigUpdate, etc. are defined
+
+// --- Helper Types ---
+// Define Completion handler type definition used internally and by Realtime
+typealias RCNConfigFetchCompletion = (RemoteConfigFetchStatus, RemoteConfigUpdate?, Error?) -> Void
+// Define Key constant used in error dictionary
+let RemoteConfigThrottledEndTimeInSecondsKey = "error_throttled_end_time_seconds"
+
+
+// --- Constants ---
+// TODO: Move to central constants file
+private enum FetchConstants {
+    #if RCN_STAGING_SERVER
+    static let serverURLDomain = "https://staging-firebaseremoteconfig.sandbox.googleapis.com"
+    #else
+    static let serverURLDomain = "https://firebaseremoteconfig.googleapis.com"
+    #endif
+    static let serverURLVersion = "/v1"
+    static let serverURLProjects = "/projects/"
+    static let serverURLNamespaces = "/namespaces/"
+    static let serverURLQuery = ":fetch?"
+    static let serverURLKey = "key="
+
+    static let httpMethodPost = "POST"
+    static let contentTypeHeaderName = "Content-Type"
+    static let contentEncodingHeaderName = "Content-Encoding"
+    static let acceptEncodingHeaderName = "Accept-Encoding"
+    static let eTagHeaderName = "etag"
+    static let ifNoneMatchETagHeaderName = "if-none-match"
+    static let installationsAuthTokenHeaderName = "x-goog-firebase-installations-auth"
+    static let iOSBundleIdentifierHeaderName = "X-Ios-Bundle-Identifier"
+    static let fetchTypeHeaderName = "X-Firebase-RC-Fetch-Type"
+    static let baseFetchType = "BASE"
+    static let realtimeFetchType = "REALTIME"
+
+    static let contentTypeValueJSON = "application/json"
+    static let contentEncodingGzip = "gzip"
+
+    static let httpStatusOK = 200
+    static let httpStatusNotModified = 304 // Added for clarity, though not an error
+    static let httpStatusTooManyRequests = 429
+    static let httpStatusInternalError = 500
+    static let httpStatusServiceUnavailable = 503
+    static let httpStatusGatewayTimeout = 504 // Not explicitly handled in ObjC retry logic? Added for completeness
+
+    // Response Keys (assuming defined elsewhere, e.g., RCNConfigConstants)
+    static let responseKeyError = "error"
+    static let responseKeyErrorCode = "code"
+    static let responseKeyErrorStatus = "status"
+    static let responseKeyErrorMessage = "message"
+    static let responseKeyExperimentDescriptions = "experimentDescriptions"
+    static let responseKeyTemplateVersion = "templateVersionNumber" // Match UserDefault key?
+    static let responseKeyState = "state"
+    static let responseKeyEntries = "entries"
+    static let responseKeyPersonalizationMetadata = "personalizationMetadata"
+    static let responseKeyRolloutMetadata = "rolloutMetadata"
+
+    // State Values
+     static let responseKeyStateNoChange = "NO_CHANGE"
+     static let responseKeyStateEmptyConfig = "EMPTY_CONFIG"
+     static let responseKeyStateNoTemplate = "NO_TEMPLATE"
+     static let responseKeyStateUpdate = "UPDATE_CONFIG"
+
+}
+
+
+/// Handles the fetching of Remote Config data from the backend server.
+class RCNConfigFetch {
+
+    // Dependencies
+    private let content: RCNConfigContent
+    // DBManager is placeholder only used via Settings placeholder calls for now
+    // private let dbManager: RCNConfigDBManager
+    private let settings: RCNConfigSettingsInternal
+    private let analytics: FIRAnalyticsInterop? // Placeholder
+    private let experiment: RCNConfigExperiment? // Placeholder
+    private let lockQueue: DispatchQueue // Serial queue for synchronization
+    private let firebaseNamespace: String
+    private let options: FirebaseOptions
+
+    // Internal State
+    // Making fetchSession internal(set) allows tests to replace it
+    internal(set) var fetchSession: URLSession
+
+    // Publicly readable property for Realtime
+    var templateVersionNumber: String {
+        // Read directly from settings (which reads from UserDefaults)
+        return settings.lastFetchedTemplateVersion ?? "0"
+    }
+
+    // MARK: - Initialization
+
+    init(content: RCNConfigContent,
+         dbManager: RCNConfigDBManager, // Placeholder accepted
+         settings: RCNConfigSettingsInternal,
+         analytics: FIRAnalyticsInterop?, // Placeholder accepted
+         experiment: RCNConfigExperiment?, // Placeholder accepted
+         queue: DispatchQueue,
+         firebaseNamespace: String,
+         options: FirebaseOptions) {
+        self.content = content
+        // self.dbManager = dbManager // Not directly used by Fetch itself
+        self.settings = settings
+        self.analytics = analytics
+        self.experiment = experiment
+        self.lockQueue = queue
+        self.firebaseNamespace = firebaseNamespace
+        self.options = options
+        self.fetchSession = RCNConfigFetch.newFetchSession(settings: settings) // Initial session
+        // templateVersionNumber read dynamically from settings
+    }
+
+    deinit {
+        fetchSession.invalidateAndCancel()
+    }
+
+    // MARK: - Session Management
+
+    private static func newFetchSession(settings: RCNConfigSettingsInternal) -> URLSession {
+        let config = URLSessionConfiguration.default
+        config.timeoutIntervalForRequest = settings.fetchTimeout
+        config.timeoutIntervalForResource = settings.fetchTimeout
+        return URLSession(configuration: config)
+    }
+
+    /// Recreates the network session, typically after settings change.
+    @objc func recreateNetworkSession() { // Needs @objc for selector call from RemoteConfig
+        let oldSession = fetchSession
+        lockQueue.async { // Ensure thread safety if called concurrently
+            self.fetchSession = RCNConfigFetch.newFetchSession(settings: self.settings)
+            oldSession.invalidateAndCancel() // Invalidate after new one is ready
+        }
+    }
+
+    // MARK: - Public Fetch Methods
+
+    /// Fetches config data, respecting expiration duration and throttling.
+    /// Needs @objc for selector call from RemoteConfig
+    @objc func fetchConfig(withExpirationDuration expirationDuration: TimeInterval,
+                           completionHandler: ((RemoteConfigFetchStatus, Error?) -> Void)?) {
+        // Note: device context check requires RCNDevice translation
+        // let hasDeviceContextChanged = RCNDevice.hasDeviceContextChanged(settings.deviceContext, options.googleAppID ?? "")
+        let hasDeviceContextChanged = false // Placeholder
+
+        lockQueue.async { [weak self] in
+            guard let self = self else { return }
+
+            // 1. Check Expiration/Interval
+            if !self.settings.hasMinimumFetchIntervalElapsed(minimumInterval: expirationDuration), !hasDeviceContextChanged {
+                 // TODO: Log debug: FIRLogDebug(kFIRLoggerRemoteConfig, @"I-RCN000051", ...)
+                 self.reportCompletion(status: .success, update: nil, error: nil,
+                                       baseHandler: completionHandler, realtimeHandler: nil)
+                 return
+            }
+
+            // 2. Check Throttling
+            if self.settings.shouldThrottle(), !hasDeviceContextChanged {
+                 self.settings.lastFetchStatus = .throttled // Update status
+                 self.settings.lastFetchError = .throttled
+                 let throttledEndTime = self.settings.exponentialBackoffThrottleEndTime
+                 let error = NSError(domain: RemoteConfigConstants.errorDomain,
+                                     code: RemoteConfigError.throttled.rawValue,
+                                     userInfo: [RemoteConfigThrottledEndTimeInSecondsKey: throttledEndTime]) // Use actual key constant
+                  self.reportCompletion(status: .throttled, update: nil, error: error,
+                                        baseHandler: completionHandler, realtimeHandler: nil)
+                 return
+            }
+
+            // 3. Check In Progress
+            // Note: isFetchInProgress access needs external sync (lockQueue handles it here)
+            if self.settings.isFetchInProgress {
+                 // TODO: Log appropriately based on whether previous data exists
+                 // FIRLogDebug(kFIRLoggerRemoteConfig, @"I-RCN000052", ...) or
+                 // FIRLogError(kFIRLoggerRemoteConfig, @"I-RCN000053", ...)
+                 // Report previous status or failure
+                 let status = self.settings.lastFetchTimeInterval > 0 ? self.settings.lastFetchStatus : .failure
+                  self.reportCompletion(status: status, update: nil, error: nil, // Report no error for "in progress"
+                                        baseHandler: completionHandler, realtimeHandler: nil)
+                 return
+            }
+
+            // 4. Proceed with fetch
+            self.settings.isFetchInProgress = true
+            let fetchTypeHeader = "\(FetchConstants.baseFetchType)/1" // Simple count for now
+            self.refreshInstallationsToken(fetchTypeHeader: fetchTypeHeader,
+                                           baseHandler: completionHandler,
+                                           realtimeHandler: nil)
+        }
+    }
+
+    /// Fetches config immediately for Realtime, respecting throttling but not expiration.
+    func realtimeFetchConfig(fetchAttemptNumber: Int,
+                             completionHandler: @escaping RCNConfigFetchCompletion) { // Note: Escaping closure
+        // Note: device context check requires RCNDevice translation
+        // let hasDeviceContextChanged = RCNDevice.hasDeviceContextChanged(settings.deviceContext, options.googleAppID ?? "")
+         let hasDeviceContextChanged = false // Placeholder
+
+        lockQueue.async { [weak self] in
+            guard let self = self else { return }
+
+            // 1. Check Throttling
+            if self.settings.shouldThrottle(), !hasDeviceContextChanged {
+                self.settings.lastFetchStatus = .throttled
+                self.settings.lastFetchError = .throttled
+                let throttledEndTime = self.settings.exponentialBackoffThrottleEndTime
+                let error = NSError(domain: RemoteConfigConstants.errorDomain,
+                                    code: RemoteConfigError.throttled.rawValue,
+                                    userInfo: [RemoteConfigThrottledEndTimeInSecondsKey: throttledEndTime])
+                self.reportCompletion(status: .throttled, update: nil, error: error,
+                                      baseHandler: nil, realtimeHandler: completionHandler)
+                return
+            }
+
+            // 2. Proceed with fetch (no in-progress check for Realtime?)
+            // ObjC logic didn't explicitly check isFetchInProgress here, assuming Realtime manages its own calls.
+            // Let's keep isFetchInProgress set for consistency in FIS calls.
+             self.settings.isFetchInProgress = true
+             let fetchTypeHeader = "\(FetchConstants.realtimeFetchType)/\(fetchAttemptNumber)"
+             self.refreshInstallationsToken(fetchTypeHeader: fetchTypeHeader,
+                                            baseHandler: nil,
+                                            realtimeHandler: completionHandler)
+         }
+     }
+
+
+    // MARK: - Private Fetch Flow
+
+    private func getAppNameFromNamespace() -> String {
+        return firebaseNamespace.components(separatedBy: ":").last ?? ""
+    }
+
+    private func refreshInstallationsToken(fetchTypeHeader: String,
+                                           baseHandler: ((RemoteConfigFetchStatus, Error?) -> Void)?,
+                                           realtimeHandler: RCNConfigFetchCompletion?) {
+        guard let gcmSenderID = options.gcmSenderID, !gcmSenderID.isEmpty else {
+             let errorDesc = "Failed to get GCMSenderID"
+             // TODO: Log error: FIRLogError(...)
+             self.settings.isFetchInProgress = false // Reset flag
+             let error = NSError(domain: RemoteConfigConstants.errorDomain, code: RemoteConfigError.internalError.rawValue, userInfo: [NSLocalizedDescriptionKey: errorDesc])
+             self.reportCompletion(status: .failure, update: nil, error: error, baseHandler: baseHandler, realtimeHandler: realtimeHandler)
+             return
+        }
+
+        let appName = getAppNameFromNamespace()
+        guard let app = FirebaseApp.app(name: appName), let installations = Installations.installations(app: app) else {
+            let errorDesc = "Failed to get FirebaseApp or Installations instance for app: \(appName)"
+            // TODO: Log error: FIRLogError(...)
+             self.settings.isFetchInProgress = false // Reset flag
+             let error = NSError(domain: RemoteConfigConstants.errorDomain, code: RemoteConfigError.internalError.rawValue, userInfo: [NSLocalizedDescriptionKey: errorDesc])
+             self.reportCompletion(status: .failure, update: nil, error: error, baseHandler: baseHandler, realtimeHandler: realtimeHandler)
+             return
+        }
+
+        // TODO: Log debug: FIRLogDebug(kFIRLoggerRemoteConfig, @"I-RCN000039", ...)
+        installations.authToken { [weak self] tokenResult, error in
+             guard let self = self else { return }
+
+             guard let token = tokenResult?.authToken, error == nil else {
+                 let errorDesc = "Failed to get installations token. Error: \(error?.localizedDescription ?? "Unknown")"
+                 // TODO: Log error: FIRLogError(...)
+                 self.lockQueue.async { // Ensure state update is on queue
+                     self.settings.isFetchInProgress = false // Reset flag
+                      let wrappedError = NSError(domain: RemoteConfigConstants.errorDomain,
+                                                code: RemoteConfigError.internalError.rawValue,
+                                                userInfo: [NSLocalizedDescriptionKey: errorDesc, NSUnderlyingErrorKey: error as Any])
+                      self.reportCompletion(status: .failure, update: nil, error: wrappedError, baseHandler: baseHandler, realtimeHandler: realtimeHandler)
+                 }
+                 return
+             }
+
+             // Get Installation ID
+             installations.installationID { [weak self] identifier, error in
+                  guard let self = self else { return }
+
+                   // Dispatch back to queue for settings update & next step
+                   self.lockQueue.async {
+                       guard let identifier = identifier, error == nil else {
+                           let errorDesc = "Error getting Installation ID: \(error?.localizedDescription ?? "Unknown")"
+                            // TODO: Log error: FIRLogError(...)
+                            self.settings.isFetchInProgress = false // Reset flag
+                            let wrappedError = NSError(domain: RemoteConfigConstants.errorDomain,
+                                                       code: RemoteConfigError.internalError.rawValue,
+                                                       userInfo: [NSLocalizedDescriptionKey: errorDesc, NSUnderlyingErrorKey: error as Any])
+                            self.reportCompletion(status: .failure, update: nil, error: wrappedError, baseHandler: baseHandler, realtimeHandler: realtimeHandler)
+                           return
+                       }
+
+                       // TODO: Log info: FIRLogInfo(kFIRLoggerRemoteConfig, @"I-RCN000022", ...)
+                       self.settings.configInstallationsToken = token
+                       self.settings.configInstallationsIdentifier = identifier
+
+                       // Proceed to get user properties and make fetch call
+                       self.doFetchCall(fetchTypeHeader: fetchTypeHeader, baseHandler: baseHandler, realtimeHandler: realtimeHandler)
+                   }
+             }
+        }
+    }
+
+    private func doFetchCall(fetchTypeHeader: String,
+                             baseHandler: ((RemoteConfigFetchStatus, Error?) -> Void)?,
+                             realtimeHandler: RCNConfigFetchCompletion?) {
+        // Get Analytics User Properties (Placeholder interaction)
+        getAnalyticsUserProperties { [weak self] userProperties in
+             guard let self = self else { return }
+             // Ensure next step is on the queue
+             self.lockQueue.async {
+                 self.performFetch(userProperties: userProperties,
+                                   fetchTypeHeader: fetchTypeHeader,
+                                   baseHandler: baseHandler,
+                                   realtimeHandler: realtimeHandler)
+             }
+        }
+    }
+
+    // Placeholder for Analytics interaction
+    private func getAnalyticsUserProperties(completionHandler: @escaping ([String: Any]?) -> Void) {
+         // TODO: Log Debug: FIRLogDebug(kFIRLoggerRemoteConfig, @"I-RCN000060", ...)
+         if let analytics = self.analytics {
+             // analytics.getUserProperties(callback: completionHandler) // Requires translated interop
+             // Placeholder: Simulate async call returning empty properties
+              DispatchQueue.global().asyncAfter(deadline: .now() + 0.01) { // Simulate delay
+                 completionHandler([:])
+             }
+         } else {
+              completionHandler([:]) // No analytics, return empty immediately
+         }
+     }
+
+     private func performFetch(userProperties: [String: Any]?,
+                               fetchTypeHeader: String,
+                               baseHandler: ((RemoteConfigFetchStatus, Error?) -> Void)?,
+                               realtimeHandler: RCNConfigFetchCompletion?) {
+          // TODO: Log Debug: FIRLogDebug(kFIRLoggerRemoteConfig, @"I-RCN000061", ...)
+
+          guard let postBodyString = settings.nextRequestWithUserProperties(userProperties) else {
+              let errorDesc = "Failed to construct fetch request body."
+               self.settings.isFetchInProgress = false // Reset flag
+               let error = NSError(domain: RemoteConfigConstants.errorDomain, code: RemoteConfigError.internalError.rawValue, userInfo: [NSLocalizedDescriptionKey: errorDesc])
+               self.reportCompletion(status: .failure, update: nil, error: error, baseHandler: baseHandler, realtimeHandler: realtimeHandler)
+              return
+          }
+
+          guard let content = postBodyString.data(using: .utf8) else {
+               let errorDesc = "Failed to encode fetch request body to UTF8."
+               self.settings.isFetchInProgress = false // Reset flag
+               let error = NSError(domain: RemoteConfigConstants.errorDomain, code: RemoteConfigError.internalError.rawValue, userInfo: [NSLocalizedDescriptionKey: errorDesc])
+               self.reportCompletion(status: .failure, update: nil, error: error, baseHandler: baseHandler, realtimeHandler: realtimeHandler)
+               return
+           }
+
+
+          // Compress data
+          let compressedContent: Data?
+          do {
+               compressedContent = try (content as NSData).gzipped(withCompressionLevel: .defaultCompression) // Requires GULNSData+zlib logic port or library
+               // Placeholder for gzipped:
+               // compressedContent = content // Remove this line if gzip available
+          } catch {
+               let errorDesc = "Failed to compress the config request: \(error)"
+               // TODO: Log warning: FIRLogWarning(...)
+                self.settings.isFetchInProgress = false // Reset flag
+                let wrappedError = NSError(domain: RemoteConfigConstants.errorDomain,
+                                           code: RemoteConfigError.internalError.rawValue,
+                                           userInfo: [NSLocalizedDescriptionKey: errorDesc, NSUnderlyingErrorKey: error])
+                self.reportCompletion(status: .failure, update: nil, error: wrappedError, baseHandler: baseHandler, realtimeHandler: realtimeHandler)
+               return
+           }
+
+           guard let finalContent = compressedContent else {
+                let errorDesc = "Compressed content is nil."
+                 self.settings.isFetchInProgress = false // Reset flag
+                 let error = NSError(domain: RemoteConfigConstants.errorDomain, code: RemoteConfigError.internalError.rawValue, userInfo: [NSLocalizedDescriptionKey: errorDesc])
+                 self.reportCompletion(status: .failure, update: nil, error: error, baseHandler: baseHandler, realtimeHandler: realtimeHandler)
+                return
+            }
+
+
+          // TODO: Log Debug: FIRLogDebug(kFIRLoggerRemoteConfig, @"I-RCN000040", ...)
+          let task = createURLSessionDataTask(content: finalContent, fetchTypeHeader: fetchTypeHeader) {
+              [weak self] data, response, error in
+              // This completion handler runs on the URLSession's delegate queue (main by default)
+              // Ensure subsequent processing happens on our lockQueue
+               guard let self = self else { return }
+              // TODO: Log Debug: FIRLogDebug(kFIRLoggerRemoteConfig, @"I-RCN000050", ...)
+
+              self.lockQueue.async { // Dispatch processing to the lock queue
+                  self.settings.isFetchInProgress = false // Reset flag regardless of outcome
+
+                  self.handleFetchResponse(data: data, response: response, error: error,
+                                           baseHandler: baseHandler, realtimeHandler: realtimeHandler)
+              }
+          }
+          task.resume()
+      }
+
+     private func createURLSessionDataTask(content: Data,
+                                           fetchTypeHeader: String,
+                                           completionHandler: @escaping (Data?, URLResponse?, Error?) -> Void) -> URLSessionDataTask {
+         guard let url = constructServerURL() else {
+              // Should not happen if options are valid
+              fatalError("Could not construct server URL") // Or handle more gracefully
+          }
+          // TODO: Log Debug: FIRLogDebug(kFIRLoggerRemoteConfig, @"I-RCN000046", ...)
+
+          var request = URLRequest(url: url,
+                                   cachePolicy: .reloadIgnoringLocalCacheData,
+                                   timeoutInterval: fetchSession.configuration.timeoutIntervalForRequest) // Use session timeout
+         request.httpMethod = FetchConstants.httpMethodPost
+         request.setValue(FetchConstants.contentTypeValueJSON, forHTTPHeaderField: FetchConstants.contentTypeHeaderName)
+         request.setValue(settings.configInstallationsToken, forHTTPHeaderField: FetchConstants.installationsAuthTokenHeaderName)
+         request.setValue(settings.bundleIdentifier, forHTTPHeaderField: FetchConstants.iOSBundleIdentifierHeaderName) // Use settings bundle ID
+         request.setValue(FetchConstants.contentEncodingGzip, forHTTPHeaderField: FetchConstants.contentEncodingHeaderName)
+         request.setValue(FetchConstants.contentEncodingGzip, forHTTPHeaderField: FetchConstants.acceptEncodingHeaderName)
+         request.setValue(fetchTypeHeader, forHTTPHeaderField: FetchConstants.fetchTypeHeaderName)
+
+         if let etag = settings.lastETag {
+             request.setValue(etag, forHTTPHeaderField: FetchConstants.ifNoneMatchETagHeaderName)
+         }
+         request.httpBody = content
+
+         return fetchSession.dataTask(with: request, completionHandler: completionHandler)
+     }
+
+    // MARK: - Response Handling (on lockQueue)
+
+    private func handleFetchResponse(data: Data?, response: URLResponse?, error: Error?,
+                                     baseHandler: ((RemoteConfigFetchStatus, Error?) -> Void)?,
+                                     realtimeHandler: RCNConfigFetchCompletion?) {
+
+        let httpResponse = response as? HTTPURLResponse
+        let statusCode = httpResponse?.statusCode ?? -1 // Default to invalid status code
+
+        // 1. Handle Client-Side or HTTP Errors
+        if let error = error { // Client-side error (network, timeout, etc.)
+            handleFetchError(error: error, statusCode: statusCode, baseHandler: baseHandler, realtimeHandler: realtimeHandler)
+            return
+        }
+        if statusCode != FetchConstants.httpStatusOK {
+            // Check for 304 Not Modified *before* treating other non-200 as errors
+            if statusCode == FetchConstants.httpStatusNotModified {
+                 // TODO: Log info - Not Modified
+                 settings.updateMetadataWithFetchSuccessStatus(true, templateVersion: settings.lastFetchedTemplateVersion) // Keep old version
+                 let update = content.getConfigUpdate(forNamespace: firebaseNamespace) // Calculate diff anyway?
+                 self.reportCompletion(status: .success, update: update, error: nil, baseHandler: baseHandler, realtimeHandler: realtimeHandler)
+                 return
+            }
+            // Handle other non-200, non-304 statuses as errors
+            handleFetchError(error: nil, statusCode: statusCode, baseHandler: baseHandler, realtimeHandler: realtimeHandler)
+            return
+        }
+
+        // 2. Handle Successful Fetch (Status OK - 200)
+        guard let responseData = data else {
+            // TODO: Log info - No data in successful response
+            let update = content.getConfigUpdate(forNamespace: firebaseNamespace) // Still calculate diff
+             self.reportCompletion(status: .success, update: update, error: nil, baseHandler: baseHandler, realtimeHandler: realtimeHandler)
+            return
+        }
+
+        // 3. Parse JSON Response
+        let parsedResponse: [String: Any]?
+        do {
+             parsedResponse = try JSONSerialization.jsonObject(with: responseData, options: .mutableContainers) as? [String: Any]
+        } catch let parseError {
+             // TODO: Log error - JSON parsing failure
+             let wrappedError = NSError(domain: RemoteConfigConstants.errorDomain, code: RemoteConfigError.internalError.rawValue,
+                                        userInfo: [NSLocalizedDescriptionKey: "Failed to parse fetch response JSON.", NSUnderlyingErrorKey: parseError])
+             self.reportCompletion(status: .failure, update: nil, error: wrappedError, baseHandler: baseHandler, realtimeHandler: realtimeHandler)
+             return
+        }
+
+        // 4. Check for Server-Side Error in JSON Payload
+        if let responseDict = parsedResponse,
+            let serverError = responseDict[FetchConstants.responseKeyError] as? [String: Any] {
+             let errorDesc = formatServerError(serverError)
+             // TODO: Log error - Server returned error
+             let wrappedError = NSError(domain: RemoteConfigConstants.errorDomain, code: RemoteConfigError.internalError.rawValue, userInfo: [NSLocalizedDescriptionKey: errorDesc])
+             self.reportCompletion(status: .failure, update: nil, error: wrappedError, baseHandler: baseHandler, realtimeHandler: realtimeHandler)
+            return
+        }
+
+        // 5. Process Successful Fetch Data
+        if let fetchedData = parsedResponse {
+            // Update content (triggers DB writes via selectors for now)
+            content.updateConfigContentWithResponse(fetchedData, forNamespace: firebaseNamespace)
+
+             // Update experiments (Placeholder interaction)
+             if let experimentDescriptions = fetchedData[FetchConstants.responseKeyExperimentDescriptions] {
+                 // TODO: Ensure experimentDescriptions is correct type for experiment object
+                 experiment?.perform(#selector(RCNConfigExperiment.updateExperiments(response:)), with: experimentDescriptions)
+             }
+
+            // Update ETag if changed
+            if let latestETag = httpResponse?.allHeaderFields[FetchConstants.eTagHeaderName] as? String {
+                 if settings.lastETag != latestETag {
+                      settings.setLastETag(latestETag) // Updates UserDefaults
+                 }
+             } else {
+                 // No ETag received? Clear local ETag? ObjC didn't explicitly clear.
+                 // settings.setLastETag(nil)
+             }
+
+             // Update settings metadata (DB interaction via selector)
+             let newVersion = getTemplateVersionNumber(from: fetchedData)
+             settings.updateMetadataWithFetchSuccessStatus(true, templateVersion: newVersion)
+
+         } else {
+              // TODO: Log Debug - Empty response?
+              // Still treat as success, but update metadata? ObjC didn't explicitly handle empty dict case here.
+               settings.updateMetadataWithFetchSuccessStatus(true, templateVersion: settings.lastFetchedTemplateVersion) // Keep old version?
+         }
+
+         // 6. Report Success
+         let update = content.getConfigUpdate(forNamespace: firebaseNamespace)
+         self.reportCompletion(status: .success, update: update, error: nil, baseHandler: baseHandler, realtimeHandler: realtimeHandler)
+    }
+
+     private func handleFetchError(error: Error?, statusCode: Int,
+                                  baseHandler: ((RemoteConfigFetchStatus, Error?) -> Void)?,
+                                  realtimeHandler: RCNConfigFetchCompletion?) {
+          // Update metadata (DB interaction via selector)
+          settings.updateMetadataWithFetchSuccessStatus(false, templateVersion: nil)
+
+          var reportedError = error
+          var reportedStatus = RemoteConfigFetchStatus.failure
+          var errorDomain = error?.domain ?? RemoteConfigConstants.errorDomain
+          var errorCode = error?.code ?? RemoteConfigError.internalError.rawValue
+
+          // Check for retryable HTTP status codes and update throttling/status/error
+          let retryableStatusCodes = [
+              FetchConstants.httpStatusTooManyRequests,
+              FetchConstants.httpStatusInternalError, // 500
+              FetchConstants.httpStatusServiceUnavailable // 503
+              // Add 504? ObjC didn't include it in backoff trigger check.
+          ]
+          if retryableStatusCodes.contains(statusCode) {
+               settings.updateExponentialBackoffTime() // Update backoff window
+               if settings.shouldThrottle() { // Check if *now* we are throttled
+                    reportedStatus = .throttled
+                    errorCode = RemoteConfigError.throttled.rawValue
+                    errorDomain = RemoteConfigConstants.errorDomain // Ensure RC domain
+                    let throttledEndTime = settings.exponentialBackoffThrottleEndTime
+                    reportedError = NSError(domain: errorDomain, code: errorCode,
+                                            userInfo: [NSLocalizedDescriptionKey: "Fetch throttled. Backoff interval has not passed.",
+                                                       RemoteConfigThrottledEndTimeInSecondsKey: throttledEndTime])
+               }
+           }
+
+           // Ensure reported error is constructed if nil
+           if reportedError == nil {
+               // Handle 304 separately as it's not a true error in the same sense
+               if statusCode == FetchConstants.httpStatusNotModified {
+                    // This path shouldn't be reached based on logic in handleFetchResponse.
+                    // Log a warning if we somehow get here.
+                    // TODO: Log warning
+                    reportedStatus = .success // Technically not an error, but no update happened.
+                    reportedError = nil // Clear any potential error if it was just 304.
+               } else {
+                   let errorDesc = "Fetch failed with HTTP status code: \(statusCode)"
+                   // TODO: Log Error
+                   reportedError = NSError(domain: errorDomain, code: errorCode,
+                                           userInfo: [NSLocalizedDescriptionKey: errorDesc])
+               }
+            }
+
+            // Update settings status *after* potential throttling check
+            settings.lastFetchStatus = reportedStatus
+            settings.lastFetchError = RemoteConfigError(rawValue: errorCode) ?? .unknown
+
+            self.reportCompletion(status: reportedStatus, update: nil, error: reportedError,
+                                  baseHandler: baseHandler, realtimeHandler: realtimeHandler)
+      }
+
+    // MARK: - Helpers
+
+    private func constructServerURL() -> URL? {
+        guard let projectID = options.projectID, !projectID.isEmpty,
+              let apiKey = options.apiKey, !apiKey.isEmpty else {
+             // TODO: Log error - Missing projectID or apiKey
+             return nil
+        }
+
+        // Extract namespace part from "namespace:appName"
+        let namespacePart = firebaseNamespace.components(separatedBy: ":").first ?? firebaseNamespace
+
+        let urlString = FetchConstants.serverURLDomain +
+                        FetchConstants.serverURLVersion +
+                        FetchConstants.serverURLProjects + projectID +
+                        FetchConstants.serverURLNamespaces + namespacePart +
+                        FetchConstants.serverURLQuery +
+                        FetchConstants.serverURLKey + apiKey
+        return URL(string: urlString)
+    }
+
+    private func getTemplateVersionNumber(from fetchedConfig: [String: Any]?) -> String {
+        return fetchedConfig?[FetchConstants.responseKeyTemplateVersion] as? String ?? "0"
+    }
+
+     private func formatServerError(_ errorDict: [String: Any]) -> String {
+         var errStr = "Fetch Failure: Server returned error: "
+         if let code = errorDict[FetchConstants.responseKeyErrorCode] { errStr += "Code: \(code). " }
+         if let status = errorDict[FetchConstants.responseKeyErrorStatus] { errStr += "Status: \(status). " }
+         if let message = errorDict[FetchConstants.responseKeyErrorMessage] { errStr += "Message: \(message)" }
+         return errStr
+     }
+
+    /// Dispatches completion handlers to the main queue.
+    private func reportCompletion(status: RemoteConfigFetchStatus,
+                                  update: RemoteConfigUpdate?, // Included for realtime handler
+                                  error: Error?,
+                                  baseHandler: ((RemoteConfigFetchStatus, Error?) -> Void)?,
+                                  realtimeHandler: RCNConfigFetchCompletion?) {
+        DispatchQueue.main.async {
+             baseHandler?(status, error)
+             realtimeHandler?(status, update, error) // Pass update only to realtime handler
+         }
+    }
+
+    // MARK: - Placeholder Selectors
+    // Selectors needed for RemoteConfig interaction via perform(#selector(...))
+    @objc private func fetchConfig(withExpirationDuration duration: TimeInterval, completionHandler handler: Any?) {}
+
+    // Selectors for RCNConfigExperiment (placeholder)
+    @objc private func updateExperiments(response: Any?) {}
+}
+
+
+// Define GULNSData+zlib methods or include a library
+extension NSData {
+     @objc func gzipped(withCompressionLevel level: Int32 = -1) throws -> Data {
+         // Placeholder - Requires porting or library
+         print("Warning: gzipped compression not implemented.")
+         return self as Data
+     }
+ }
+
+// Assume these types are defined elsewhere
+// @objc(FIRRemoteConfigFetchStatus) public enum RemoteConfigFetchStatus: Int { ... }
+// @objc(FIRRemoteConfigError) public enum RemoteConfigError: Int { ... }
+// @objc(FIRRemoteConfigUpdate) public class RemoteConfigUpdate: NSObject { ... }
+// class RCNConfigContent { ... }
+// class RCNConfigSettingsInternal { ... }
+// etc.

FirebaseRemoteConfig/Sources/RCNConfigSettingsInternal.swift

@@ -0,0 +1,578 @@
+import Foundation
+import FirebaseCore // For FIRLogger
+
+// --- Placeholder Types ---
+// These will be replaced by actual translated classes later.
+typealias RCNConfigDBManager = AnyObject
+// RCNUserDefaultsManager is now translated
+typealias RCNDevice = AnyObject // Assuming RCNDevice provides static methods like RCNDevice.deviceCountry()
+
+// --- Constants ---
+// TODO: Move these to a central constants file
+private enum Constants {
+    // From RCNConfigSettings.m
+    static let exponentialBackoffMinimumInterval: TimeInterval = 120 // 2 mins
+    static let exponentialBackoffMaximumInterval: TimeInterval = 14400 // 4 hours (60 * 60 * 4)
+
+    // From RCNConfigConstants.h (assuming defaults if not found elsewhere)
+    static let defaultMinimumFetchInterval: TimeInterval = 43200.0 // 12 hours
+    static let httpDefaultConnectionTimeout: TimeInterval = 60.0
+
+    // Keys from RCNConfigDBManager.h (assuming)
+    static let keyDeviceContext = "device_context"
+    static let keyAppContext = "app_context"
+    static let keySuccessFetchTime = "success_fetch_time"
+    static let keyFailureFetchTime = "failure_fetch_time"
+    static let keyLastFetchStatus = "last_fetch_status"
+    static let keyLastFetchError = "last_fetch_error"
+    static let keyLastApplyTime = "last_apply_time"
+    static let keyLastSetDefaultsTime = "last_set_defaults_time"
+    static let keyBundleIdentifier = "bundle_identifier"
+    static let keyNamespace = "namespace"
+    static let keyFetchTime = "fetch_time"
+    static let keyDigestPerNamespace = "digest_per_namespace" // Backwards compat only
+
+    // Keys from RCNUserDefaultsManager.h (assuming)
+    // Define as needed when RCNUserDefaultsManager is translated
+
+    // Keys from RCNConfigFetch.m (assuming) - for request body
+    static let analyticsFirstOpenTimePropertyName = "_fot"
+}
+
+/// Enum to map RCNUpdateOption to Swift enum, primarily for DB interaction selectors
+enum RCNUpdateOption: Int {
+    case applyTime = 0
+    case defaultTime = 1
+}
+
+
+/// Internal class containing settings, state, and metadata for a Remote Config instance.
+/// Mirrors the Objective-C class RCNConfigSettings.
+/// This class is intended for internal use within the FirebaseRemoteConfig module.
+/// Note: This class is not inherently thread-safe for all properties.
+/// The original Objective-C implementation relied on a serial dispatch queue (`_queue` in FIRRemoteConfig)
+/// for synchronization when accessing instances of this class. Callers (like RemoteConfig.swift)
+/// must ensure thread-safe access. Properties marked `atomic` in ObjC are handled here
+/// using basic Swift atomicity or placeholders requiring external locking.
+class RCNConfigSettingsInternal { // Not public
+
+    // MARK: - Properties (Mirrored from RCNConfigSettings.h and .m)
+
+    // Settable Public Settings
+    var minimumFetchInterval: TimeInterval
+    var fetchTimeout: TimeInterval
+
+    // Readonly Properties (or internally set)
+    let bundleIdentifier: String
+    private(set) var successFetchTimes: [TimeInterval] // Equivalent to NSMutableArray
+    private(set) var failureFetchTimes: [TimeInterval] // Equivalent to NSMutableArray
+    private(set) var deviceContext: [String: Any] // Equivalent to NSMutableDictionary
+    var customVariables: [String: Any] // Equivalent to NSMutableDictionary, settable internally
+
+    private(set) var lastFetchStatus: RemoteConfigFetchStatus
+    private(set) var lastFetchError: RemoteConfigError // Make sure RemoteConfigError enum is defined
+    private(set) var lastApplyTimeInterval: TimeInterval
+    private(set) var lastSetDefaultsTimeInterval: TimeInterval
+
+    // Properties managed via RCNUserDefaultsManager
+    // Use direct access via userDefaultsManager instance below
+    var lastETag: String? {
+        get { userDefaultsManager.lastETag }
+        set { userDefaultsManager.lastETag = newValue }
+    }
+    var lastETagUpdateTime: TimeInterval {
+        get { userDefaultsManager.lastETagUpdateTime }
+        set { userDefaultsManager.lastETagUpdateTime = newValue }
+    }
+    var lastFetchTimeInterval: TimeInterval {
+        get { userDefaultsManager.lastFetchTime }
+        set { userDefaultsManager.lastFetchTime = newValue }
+    }
+    var lastFetchedTemplateVersion: String? { // Defaulted to "0" in RCNUserDefaultsManager getter if nil
+        get { userDefaultsManager.lastFetchedTemplateVersion }
+        set { userDefaultsManager.lastFetchedTemplateVersion = newValue }
+    }
+    var lastActiveTemplateVersion: String? { // Defaulted to "0" in RCNUserDefaultsManager getter if nil
+        get { userDefaultsManager.lastActiveTemplateVersion }
+        set { userDefaultsManager.lastActiveTemplateVersion = newValue }
+    }
+    var realtimeExponentialBackoffRetryInterval: TimeInterval {
+        get { userDefaultsManager.currentRealtimeThrottlingRetryIntervalSeconds }
+        set { userDefaultsManager.currentRealtimeThrottlingRetryIntervalSeconds = newValue }
+    }
+    var realtimeExponentialBackoffThrottleEndTime: TimeInterval {
+        get { userDefaultsManager.realtimeThrottleEndTime }
+        set { userDefaultsManager.realtimeThrottleEndTime = newValue }
+    }
+    var realtimeRetryCount: Int {
+        get { userDefaultsManager.realtimeRetryCount }
+        set { userDefaultsManager.realtimeRetryCount = newValue }
+    }
+    var customSignals: [String: String] { // Defaulted to [:] in RCNUserDefaultsManager getter if nil
+        get { userDefaultsManager.customSignals }
+        set { userDefaultsManager.customSignals = newValue }
+    }
+
+    // Throttling Properties
+    var exponentialBackoffRetryInterval: TimeInterval // Not stored in userDefaults
+    private(set) var exponentialBackoffThrottleEndTime: TimeInterval = 0 // Not stored in userDefaults
+
+    // Installation ID and Token (marked atomic in ObjC)
+    // Using basic String properties. Synchronization handled externally by RemoteConfig queue.
+    var configInstallationsIdentifier: String?
+    var configInstallationsToken: String?
+
+    // Fetch In Progress Flag (marked atomic in ObjC)
+    // Needs external synchronization (e.g., RemoteConfig queue)
+    var isFetchInProgress: Bool = false
+
+    // Dependencies (Placeholders - initialized in init)
+    private let dbManager: RCNConfigDBManager
+    private let userDefaultsManager: RCNUserDefaultsManager // Use actual translated class
+    private let firebaseNamespace: String // Fully qualified (namespace:appName)
+    private let googleAppID: String
+
+    // MARK: - Initializer
+
+    init(databaseManager: RCNConfigDBManager,
+         namespace: String, // Fully qualified namespace
+         firebaseAppName: String,
+         googleAppID: String) {
+
+        self.dbManager = databaseManager
+        self.firebaseNamespace = namespace
+        self.googleAppID = googleAppID
+
+        // Bundle ID
+        if let bundleID = Bundle.main.bundleIdentifier, !bundleID.isEmpty {
+            self.bundleIdentifier = bundleID
+        } else {
+             self.bundleIdentifier = ""
+             // TODO: Log warning: FIRLogNotice(kFIRLoggerRemoteConfig, @"I-RCN000038", ...)
+        }
+
+        // Initialize User Defaults Manager (Use actual translated init)
+        self.userDefaultsManager = RCNUserDefaultsManager(appName: firebaseAppName, bundleID: bundleIdentifier, firebaseNamespace: namespace)
+
+        // Check if DB is new and reset UserDefaults if needed
+        // DB interaction still uses selector
+        let isNewDB = self.dbManager.perform(#selector(RCNConfigDBManager.isNewDatabase))?.takeUnretainedValue() as? Bool ?? false
+        if isNewDB {
+             // TODO: Log notice: FIRLogNotice(kFIRLoggerRemoteConfig, @"I-RCN000072", ...)
+             self.userDefaultsManager.resetUserDefaults() // Call actual method
+        }
+
+        // Initialize properties with default/loaded values
+        self.minimumFetchInterval = Constants.defaultMinimumFetchInterval
+        self.fetchTimeout = Constants.httpDefaultConnectionTimeout
+
+        self.deviceContext = [:]
+        self.customVariables = [:]
+        self.successFetchTimes = []
+        self.failureFetchTimes = []
+        self.lastFetchStatus = .noFetchYet
+        self.lastFetchError = .unknown // Assuming .unknown is 0 or default
+        self.lastApplyTimeInterval = 0
+        self.lastSetDefaultsTimeInterval = 0
+
+        // Properties read from UserDefaults are now accessed via computed properties
+        // self.lastFetchedTemplateVersion = self.userDefaultsManager.lastFetchedTemplateVersion
+        // etc...
+
+        // Initialize non-persistent state
+        self.exponentialBackoffRetryInterval = Constants.exponentialBackoffMinimumInterval // Default start
+        self.isFetchInProgress = false
+
+        // Load persistent metadata from DB after initializing defaults
+        // DB interaction still uses selector
+        // This might overwrite some defaults like lastFetchStatus etc.
+        self.loadConfigFromMetadataTable()
+
+        // Note: lastETag, lastETagUpdateTime, lastFetchTimeInterval, customSignals are
+        // also now handled by computed properties reading from userDefaultsManager.
+    }
+
+    // MARK: - UserDefaults Interaction (via RCNUserDefaultsManager)
+    // Methods below are now simplified or removed as interaction happens via computed properties.
+
+    // Setter updates UserDefaults directly via computed property setter
+    func updateLastFetchTimeInterval(_ timeInterval: TimeInterval) {
+        self.lastFetchTimeInterval = timeInterval
+    }
+
+    // Setter updates UserDefaults directly via computed property setter
+    func updateLastFetchedTemplateVersion(_ version: String?) {
+         self.lastFetchedTemplateVersion = version
+    }
+
+    // Setter updates UserDefaults directly via computed property setter
+    func updateLastActiveTemplateVersionInUserDefaults(_ version: String?) {
+         self.lastActiveTemplateVersion = version
+    }
+
+    // Setter updates UserDefaults directly via computed property setter
+    func updateRealtimeExponentialBackoffRetryInterval(_ interval: TimeInterval) {
+         self.realtimeExponentialBackoffRetryInterval = interval
+    }
+
+    // Setter updates UserDefaults directly via computed property setter
+     func updateRealtimeThrottleEndTime(_ time: TimeInterval) {
+         self.realtimeExponentialBackoffThrottleEndTime = time
+     }
+
+    // Setter updates UserDefaults directly via computed property setter
+    func updateRealtimeRetryCount(_ count: Int) {
+        self.realtimeRetryCount = count
+    }
+
+    // Setter updates UserDefaults directly via computed property setter
+    func updateCustomSignals(_ signals: [String: String]) {
+        self.customSignals = signals
+    }
+
+    // Internal setters for properties usually read from userDefaults
+    func setLastETag(_ etag: String?) {
+        let now = Date().timeIntervalSince1970
+        // Set timestamp first, then etag via computed property setters
+        self.lastETagUpdateTime = now
+        self.lastETag = etag
+    }
+
+
+    // MARK: - Load/Save Metadata (DB Interaction via RCNConfigDBManager)
+
+    @discardableResult
+    func loadConfigFromMetadataTable() -> [String: Any]? {
+        // DB Interaction - Keep selector
+        // loadMetadataWithBundleIdentifier:namespace:
+        guard let metadata = dbManager.perform(#selector(RCNConfigDBManager.loadMetadata(withBundleIdentifier:namespace:)),
+                                                with: bundleIdentifier,
+                                                with: firebaseNamespace)?.takeUnretainedValue() as? [String: Any]
+        else {
+            return nil
+        }
+
+        // Parse metadata dictionary and update self properties
+        if let contextData = metadata[Constants.keyDeviceContext] as? Data,
+           let contextDict = try? JSONSerialization.jsonObject(with: contextData) as? [String: Any] {
+            self.deviceContext = contextDict
+        }
+        if let appContextData = metadata[Constants.keyAppContext] as? Data,
+           let appContextDict = try? JSONSerialization.jsonObject(with: appContextData) as? [String: Any] {
+            self.customVariables = appContextDict
+        }
+        if let successTimesData = metadata[Constants.keySuccessFetchTime] as? Data,
+           let successTimesArray = try? JSONSerialization.jsonObject(with: successTimesData) as? [TimeInterval] {
+             self.successFetchTimes = successTimesArray
+        }
+        if let failureTimesData = metadata[Constants.keyFailureFetchTime] as? Data,
+           let failureTimesArray = try? JSONSerialization.jsonObject(with: failureTimesData) as? [TimeInterval] {
+             self.failureFetchTimes = failureTimesArray
+        }
+        if let statusString = metadata[Constants.keyLastFetchStatus] as? String, let statusInt = Int(statusString), let status = RemoteConfigFetchStatus(rawValue: statusInt) {
+            self.lastFetchStatus = status
+        }
+        if let errorString = metadata[Constants.keyLastFetchError] as? String, let errorInt = Int(errorString), let error = RemoteConfigError(rawValue: errorInt) {
+            self.lastFetchError = error
+        }
+        if let applyTimeString = metadata[Constants.keyLastApplyTime] as? String, let applyTime = TimeInterval(applyTimeString) {
+             self.lastApplyTimeInterval = applyTime
+        } else if let applyTimeNum = metadata[Constants.keyLastApplyTime] as? NSNumber { // Handle potential NSNumber storage
+             self.lastApplyTimeInterval = applyTimeNum.doubleValue
+        }
+         if let defaultTimeString = metadata[Constants.keyLastSetDefaultsTime] as? String, let defaultTime = TimeInterval(defaultTimeString) {
+             self.lastSetDefaultsTimeInterval = defaultTime
+         } else if let defaultTimeNum = metadata[Constants.keyLastSetDefaultsTime] as? NSNumber { // Handle potential NSNumber storage
+             self.lastSetDefaultsTimeInterval = defaultTimeNum.doubleValue
+         }
+        // Note: Properties read from UserDefaults (e.g., lastFetchTimeInterval) are handled by computed properties now.
+
+        return metadata
+    }
+
+    func updateMetadataTable() {
+        // DB Interaction - Keep selector
+        // deleteRecordWithBundleIdentifier:namespace:
+         _ = dbManager.perform(#selector(RCNConfigDBManager.deleteRecord(withBundleIdentifier:namespace:)),
+                               with: bundleIdentifier,
+                               with: firebaseNamespace)
+
+        // Serialize data - Requires properties to be valid for JSONSerialization
+        guard let appContextData = try? JSONSerialization.data(withJSONObject: customVariables) else {
+             // TODO: Log error: FIRLogError(kFIRLoggerRemoteConfig, @"I-RCN000028", ...)
+             return
+        }
+        guard let deviceContextData = try? JSONSerialization.data(withJSONObject: deviceContext) else {
+             // TODO: Log error: FIRLogError(kFIRLoggerRemoteConfig, @"I-RCN000029", ...)
+             return
+        }
+         // Backward compat only
+        guard let digestPerNamespaceData = try? JSONSerialization.data(withJSONObject: [:]) else { return }
+        guard let successTimeData = try? JSONSerialization.data(withJSONObject: successFetchTimes) else {
+             // TODO: Log error: FIRLogError(kFIRLoggerRemoteConfig, @"I-RCN000031", ...)
+             return
+        }
+        guard let failureTimeData = try? JSONSerialization.data(withJSONObject: failureFetchTimes) else {
+             // TODO: Log error: FIRLogError(kFIRLoggerRemoteConfig, @"I-RCN000032", ...)
+             return
+        }
+
+        // Read lastFetchTimeInterval directly via computed property
+        let columnNameToValue: [String: Any] = [
+            Constants.keyBundleIdentifier: bundleIdentifier,
+            Constants.keyNamespace: firebaseNamespace,
+            Constants.keyFetchTime: self.lastFetchTimeInterval, // Read directly
+            Constants.keyDigestPerNamespace: digestPerNamespaceData,
+            Constants.keyDeviceContext: deviceContextData,
+            Constants.keyAppContext: appContextData,
+            Constants.keySuccessFetchTime: successTimeData,
+            Constants.keyFailureFetchTime: failureTimeData,
+            Constants.keyLastFetchStatus: String(lastFetchStatus.rawValue), // Store as String like ObjC
+            Constants.keyLastFetchError: String(lastFetchError.rawValue), // Store as String like ObjC
+            Constants.keyLastApplyTime: lastApplyTimeInterval, // Store as TimeInterval/Double
+            Constants.keyLastSetDefaultsTime: lastSetDefaultsTimeInterval // Store as TimeInterval/Double
+        ]
+
+        // DB Interaction - Keep selector
+        // insertMetadataTableWithValues:completionHandler:
+        dbManager.perform(#selector(RCNConfigDBManager.insertMetadataTable(withValues:completionHandler:)),
+                        with: columnNameToValue,
+                        with: nil) // No completion handler in original call
+    }
+
+    // Specific update methods (used by FIRRemoteConfig setters)
+    func updateLastApplyTimeIntervalInDB(_ timeInterval: TimeInterval) {
+        self.lastApplyTimeInterval = timeInterval
+        // DB Interaction - Keep selector
+        // updateMetadataWithOption:namespace:values:completionHandler:
+        dbManager.perform(#selector(RCNConfigDBManager.updateMetadata(withOption:namespace:values:completionHandler:)),
+                        with: RCNUpdateOption.applyTime.rawValue, // Use enum raw value
+                        with: firebaseNamespace,
+                        with: [timeInterval],
+                        with: nil)
+    }
+
+     func updateLastSetDefaultsTimeIntervalInDB(_ timeInterval: TimeInterval) {
+         self.lastSetDefaultsTimeInterval = timeInterval
+         // DB Interaction - Keep selector
+         // updateMetadataWithOption:namespace:values:completionHandler:
+         dbManager.perform(#selector(RCNConfigDBManager.updateMetadata(withOption:namespace:values:completionHandler:)),
+                         with: RCNUpdateOption.defaultTime.rawValue, // Use enum raw value
+                         with: firebaseNamespace,
+                         with: [timeInterval],
+                         with: nil)
+     }
+
+
+    // MARK: - State Update Methods
+
+    func updateMetadataWithFetchSuccessStatus(_ fetchSuccess: Bool, templateVersion: String?) {
+        // TODO: Log debug: FIRLogDebug(kFIRLoggerRemoteConfig, @"I-RCN000056", ...)
+        updateFetchTimeWithSuccessFetch(fetchSuccess)
+        lastFetchStatus = fetchSuccess ? .success : .failure
+        lastFetchError = fetchSuccess ? .unknown : .internalError // Assuming internalError for generic failure
+
+        if fetchSuccess {
+            updateLastFetchTimeInterval(Date().timeIntervalSince1970) // Updates UserDefaults via computed property
+            // TODO: Get device context - Requires RCNDevice translation
+            // deviceContext = FIRRemoteConfigDeviceContextWithProjectIdentifier(_googleAppID);
+            deviceContext = getDeviceContextPlaceholder(projectID: googleAppID) // Placeholder call
+            if let version = templateVersion {
+                 updateLastFetchedTemplateVersion(version) // Updates UserDefaults via computed property
+            }
+        }
+
+        updateMetadataTable() // DB Interaction - Keep selector usage within
+    }
+
+    func updateFetchTimeWithSuccessFetch(_ isSuccessfulFetch: Bool) {
+        let epochTimeInterval = Date().timeIntervalSince1970
+        if isSuccessfulFetch {
+            successFetchTimes.append(epochTimeInterval)
+        } else {
+            failureFetchTimes.append(epochTimeInterval)
+        }
+        // Note: DB update happens in updateMetadataTable called by updateMetadataWithFetchSuccessStatus
+    }
+
+     func updateLastActiveTemplateVersion() {
+         if let fetchedVersion = self.lastFetchedTemplateVersion { // Reads via computed property
+             // Calls setter which updates UserDefaults and local cache
+             updateLastActiveTemplateVersionInUserDefaults(fetchedVersion)
+         }
+     }
+
+    // MARK: - Throttling Logic
+
+    func updateExponentialBackoffTime() {
+        if lastFetchStatus == .success {
+             // TODO: Log Debug: FIRLogDebug(kFIRLoggerRemoteConfig, @"I-RCN000057", @"Throttling: Entering exponential backoff mode.")
+            exponentialBackoffRetryInterval = Constants.exponentialBackoffMinimumInterval
+        } else {
+             // TODO: Log Debug: FIRLogDebug(kFIRLoggerRemoteConfig, @"I-RCN000057", @"Throttling: Updating throttling interval.")
+            let doubledInterval = exponentialBackoffRetryInterval * 2
+            exponentialBackoffRetryInterval = min(doubledInterval, Constants.exponentialBackoffMaximumInterval)
+        }
+
+        // Randomize +/- 50%
+        let randomFactor = Double.random(in: -0.5...0.5)
+        let randomizedRetryInterval = exponentialBackoffRetryInterval + (exponentialBackoffRetryInterval * randomFactor)
+        exponentialBackoffThrottleEndTime = Date().timeIntervalSince1970 + randomizedRetryInterval
+    }
+
+     func updateRealtimeExponentialBackoffTime() {
+         var currentRetryInterval = self.realtimeExponentialBackoffRetryInterval // Read via computed property
+         if realtimeRetryCount == 0 {
+              // TODO: Log Debug: FIRLogDebug(kFIRLoggerRemoteConfig, @"I-RCN000058", @"Throttling: Entering exponential Realtime backoff mode.")
+              currentRetryInterval = Constants.exponentialBackoffMinimumInterval
+         } else {
+              // TODO: Log Debug: FIRLogDebug(kFIRLoggerRemoteConfig, @"I-RCN000058", @"Throttling: Updating Realtime throttling interval.")
+              let doubledInterval = currentRetryInterval * 2
+              currentRetryInterval = min(doubledInterval, Constants.exponentialBackoffMaximumInterval)
+         }
+
+         let randomFactor = Double.random(in: -0.5...0.5)
+         let randomizedRetryInterval = currentRetryInterval + (currentRetryInterval * randomFactor)
+         let newEndTime = Date().timeIntervalSince1970 + randomizedRetryInterval
+
+         // Update UserDefaults via computed property setters
+         self.realtimeThrottleEndTime = newEndTime
+         self.realtimeExponentialBackoffRetryInterval = currentRetryInterval
+     }
+
+    func getRealtimeBackoffInterval() -> TimeInterval {
+        let now = Date().timeIntervalSince1970
+        let endTime = self.realtimeThrottleEndTime // Read directly via computed property
+        let interval = endTime - now
+        return max(0, interval) // Return 0 if end time is in the past
+    }
+
+    func shouldThrottle() -> Bool {
+        // Check if not successful and backoff time is in the future
+        let now = Date().timeIntervalSince1970
+        return lastFetchStatus != .success && exponentialBackoffThrottleEndTime > now
+    }
+
+    func hasMinimumFetchIntervalElapsed(minimumInterval: TimeInterval) -> Bool {
+        let lastFetch = self.lastFetchTimeInterval // Read directly via computed property
+        if lastFetch <= 0 { return true } // No successful fetch yet
+
+        let diffInSeconds = Date().timeIntervalSince1970 - lastFetch
+        return diffInSeconds > minimumInterval
+    }
+
+    // MARK: - Fetch Request Body Construction
+
+    func nextRequestWithUserProperties(_ userProperties: [String: Any]?) -> String? {
+        // Ensure required IDs are present
+        guard let installationsID = configInstallationsIdentifier,
+              let installationsToken = configInstallationsToken,
+              let appID = googleAppID else {
+            // TODO: Log error?
+            return nil
+        }
+
+        // Device Info - Keep selectors for RCNDevice
+        // Assume RCNDevice is an NSObject subclass for perform(#selector(...))
+        let countryCode = RCNDevice.perform(#selector(RCNDevice.deviceCountry))?.takeUnretainedValue() as? String ?? ""
+        let languageCode = RCNDevice.perform(#selector(RCNDevice.deviceLocale))?.takeUnretainedValue() as? String ?? ""
+        let platformVersion = RCNDevice.perform(#selector(RCNDevice.systemVersion))?.takeUnretainedValue() as? String ?? "" // GULAppEnvironmentUtil.systemVersion()
+        let timeZone = RCNDevice.perform(#selector(RCNDevice.timezone))?.takeUnretainedValue() as? String ?? ""
+        let appVersion = RCNDevice.perform(#selector(RCNDevice.appVersion))?.takeUnretainedValue() as? String ?? ""
+        let appBuild = RCNDevice.perform(#selector(RCNDevice.appBuildVersion))?.takeUnretainedValue() as? String ?? ""
+        let sdkVersion = RCNDevice.perform(#selector(RCNDevice.podVersion))?.takeUnretainedValue() as? String ?? "" // Renamed selector assuming podVersion exists
+
+
+        var components: [String: String] = [
+            "app_instance_id": "'\(installationsID)'",
+            "app_instance_id_token": "'\(installationsToken)'",
+            "app_id": "'\(appID)'",
+            "country_code": "'\(countryCode)'",
+            "language_code": "'\(languageCode)'",
+            "platform_version": "'\(platformVersion)'",
+            "time_zone": "'\(timeZone)'",
+            "package_name": "'\(bundleIdentifier)'",
+            "app_version": "'\(appVersion)'",
+            "app_build": "'\(appBuild)'",
+            "sdk_version": "'\(sdkVersion)'"
+        ]
+
+        var analyticsProperties = userProperties ?? [:]
+
+        // Handle first open time
+        if let firstOpenTimeNum = analyticsProperties[Constants.analyticsFirstOpenTimePropertyName] as? NSNumber {
+            let firstOpenTimeSeconds = firstOpenTimeNum.doubleValue / 1000.0
+            let date = Date(timeIntervalSince1970: firstOpenTimeSeconds)
+            let formatter = ISO8601DateFormatter() // Swift equivalent
+            components["first_open_time"] = "'\(formatter.string(from: date))'"
+            analyticsProperties.removeValue(forKey: Constants.analyticsFirstOpenTimePropertyName)
+        }
+
+        // Add remaining analytics properties
+        if !analyticsProperties.isEmpty {
+            if let jsonData = try? JSONSerialization.data(withJSONObject: analyticsProperties),
+               let jsonString = String(data: jsonData, encoding: .utf8) {
+                 components["analytics_user_properties"] = jsonString // No extra quotes needed? Check ObjC impl string format
+            }
+        }
+
+         // Add custom signals
+         let currentCustomSignals = self.customSignals // Read directly via computed property
+         if !currentCustomSignals.isEmpty {
+             if let jsonData = try? JSONSerialization.data(withJSONObject: currentCustomSignals),
+                let jsonString = String(data: jsonData, encoding: .utf8) {
+                 components["custom_signals"] = jsonString // No extra quotes needed? Check ObjC impl string format
+                  // TODO: Log Debug: FIRLogDebug(kFIRLoggerRemoteConfig, @"I-RCN000078", ...)
+             }
+         }
+
+        // Construct final string - Requires careful formatting to match ObjC exactly
+        let bodyString = components.map { key, value in "\(key):\(value)" }.joined(separator: ", ")
+        return "{\(bodyString)}"
+    }
+
+    // MARK: - Placeholder Helpers
+    private func getDeviceContextPlaceholder(projectID: String) -> [String: Any] {
+        // TODO: Replace with actual call to translated RCNDevice function
+        return ["project_id": projectID] // Minimal placeholder
+    }
+
+    // MARK: - Placeholder Selectors for Dependencies
+    // Selectors for DB Manager (kept as placeholder)
+    @objc private func isNewDatabase() -> Bool { return false }
+    @objc private func loadMetadata(withBundleIdentifier id: String, namespace ns: String) -> [String: Any]? { return nil }
+    @objc private func deleteRecord(withBundleIdentifier id: String, namespace ns: String) {}
+    @objc private func insertMetadataTable(withValues values: [String: Any], completionHandler handler: Any?) {} // Handler is optional block
+    @objc private func updateMetadata(withOption option: Int, namespace ns: String, values: [Any], completionHandler handler: Any?) {} // Handler is optional block
+
+    // RCNDevice selectors (static methods)
+    // Keep these until RCNDevice is translated
+    @objc private static func deviceCountry() -> String { return "" }
+    @objc private static func deviceLocale() -> String { return "" }
+    @objc private static func systemVersion() -> String { return "" } // GULAppEnvironmentUtil
+    @objc private static func timezone() -> String { return "" }
+    @objc private static func appVersion() -> String { return "" }
+    @objc private static func appBuildVersion() -> String { return "" }
+    @objc private static func podVersion() -> String { return "" } // FIRRemoteConfigPodVersion
+}
+
+// Extension providing @objc methods for RemoteConfig.swift to call
+// This is still needed as RemoteConfig uses selectors for DB updates via these methods
+extension RCNConfigSettingsInternal {
+    // Properties accessed directly by RemoteConfig.swift do not need @objc methods here
+    // (e.g., lastFetchTimeInterval, lastFetchStatus, minimumFetchInterval, fetchTimeout,
+    // lastETagUpdateTime, lastApplyTimeInterval, lastActiveTemplateVersion)
+
+    // Keep methods that involve DB interaction selectors
+    @objc func updateLastApplyTimeIntervalInDB(_ interval: TimeInterval) {
+        updateLastApplyTimeIntervalInDB(interval) // Calls internal func with DB selector call
+    }
+
+    @objc func updateLastSetDefaultsTimeIntervalInDB(_ interval: TimeInterval) {
+        updateLastSetDefaultsTimeIntervalInDB(interval) // Calls internal func with DB selector call
+    }
+
+    @objc func updateLastActiveTemplateVersion() { // Matches selector used in RemoteConfig.activate
+        updateLastActiveTemplateVersion() // Calls internal func that updates property & UserDefaults
+    }
+}

FirebaseRemoteConfig/Sources/RCNUserDefaultsManager.swift

@@ -0,0 +1,255 @@
+import Foundation
+import FirebaseCore // For FIRLogger
+
+// TODO: Move keys to a central constants file
+private enum UserDefaultsKeys {
+    static let lastETag = "lastETag"
+    static let lastETagUpdateTime = "lastETagUpdateTime"
+    static let lastSuccessfulFetchTime = "lastSuccessfulFetchTime"
+    static let lastFetchStatus = "lastFetchStatus" // Note: This seems unused in RCNConfigSettingsInternal read path
+    static let isClientThrottled = "isClientThrottledWithExponentialBackoff"
+    static let throttleEndTime = "throttleEndTime"
+    static let currentThrottlingRetryInterval = "currentThrottlingRetryInterval"
+    static let realtimeThrottleEndTime = "throttleRealtimeEndTime"
+    static let currentRealtimeThrottlingRetryInterval = "currentRealtimeThrottlingRetryInterval"
+    static let realtimeRetryCount = "realtimeRetryCount"
+    static let lastFetchedTemplateVersion = "fetchTemplateVersion" // From RCNConfigConstants? Check key name
+    static let lastActiveTemplateVersion = "activeTemplateVersion" // From RCNConfigConstants? Check key name
+    static let customSignals = "customSignals"
+
+    // Grouping constants from ObjC implementation
+    static let groupPrefix = "group"
+    static let groupSuffix = "firebase"
+
+}
+
+
+/// Wraps UserDefaults to provide scoped, thread-safe access for Remote Config settings.
+class RCNUserDefaultsManager {
+
+    private let userDefaults: UserDefaults
+    private let firebaseAppName: String
+    private let firebaseNamespace: String // Just the namespace part (e.g., "firebase")
+    private let bundleIdentifier: String
+    private let lock = NSLock() // Lock for synchronizing writes
+
+    // MARK: - Initialization
+
+    /// Designated initializer.
+    init(appName: String, bundleID: String, firebaseNamespace qualifiedNamespace: String) {
+        self.firebaseAppName = appName
+        self.bundleIdentifier = bundleID
+
+        // Extract namespace part from "namespace:appName"
+        if let range = qualifiedNamespace.range(of: ":") {
+             self.firebaseNamespace = String(qualifiedNamespace[..<range.lowerBound])
+        } else {
+             // TODO: Log error - Namespace not fully qualified
+             print("Error: Namespace '\(qualifiedNamespace)' is not fully qualified.")
+             self.firebaseNamespace = qualifiedNamespace // Use as is, might cause issues
+        }
+
+        // Get shared UserDefaults instance for the app group derived from bundle ID
+        self.userDefaults = RCNUserDefaultsManager.sharedUserDefaults(forBundleIdentifier: bundleID)
+    }
+
+    // MARK: - Static Methods for Shared UserDefaults
+
+    private static func userDefaultsSuiteName(forBundleIdentifier bundleIdentifier: String) -> String {
+        // Ensure bundleIdentifier is not empty? ObjC didn't check here.
+        return "\(UserDefaultsKeys.groupPrefix).\(bundleIdentifier).\(UserDefaultsKeys.groupSuffix)"
+    }
+
+    private static func sharedUserDefaults(forBundleIdentifier bundleIdentifier: String) -> UserDefaults {
+        // This mimics dispatch_once behavior implicitly through static initialization in Swift >= 1.2
+        struct Static {
+            static let instance = UserDefaults(suiteName: userDefaultsSuiteName(forBundleIdentifier: bundleIdentifier)) ?? UserDefaults.standard // Fallback unlikely needed
+        }
+        return Static.instance
+    }
+
+    // MARK: - Scoped Key Path
+
+    /// Generates the key path for accessing the setting within UserDefaults: AppName.Namespace.Key
+    private func scopedKeyPath(forKey key: String) -> String {
+        return "\(firebaseAppName).\(firebaseNamespace).\(key)"
+    }
+
+    // MARK: - Read/Write Helpers (with locking)
+
+    private func readValue<T>(forKey key: String) -> T? {
+        // Reading UserDefaults is thread-safe, no lock needed technically,
+        // but ObjC implementation read inside @synchronized block indirectly via instanceUserDefaults.
+        // Let's keep reads simple for now.
+        return userDefaults.value(forKeyPath: scopedKeyPath(forKey: key)) as? T
+    }
+
+    private func writeValue(_ value: Any?, forKey key: String) {
+        lock.lock()
+        defer { lock.unlock() }
+
+        // We need to read the current app dictionary, then the namespace dictionary,
+        // modify it, and write the whole app dictionary back. This mimics the ObjC logic.
+
+        let appKey = firebaseAppName
+        let namespaceKey = firebaseNamespace
+        let settingKey = key
+
+        var appDict = userDefaults.dictionary(forKey: appKey) ?? [:]
+        var namespaceDict = appDict[namespaceKey] as? [String: Any] ?? [:]
+
+        if let newValue = value {
+            namespaceDict[settingKey] = newValue
+        } else {
+            namespaceDict.removeValue(forKey: settingKey) // Remove if value is nil
+        }
+
+        appDict[namespaceKey] = namespaceDict // Put potentially modified namespace dict back
+        userDefaults.set(appDict, forKey: appKey) // Write the whole app dict back
+
+        // Mimic explicit synchronize call, though often discouraged in Swift.
+        // Required for potential app extension communication relying on it.
+        userDefaults.synchronize()
+    }
+
+
+    // MARK: - Public Properties (Computed)
+
+    var lastETag: String? {
+        get { readValue(forKey: UserDefaultsKeys.lastETag) }
+        set { writeValue(newValue, forKey: UserDefaultsKeys.lastETag) }
+    }
+
+    var lastETagUpdateTime: TimeInterval {
+        get { readValue(forKey: UserDefaultsKeys.lastETagUpdateTime) ?? 0.0 }
+        set { writeValue(newValue, forKey: UserDefaultsKeys.lastETagUpdateTime) }
+    }
+
+    var lastFetchTime: TimeInterval {
+         get { readValue(forKey: UserDefaultsKeys.lastSuccessfulFetchTime) ?? 0.0 }
+         set { writeValue(newValue, forKey: UserDefaultsKeys.lastSuccessfulFetchTime) }
+     }
+
+     // lastFetchStatus seems unused internally for read, only written? Keep setter for now.
+     // var lastFetchStatus: String? {
+     //     get { readValue(forKey: UserDefaultsKeys.lastFetchStatus) }
+     //     set { writeValue(newValue, forKey: UserDefaultsKeys.lastFetchStatus) }
+     // }
+
+     var isClientThrottledWithExponentialBackoff: Bool {
+         get { readValue(forKey: UserDefaultsKeys.isClientThrottled) ?? false }
+         set { writeValue(newValue, forKey: UserDefaultsKeys.isClientThrottled) }
+     }
+
+     var throttleEndTime: TimeInterval {
+         get { readValue(forKey: UserDefaultsKeys.throttleEndTime) ?? 0.0 }
+         set { writeValue(newValue, forKey: UserDefaultsKeys.throttleEndTime) }
+     }
+
+     var currentThrottlingRetryIntervalSeconds: TimeInterval {
+         get { readValue(forKey: UserDefaultsKeys.currentThrottlingRetryInterval) ?? 0.0 }
+         set { writeValue(newValue, forKey: UserDefaultsKeys.currentThrottlingRetryInterval) }
+     }
+
+     var realtimeThrottleEndTime: TimeInterval {
+         get { readValue(forKey: UserDefaultsKeys.realtimeThrottleEndTime) ?? 0.0 }
+         set { writeValue(newValue, forKey: UserDefaultsKeys.realtimeThrottleEndTime) }
+     }
+
+     var currentRealtimeThrottlingRetryIntervalSeconds: TimeInterval {
+          get { readValue(forKey: UserDefaultsKeys.currentRealtimeThrottlingRetryInterval) ?? 0.0 }
+          set { writeValue(newValue, forKey: UserDefaultsKeys.currentRealtimeThrottlingRetryInterval) }
+      }
+
+      var realtimeRetryCount: Int {
+           get { readValue(forKey: UserDefaultsKeys.realtimeRetryCount) ?? 0 }
+           set { writeValue(newValue, forKey: UserDefaultsKeys.realtimeRetryCount) }
+       }
+
+     var lastFetchedTemplateVersion: String? { // Defaulted to "0" in ObjC getter if nil
+         get { readValue(forKey: UserDefaultsKeys.lastFetchedTemplateVersion) ?? "0" }
+         set { writeValue(newValue, forKey: UserDefaultsKeys.lastFetchedTemplateVersion) }
+     }
+
+     var lastActiveTemplateVersion: String? { // Defaulted to "0" in ObjC getter if nil
+         get { readValue(forKey: UserDefaultsKeys.lastActiveTemplateVersion) ?? "0" }
+         set { writeValue(newValue, forKey: UserDefaultsKeys.lastActiveTemplateVersion) }
+     }
+
+     var customSignals: [String: String] {
+         get { readValue(forKey: UserDefaultsKeys.customSignals) ?? [:] } // Default to empty dict
+         set { writeValue(newValue, forKey: UserDefaultsKeys.customSignals) }
+     }
+
+
+    // MARK: - Public Methods
+
+    /// Delete all saved user defaults for this instance (App Name + Namespace scope).
+    func resetUserDefaults() {
+        lock.lock()
+        defer { lock.unlock() }
+
+        let appKey = firebaseAppName
+        let namespaceKey = firebaseNamespace
+
+        var appDict = userDefaults.dictionary(forKey: appKey) ?? [:]
+        appDict.removeValue(forKey: namespaceKey) // Remove the namespace dict
+
+        if appDict.isEmpty {
+             userDefaults.removeObject(forKey: appKey) // Remove app dict if empty
+        } else {
+             userDefaults.set(appDict, forKey: appKey) // Write back modified app dict
+        }
+
+        userDefaults.synchronize()
+    }
+
+    // MARK: - Placeholder Selectors (for @objc calls from RCNConfigSettingsInternal)
+    // These allow RCNConfigSettingsInternal to call this Swift class via selectors
+    // until RCNConfigSettingsInternal is updated to call Swift methods directly.
+
+    @objc func lastETagObjc() -> String? { return lastETag }
+    @objc func setLastETagObjc(_ etag: String?) { lastETag = etag }
+
+    @objc func lastETagUpdateTimeObjc() -> TimeInterval { return lastETagUpdateTime }
+    @objc func setLastETagUpdateTimeObjc(_ time: TimeInterval) { lastETagUpdateTime = time }
+
+    @objc func lastFetchTimeObjc() -> TimeInterval { return lastFetchTime }
+    @objc func setLastFetchTimeObjc(_ time: TimeInterval) { lastFetchTime = time }
+
+    // No getter for lastFetchStatus needed?
+    // @objc func setLastFetchStatusObjc(_ status: String?) { lastFetchStatus = status }
+
+    @objc func isClientThrottledWithExponentialBackoffObjc() -> Bool { return isClientThrottledWithExponentialBackoff }
+    @objc func setIsClientThrottledWithExponentialBackoffObjc(_ throttled: Bool) { isClientThrottledWithExponentialBackoff = throttled }
+
+    @objc func throttleEndTimeObjc() -> TimeInterval { return throttleEndTime }
+    @objc func setThrottleEndTimeObjc(_ time: TimeInterval) { throttleEndTime = time }
+
+    @objc func currentThrottlingRetryIntervalSecondsObjc() -> TimeInterval { return currentThrottlingRetryIntervalSeconds }
+    @objc func setCurrentThrottlingRetryIntervalSecondsObjc(_ interval: TimeInterval) { currentThrottlingRetryIntervalSeconds = interval }
+
+    @objc func realtimeThrottleEndTimeObjc() -> TimeInterval { return realtimeThrottleEndTime }
+    @objc func setRealtimeThrottleEndTimeObjc(_ time: TimeInterval) { realtimeThrottleEndTime = time }
+
+    @objc func currentRealtimeThrottlingRetryIntervalSecondsObjc() -> TimeInterval { return currentRealtimeThrottlingRetryIntervalSeconds }
+    @objc func setCurrentRealtimeThrottlingRetryIntervalSecondsObjc(_ interval: TimeInterval) { currentRealtimeThrottlingRetryIntervalSeconds = interval }
+
+    @objc func realtimeRetryCountObjc() -> Int { return realtimeRetryCount }
+    @objc func setRealtimeRetryCountObjc(_ count: Int) { realtimeRetryCount = count }
+
+    @objc func lastFetchedTemplateVersionObjc() -> String? { return lastFetchedTemplateVersion }
+    @objc func setLastFetchedTemplateVersionObjc(_ version: String?) { lastFetchedTemplateVersion = version }
+
+    @objc func lastActiveTemplateVersionObjc() -> String? { return lastActiveTemplateVersion }
+    @objc func setLastActiveTemplateVersionObjc(_ version: String?) { lastActiveTemplateVersion = version }
+
+    @objc func customSignalsObjc() -> [String: String]? { return customSignals }
+    @objc func setCustomSignalsObjc(_ signals: [String: String]?) { customSignals = signals ?? [:] }
+
+    @objc func resetUserDefaultsObjc() { resetUserDefaults() }
+
+}
+
+// Temporary placeholder for RemoteConfigSource enum if not defined elsewhere yet
+//@objc(FIRRemoteConfigSource) public enum RemoteConfigSource: Int { case remote, defaultValue, staticValue }

FirebaseRemoteConfig/Sources/RemoteConfig.swift

@@ -0,0 +1,447 @@
+import Foundation
+import FirebaseCore // For FIROptions, FIRApp, FIRAnalyticsInterop, etc.
+// TODO: Import necessary modules like FirebaseInstallations if needed after translation
+
+// Placeholder types for internal Objective-C classes until they are translated
+// Keep DBManager placeholder if translation was skipped
+typealias RCNConfigContent = AnyObject
+typealias RCNConfigDBManager = AnyObject
+// RCNConfigSettingsInternal is now translated
+typealias RCNConfigFetch = AnyObject
+typealias RCNConfigExperiment = AnyObject
+typealias RCNConfigRealtime = AnyObject
+typealias FIRAnalyticsInterop = AnyObject // Assuming FIRAnalyticsInterop is ObjC protocol
+typealias FIRExperimentController = AnyObject // Placeholder
+// Define RemoteConfigSource enum based on previous translation
+@objc(FIRRemoteConfigSource) public enum RemoteConfigSource: Int {
+  case remote = 0
+  case defaultValue = 1
+  case staticValue = 2
+}
+// Define RemoteConfigValue based on previous translation (simplified for context)
+@objc(FIRRemoteConfigValue) public class RemoteConfigValue: NSObject, NSCopying {
+    let valueData: Data
+    let source: RemoteConfigSource
+    init(data: Data, source: RemoteConfigSource) {
+        self.valueData = data; self.source = source; super.init()
+    }
+    override convenience init() { self.init(data: Data(), source: .staticValue) }
+    @objc public func copy(with zone: NSZone? = nil) -> Any { return self }
+    // Add properties like stringValue, boolValue etc. if needed by selectors below
+    @objc public var stringValue: String { String(data: valueData, encoding: .utf8) ?? "" } // Placeholder implementation
+    @objc public var numberValue: NSNumber { NSNumber(value: Double(stringValue) ?? 0.0) } // Placeholder
+    @objc public var dataValue: Data { valueData } // Placeholder
+    @objc public var boolValue: Bool { false } // Placeholder
+    @objc public var jsonValue: Any? { nil } // Placeholder
+}
+
+
+// Constants mirroring Objective-C defines (move to a constants file later?)
+let defaultMinimumFetchInterval: TimeInterval = 43200.0 // 12 hours
+let defaultFetchTimeout: TimeInterval = 60.0
+struct RemoteConfigConstants {
+    static let errorDomain = "com.google.remoteconfig.ErrorDomain"
+    static let remoteConfigActivateNotification = Notification.Name("FIRRemoteConfigActivateNotification")
+    static let appNameKey = "FIRAppNameKey" // Assuming kFIRAppNameKey maps to this
+    static let googleMobilePlatformNamespace = "firebase" // Placeholder for FIRNamespaceGoogleMobilePlatform
+}
+
+// TODO: Define RemoteConfigFetchStatus, RemoteConfigFetchAndActivateStatus, RemoteConfigError enums
+@objc(FIRRemoteConfigFetchStatus) public enum RemoteConfigFetchStatus: Int {
+    case noFetchYet = 0
+    case success = 1
+    case failure = 2
+    case throttled = 3
+}
+@objc(FIRRemoteConfigFetchAndActivateStatus) public enum RemoteConfigFetchAndActivateStatus: Int {
+    case successFetchedFromRemote = 0
+    case successUsingPreFetchedData = 1
+    case error = 2
+}
+@objc(FIRRemoteConfigError) public enum RemoteConfigError: Int {
+    case unknown = 8001
+    case throttled = 8002
+    case internalError = 8003
+}
+
+/// Firebase Remote Config class.
+@objc(FIRRemoteConfig)
+public class RemoteConfig: NSObject {
+
+    // --- Properties ---
+    private let configContent: RCNConfigContent
+    private let dbManager: RCNConfigDBManager
+    private let settingsInternal: RCNConfigSettingsInternal // Use actual translated class
+    private let configFetch: RCNConfigFetch
+    private let configExperiment: RCNConfigExperiment
+    private let configRealtime: RCNConfigRealtime
+    private static let sharedQueue = DispatchQueue(label: "com.google.firebase.remoteconfig.serial")
+    private let queue: DispatchQueue = RemoteConfig.sharedQueue
+
+    private let appName: String
+    private let firebaseNamespace: String // Fully qualified namespace (namespace:appName)
+
+    @objc public var lastFetchTime: Date? {
+        var fetchTimeInterval: TimeInterval = 0
+        // Access directly via userDefaultsManager used by settingsInternal
+        queue.sync {
+           fetchTimeInterval = self.settingsInternal.lastFetchTimeInterval
+        }
+        return fetchTimeInterval > 0 ? Date(timeIntervalSince1970: fetchTimeInterval) : nil
+    }
+
+    @objc public var lastFetchStatus: RemoteConfigFetchStatus {
+         var status: RemoteConfigFetchStatus = .noFetchYet
+         // Access internal settings property safely on the queue
+         queue.sync {
+           status = self.settingsInternal.lastFetchStatus
+         }
+         return status
+    }
+
+    @objc public var configSettings: RemoteConfigSettings {
+        get {
+            let currentSettings = RemoteConfigSettings()
+            // Access internal settings properties safely on the queue
+            queue.sync {
+                currentSettings.minimumFetchInterval = self.settingsInternal.minimumFetchInterval
+                currentSettings.fetchTimeout = self.settingsInternal.fetchTimeout
+            }
+            // TODO: Log debug message? FIRLogDebug(kFIRLoggerRemoteConfig, @"I-RCN000066", ...)
+            return currentSettings
+        }
+        set {
+            // Update internal settings properties safely on the queue
+            queue.async { // Use async for setter as ObjC does
+                self.settingsInternal.minimumFetchInterval = newValue.minimumFetchInterval
+                self.settingsInternal.fetchTimeout = newValue.fetchTimeout
+
+                // TODO: Recreate network session if needed
+                // This likely involves calling a method on the (translated) configFetch object
+                 _ = self.configFetch.perform(#selector(RCNConfigFetch.recreateNetworkSession))
+
+                // TODO: Log debug message? FIRLogDebug(kFIRLoggerRemoteConfig, @"I-RCN000067", ...)
+            }
+        }
+    }
+
+     @objc(remoteConfig)
+     public static func remoteConfig() -> RemoteConfig { return FIRRemoteConfig.remoteConfig() } // Bridge
+     @objc(remoteConfigWithApp:)
+     public static func remoteConfig(app: FirebaseApp) -> RemoteConfig { return FIRRemoteConfig.remoteConfig(with: app) } // Bridge
+
+
+    init(appName: String, options: FIROptions, namespace: String, dbManager: RCNConfigDBManager, configContent: RCNConfigContent, analytics: FIRAnalyticsInterop?) {
+        self.appName = appName
+        self.firebaseNamespace = "\(namespace):\(appName)" // Corrected namespace format
+        self.dbManager = dbManager
+        self.configContent = configContent
+
+        // Initialize RCNConfigSettingsInternal (Use actual translated init)
+        // Pass dbManager placeholder, namespace, appName, options.googleAppID
+        // Note: options.googleAppID might be optional, handle nil case
+        self.settingsInternal = RCNConfigSettingsInternal(databaseManager: dbManager, namespace: self.firebaseNamespace, firebaseAppName: appName, googleAppID: options.googleAppID ?? "")
+
+        // Initialize RCNConfigExperiment (Placeholder - requires translation)
+         // let experimentController = FIRExperimentController.sharedInstance() // Requires FIRExperimentController translation
+         self.configExperiment = RCNConfigExperiment() // Placeholder
+
+        // Initialize RCNConfigFetch (Placeholder - requires translation)
+        self.configFetch = RCNConfigFetch() // Placeholder
+
+        // Initialize RCNConfigRealtime (Placeholder - requires translation)
+        self.configRealtime = RCNConfigRealtime() // Placeholder
+
+        super.init()
+    }
+     @available(*, unavailable, message: "Use RemoteConfig.remoteConfig() static method instead.")
+     public override init() { fatalError("Use RemoteConfig.remoteConfig() static method instead.") }
+
+    @objc(ensureInitializedWithCompletionHandler:)
+    public func ensureInitialized(completionHandler: @escaping @Sendable (Error?) -> Void) {
+        DispatchQueue.global(qos: .utility).async { [weak self] in
+            guard let self = self else { return }
+            var initializationSuccessful = false
+            // Keep using selector for untranslated RCNConfigContent
+            let successValue = self.configContent.perform(#selector(getter: RCNConfigContent.initializationSuccessful))?.takeUnretainedValue() as? Bool
+            initializationSuccessful = successValue ?? false
+            var error: Error? = nil
+            if !initializationSuccessful {
+                error = NSError(domain: RemoteConfigConstants.errorDomain, code: RemoteConfigError.internalError.rawValue, userInfo: [NSLocalizedDescriptionKey: "Timed out waiting for database load."])
+            }
+            completionHandler(error)
+        }
+    }
+
+
+    // --- Fetch & Activate Methods ---
+    @objc(fetchWithCompletionHandler:)
+    public func fetch(completionHandler: ((RemoteConfigFetchStatus, Error?) -> Void)? = nil) {
+        queue.async {
+            // Use direct access to settingsInternal property
+            let expirationDuration = self.settingsInternal.minimumFetchInterval
+            self.fetch(withExpirationDuration: expirationDuration, completionHandler: completionHandler)
+        }
+     }
+    @objc(fetchWithExpirationDuration:completionHandler:)
+    public func fetch(withExpirationDuration expirationDuration: TimeInterval, completionHandler: ((RemoteConfigFetchStatus, Error?) -> Void)? = nil) {
+        // Keep using selector for untranslated RCNConfigFetch
+        _ = configFetch.perform(#selector(RCNConfigFetch.fetchConfig(withExpirationDuration:completionHandler:)),
+                                with: expirationDuration, with: completionHandler as Any?)
+    }
+    @objc(activateWithCompletion:)
+    public func activate(completion: ((Bool, Error?) -> Void)? = nil) {
+         queue.async { [weak self] in
+             guard let self = self else {
+                  completion?(false, NSError(domain: RemoteConfigConstants.errorDomain, code: RemoteConfigError.internalError.rawValue, userInfo: [NSLocalizedDescriptionKey: "Internal error activating config: Instance deallocated."]))
+                  return
+             }
+             // Use direct access for settingsInternal properties
+             // Check if the last fetched config has already been activated.
+             if self.settingsInternal.lastETagUpdateTime <= 0 || self.settingsInternal.lastETagUpdateTime <= self.settingsInternal.lastApplyTimeInterval {
+                  // TODO: Log debug message? FIRLogDebug(kFIRLoggerRemoteConfig, @"I-RCN000069", ...)
+                  DispatchQueue.global().async { completion?(false, nil) } // Match ObjC global queue dispatch
+                  return
+             }
+
+             // Keep selectors for untranslated RCNConfigContent
+             let fetchedConfigDict = self.configContent.perform(#selector(getter: RCNConfigContent.fetchedConfig))?.takeUnretainedValue() as? NSDictionary
+             _ = self.configContent.perform(#selector(RCNConfigContent.copyFromDictionary(_:toSource:forNamespace:)), with: fetchedConfigDict, with: 1 /* Active */, with: self.firebaseNamespace)
+
+             // Update last apply time via settingsInternal method (interacts with DB placeholder)
+             let now = Date().timeIntervalSince1970
+             self.settingsInternal.updateLastApplyTimeIntervalInDB(now)
+
+             // TODO: Log debug message? FIRLogDebug(kFIRLoggerRemoteConfig, @"I-RCN000069", @"Config activated.")
+
+             // Keep selector for untranslated RCNConfigContent
+             _ = self.configContent.perform(#selector(RCNConfigContent.activatePersonalization))
+
+             // Update last active template version via settingsInternal method
+             self.settingsInternal.updateLastActiveTemplateVersion()
+
+             // Keep selector for untranslated RCNConfigContent for rollout activation
+             let rolloutCompletion: @convention(block) (Bool) -> Void = { success in
+                 if success {
+                    // Use actual property for version, keep selector for metadata
+                    let activeMetadata = self.configContent.perform(#selector(getter: RCNConfigContent.activeRolloutMetadata))?.takeUnretainedValue() as? NSArray // Placeholder type
+                    let versionNumber = self.settingsInternal.lastActiveTemplateVersion // Use actual property
+                    // TODO: Call notifyRolloutsStateChange - Requires translation
+                 }
+             }
+             _ = self.configContent.perform(#selector(RCNConfigContent.activateRolloutMetadata(_:)), with: rolloutCompletion as Any?)
+
+             let namespacePrefix = self.firebaseNamespace.components(separatedBy: ":").first ?? ""
+             if namespacePrefix == RemoteConfigConstants.googleMobilePlatformNamespace {
+                  DispatchQueue.main.async { self.notifyConfigHasActivated() } // Match ObjC main queue dispatch
+                  // Keep selector for untranslated RCNConfigExperiment
+                  let experimentCompletion: @convention(block) (Error?) -> Void = { error in DispatchQueue.global().async { completion?(true, error) } } // Match ObjC global queue dispatch
+                   _ = self.configExperiment.perform(#selector(RCNConfigExperiment.updateExperiments(handler:)), with: experimentCompletion as Any?)
+             } else {
+                  DispatchQueue.global().async { completion?(true, nil) } // Match ObjC global queue dispatch
+             }
+         }
+     }
+    @objc(fetchAndActivateWithCompletionHandler:)
+    public func fetchAndActivate(completionHandler: ((RemoteConfigFetchAndActivateStatus, Error?) -> Void)? = nil) {
+        self.fetch { [weak self] status, error in
+            guard let self = self else { return }
+            if status == .success, error == nil {
+                self.activate { changed, activateError in
+                    if let activateError = activateError {
+                         completionHandler?(.error, activateError)
+                    } else {
+                         completionHandler?(.successUsingPreFetchedData, nil) // Match ObjC
+                    }
+                }
+            } else {
+                 let fetchError = error ?? NSError(domain: RemoteConfigConstants.errorDomain, code: RemoteConfigError.internalError.rawValue, userInfo: [NSLocalizedDescriptionKey: "Fetch failed with status: \(status.rawValue)"])
+                 completionHandler?(.error, fetchError)
+            }
+        }
+    }
+    private func notifyConfigHasActivated() {
+        guard !self.appName.isEmpty else { return }
+        let appInfoDict = [RemoteConfigConstants.appNameKey: self.appName]
+        NotificationCenter.default.post(name: RemoteConfigConstants.remoteConfigActivateNotification, object: self, userInfo: appInfoDict)
+    }
+
+
+    // --- Get Config Methods ---
+    @objc public subscript(key: String) -> RemoteConfigValue {
+        return configValue(forKey: key)
+    }
+
+    @objc(configValueForKey:)
+    public func configValue(forKey key: String?) -> RemoteConfigValue {
+        guard let key = key, !key.isEmpty else {
+            return RemoteConfigValue(data: Data(), source: .staticValue)
+        }
+
+        return queue.sync { [weak self] () -> RemoteConfigValue in
+            guard let self = self else {
+                 return RemoteConfigValue(data: Data(), source: .staticValue)
+            }
+
+            // Keep selectors for untranslated RCNConfigContent
+            let activeConfig = self.configContent.perform(#selector(getter: RCNConfigContent.activeConfig))?.takeUnretainedValue() as? [String: [String: RemoteConfigValue]]
+
+            if let value = activeConfig?[self.firebaseNamespace]?[key] {
+                // TODO: Check value.source == .remote? Log error?
+                // TODO: Call listeners?
+                return value
+            }
+
+            // Call local defaultValue(forKey:) method
+            let defaultValue = self.defaultValue(forKey: key)
+            return defaultValue ?? RemoteConfigValue(data: Data(), source: .staticValue)
+        }
+    }
+
+    @objc(configValueForKey:source:)
+    public func configValue(forKey key: String?, source: RemoteConfigSource) -> RemoteConfigValue {
+         guard let key = key, !key.isEmpty else {
+             return RemoteConfigValue(data: Data(), source: .staticValue)
+         }
+
+         return queue.sync { [weak self] () -> RemoteConfigValue in
+            guard let self = self else { return RemoteConfigValue(data: Data(), source: .staticValue) }
+
+            // Keep selectors for untranslated RCNConfigContent
+            var value: RemoteConfigValue? = nil
+            switch source {
+            case .remote:
+                let activeConfig = self.configContent.perform(#selector(getter: RCNConfigContent.activeConfig))?.takeUnretainedValue() as? [String: [String: RemoteConfigValue]]
+                value = activeConfig?[self.firebaseNamespace]?[key]
+            case .defaultValue:
+                 let defaultConfig = self.configContent.perform(#selector(getter: RCNConfigContent.defaultConfig))?.takeUnretainedValue() as? [String: [String: RemoteConfigValue]]
+                 value = defaultConfig?[self.firebaseNamespace]?[key]
+            case .staticValue:
+                break
+            @unknown default:
+                 break
+            }
+            return value ?? RemoteConfigValue(data: Data(), source: .staticValue)
+         }
+    }
+
+    @objc(allKeysFromSource:)
+    public func allKeys(from source: RemoteConfigSource) -> [String] {
+        return queue.sync { [weak self] () -> [String] in
+            guard let self = self else { return [] }
+
+            // Keep selectors for untranslated RCNConfigContent
+            var keys: [String]? = nil
+            switch source {
+            case .remote:
+                 let activeConfig = self.configContent.perform(#selector(getter: RCNConfigContent.activeConfig))?.takeUnretainedValue() as? [String: [String: RemoteConfigValue]]
+                 keys = activeConfig?[self.firebaseNamespace]?.keys.map { $0 }
+            case .defaultValue:
+                 let defaultConfig = self.configContent.perform(#selector(getter: RCNConfigContent.defaultConfig))?.takeUnretainedValue() as? [String: [String: RemoteConfigValue]]
+                 keys = defaultConfig?[self.firebaseNamespace]?.keys.map { $0 }
+            case .staticValue:
+                 break
+            @unknown default:
+                 break
+            }
+            return keys ?? []
+        }
+    }
+
+    @objc(keysWithPrefix:)
+    public func keys(withPrefix prefix: String?) -> Set<String> {
+        return queue.sync { [weak self] () -> Set<String> in
+            guard let self = self else { return [] }
+
+            // Keep selector for untranslated RCNConfigContent
+            let activeConfig = self.configContent.perform(#selector(getter: RCNConfigContent.activeConfig))?.takeUnretainedValue() as? [String: [String: RemoteConfigValue]]
+            guard let namespaceConfig = activeConfig?[self.firebaseNamespace] else {
+                return []
+            }
+
+            let allKeys = namespaceConfig.keys
+            guard let prefix = prefix, !prefix.isEmpty else {
+                return Set(allKeys)
+            }
+
+            return Set(allKeys.filter { $0.hasPrefix(prefix) })
+        }
+    }
+
+    // MARK: - Defaults
+
+    @objc(setDefaults:)
+    public func setDefaults(_ defaults: [String: NSObject]?) {
+        let defaultsCopy = defaults ?? [:]
+
+        queue.async { [weak self] in
+            guard let self = self else { return }
+
+            // Keep selectors for untranslated RCNConfigContent
+            let namespaceToDefaults = [self.firebaseNamespace: defaultsCopy]
+             _ = self.configContent.perform(#selector(RCNConfigContent.copyFromDictionary(_:toSource:forNamespace:)),
+                                            with: namespaceToDefaults,
+                                            with: 2, // RCNDBSourceDefault
+                                            with: self.firebaseNamespace)
+
+             // Update last set defaults time via settingsInternal method (interacts with DB placeholder)
+             let now = Date().timeIntervalSince1970
+             self.settingsInternal.updateLastSetDefaultsTimeIntervalInDB(now)
+        }
+    }
+
+    @objc(setDefaultsFromPlistFileName:)
+    public func setDefaults(fromPlist fileName: String?) {
+        guard let fileName = fileName, !fileName.isEmpty else { return }
+        let bundlesToSearch = [Bundle.main, Bundle(for: RemoteConfig.self)]
+        var plistPath: String?
+        for bundle in bundlesToSearch {
+             if let path = bundle.path(forResource: fileName, ofType: "plist") {
+                 plistPath = path; break
+             }
+        }
+        guard let finalPath = plistPath else { return }
+        if let defaultsDict = NSDictionary(contentsOfFile: finalPath) as? [String: NSObject] {
+            setDefaults(defaultsDict)
+        }
+    }
+
+    @objc(defaultValueForKey:)
+    public func defaultValue(forKey key: String?) -> RemoteConfigValue? {
+        guard let key = key, !key.isEmpty else { return nil }
+
+        return queue.sync { [weak self] () -> RemoteConfigValue? in
+             guard let self = self else { return nil }
+
+             // Keep selectors for untranslated RCNConfigContent
+             let defaultConfig = self.configContent.perform(#selector(getter: RCNConfigContent.defaultConfig))?.takeUnretainedValue() as? [String: [String: RemoteConfigValue]]
+             let value = defaultConfig?[self.firebaseNamespace]?[key]
+             // TODO: Check source == .defaultValue?
+             return value
+        }
+    }
+
+    // MARK: - Placeholder selectors for untranslated classes
+
+    // RCNConfigContent related
+    @objc private func activeConfig() -> Any? { return nil }
+    @objc private func defaultConfig() -> Any? { return nil }
+    @objc private func fetchedConfig() -> NSDictionary? { return nil }
+    @objc private func copyFromDictionary(_ dict: Any?, toSource source: Int, forNamespace ns: String) {}
+    @objc private func activatePersonalization() {}
+    @objc private func activeRolloutMetadata() -> NSArray? { return nil }
+    @objc private func activateRolloutMetadata(_ completion: Any?) {}
+    @objc private func initializationSuccessful() -> Bool { return false }
+
+    // RCNConfigFetch related
+    @objc private func recreateNetworkSession() {}
+    @objc private func fetchConfig(withExpirationDuration duration: TimeInterval, completionHandler handler: Any?) {}
+
+    // RCNConfigExperiment related
+    @objc private func updateExperiments(handler: Any?) {}
+
+    // Selectors for DB interactions via RCNConfigSettingsInternal
+    @objc private func updateLastApplyTimeIntervalInDB(_ interval: TimeInterval) {}
+    @objc private func updateLastSetDefaultsTimeIntervalInDB(_ interval: TimeInterval) {}
+
+} // End of RemoteConfig class

FirebaseRemoteConfig/Sources/RemoteConfigSettings.swift

@@ -0,0 +1,32 @@
+import Foundation
+
+/// Firebase Remote Config settings.
+@objc(FIRRemoteConfigSettings)
+public class RemoteConfigSettings: NSObject {
+  /// Indicates the default value in seconds to set for the minimum interval that needs to elapse
+  /// before a fetch request can again be made to the Remote Config backend. After a fetch request to
+  /// the backend has succeeded, no additional fetch requests to the backend will be allowed until the
+  /// minimum fetch interval expires. Note that you can override this default on a per-fetch request
+  /// basis using `RemoteConfig.fetch(withExpirationDuration:)`. For example, setting
+  /// the expiration duration to 0 in the fetch request will override the `minimumFetchInterval` and
+  /// allow the request to proceed.
+  ///
+  /// The default interval is 12 hours.
+  @objc public var minimumFetchInterval: TimeInterval
+
+  /// Indicates the default value in seconds to abandon a pending fetch request made to the backend.
+  /// This value is set for outgoing requests as the `timeoutIntervalForRequest` as well as the
+  /// `timeoutIntervalForResource` on the `URLSession`'s configuration.
+  ///
+  /// The default timeout is 60 seconds.
+  @objc public var fetchTimeout: TimeInterval
+
+  /// Initializes FIRRemoteConfigSettings with default values.
+  @objc
+  public override init() {
+    // Default values match the ones set in RCNConfigSettings init and FIRRemoteConfig setDefaultConfigSettings
+    minimumFetchInterval = 43200.0 // 12 hours * 60 minutes * 60 seconds
+    fetchTimeout = 60.0
+    super.init()
+  }
+}

FirebaseRemoteConfig/Sources/RemoteConfigUpdate.swift

@@ -0,0 +1,23 @@
+import Foundation
+
+/// Represents the config update reported by the Remote Config real-time service.
+/// An instance of this class is passed to the config update listener when a new config
+/// version has been fetched from the backend.
+@objc(FIRRemoteConfigUpdate)
+public class RemoteConfigUpdate: NSObject {
+  /// Set of parameter keys whose values have been updated from the currently activated values.
+  /// This includes keys that are added, deleted, and whose value, value source, or metadata has changed.
+  @objc public let updatedKeys: Set<String>
+
+  /// Internal initializer.
+  /// - Parameter updatedKeys: The set of keys that have been updated.
+  internal init(updatedKeys: Set<String>) {
+    self.updatedKeys = updatedKeys
+    super.init()
+  }
+
+  /// Default initializer is unavailable.
+  override private init() {
+    fatalError("Default initializer is not available.")
+  }
+}

FirebaseRemoteConfig/Sources/RemoteConfigValue.swift

@@ -0,0 +1,95 @@
+import Foundation
+
+/// This enum indicates the source of fetched Remote Config data.
+/// - Note: This mirrors the Objective-C enum `FIRRemoteConfigSource`.
+@objc(FIRRemoteConfigSource) public enum RemoteConfigSource: Int {
+  /// The data source is the Remote Config backend.
+  case remote = 0
+  /// The data source is the default config defined for this app.
+  case defaultValue = 1
+  /// The data doesn't exist, returns a static initialized value.
+  case staticValue = 2
+}
+
+/// This class provides a wrapper for Remote Config parameter values, with methods to get parameter
+/// values as different data types.
+@objc(FIRRemoteConfigValue)
+public class RemoteConfigValue: NSObject, NSCopying {
+  /// Underlying data for the config value.
+  private let valueData: Data
+  /// Identifies the source of the fetched value.
+  @objc public let source: RemoteConfigSource
+
+  /// Designated initializer.
+  /// - Parameters:
+  ///   - data: The data representation of the value.
+  ///   - source: The source of the config value.
+  @objc
+  public init(data: Data, source: RemoteConfigSource) {
+    self.valueData = data
+    self.source = source
+    super.init()
+  }
+
+  /// Convenience initializer for static values (empty data).
+  override convenience init() {
+    self.init(data: Data(), source: .staticValue)
+  }
+
+  /// Gets the value as a string. Returns an empty string if the data cannot be UTF-8 decoded.
+  @objc public var stringValue: String {
+    return String(data: valueData, encoding: .utf8) ?? ""
+  }
+
+  /// Gets the value as an `NSNumber`. Tries to interpret the string value as a double.
+  @objc public var numberValue: NSNumber {
+    // Mimics Objective-C behavior: NSString.doubleValue returns 0.0 if conversion fails.
+    return NSNumber(value: Double(stringValue) ?? 0.0)
+  }
+
+  /// Gets the value as a `Data` object.
+  @objc public var dataValue: Data {
+    return valueData
+  }
+
+  /// Gets the value as a boolean. Tries to interpret the string value as a boolean.
+  @objc public var boolValue: Bool {
+    // Mimics Objective-C behavior: NSString.boolValue checks for specific prefixes/values.
+    let lowercasedString = stringValue.lowercased()
+    return lowercasedString == "true" || lowercasedString == "yes" || lowercasedString == "on" ||
+           lowercasedString == "1" || (Double(stringValue) != 0.0 && lowercasedString != "false" && lowercasedString != "no" && lowercasedString != "off")
+
+  }
+
+  /// Gets a Foundation object (`NSDictionary` / `NSArray`) by parsing the value as JSON.
+  /// Returns `nil` if the data is not valid JSON.
+  @objc public var jsonValue: Any? {
+    guard !valueData.isEmpty else { return nil }
+    do {
+      // Mimics Objective-C behavior using kNilOptions
+      return try JSONSerialization.jsonObject(with: valueData, options: [])
+    } catch {
+      // Log error similar to Objective-C implementation? Maybe not needed in Swift directly.
+      // FIRLogDebug(...)
+      return nil
+    }
+  }
+
+  // MARK: - NSCopying
+
+  @objc public func copy(with zone: NSZone? = nil) -> Any {
+    // Create a new instance with the same data and source.
+    let copy = RemoteConfigValue(data: valueData, source: source)
+    return copy
+  }
+
+  // MARK: - Debug Description
+
+  /// Debug description showing the representations of all types.
+  public override var debugDescription: String {
+    let jsonString = jsonValue.map { "\($0)" } ?? "nil"
+    return "<\(String(describing: type(of: self))): \(Unmanaged.passUnretained(self).toOpaque()), " +
+           "Boolean: \(boolValue), String: \(stringValue), Number: \(numberValue), " +
+           "JSON: \(jsonString), Data: \(dataValue.count) bytes, Source: \(source.rawValue)>"
+  }
+}