     /// CoreBluetooth Central Manager Options
     public let options: Options
     
-    internal lazy var internalManager = CBCentralManager(
+    private lazy var internalManager = CBCentralManager(
         delegate: self.delegate,
         queue: self.managerQueue,
         options: self.options.optionsDictionary
     )
     
-    internal lazy var managerQueue = DispatchQueue(label: "\(type(of: self)) Manager Queue")
-    
-    internal lazy var queue = DispatchQueue(label: "\(type(of: self)) Queue")
-    
-    internal private(set) var peripheralQueue = [Peripheral: DispatchQueue]()
-    
-    internal lazy var delegate = Delegate(self)
-
-    internal private(set) var cache = Cache()
-    
-    internal private(set) var combine = Combine()
+    private lazy var managerQueue = DispatchQueue(label: "\(type(of: self)) Manager Queue")
+    
+    private lazy var queue = DispatchQueue(label: "\(type(of: self)) Queue")
+    
+    private var peripheralQueue = [Peripheral: DispatchQueue]()
+    
+    private lazy var delegate = Delegate(self)
+
+    private var cache = Cache()
+    
+    private var combine = Combine()
     
     // MARK: - Initialization
     

    /// Get the maximum transmission unit for the specified peripheral.
    func maximumTransmissionUnit(for peripheral: Peripheral) -> AnyPublisher<ATTMaximumTransmissionUnit, Error> {
        
        let future = Future<ATTMaximumTransmissionUnit, Error> { [unowned self] (completion) in
            self.centralManager { (central) in
                self.peripheral(for: peripheral) { (corePeripheral) in
                    let mtu = corePeripheral.maximumWriteValueLength(for: .withoutResponse) + 3
                    
                }
            }
        }
        
        
        
        let future = Future<ATTMaximumTransmissionUnit, Error>()
        self.accessQueue.async {
            do {
                guard state == .poweredOn
                    else { throw DarwinCentralError.invalidState(state) }
                
            }
            catch {
                
            }
        }
        return subject
        
        
        
        let corePeripheral = try accessQueue.sync { [unowned self] in
            try self.connectedPeripheral(peripheral)
        }
        
        let mtu = corePeripheral.maximumWriteValueLength(for: .withoutResponse) + 3
        assert((corePeripheral.value(forKey: "mtuLength") as! NSNumber).intValue == mtu)
        return ATTMaximumTransmissionUnit(rawValue: UInt16(mtu)) ?? .default
    }
    
    // MARK: - Private Methods
    
    private func centralManager(_ block: (CBCentralManager) -> ()) {
        self.queue.async { [unowned self] in
            block(self.internalManager)
        }
    }
    
    private func peripheral(for peripheral: Peripheral, block: (CBPeripheral) -> ()) throws {
        // should only call from `self.queue`
        guard let corePeripheral = self.cache.peripherals[peripheral]
            else { throw CentralError.unknownPeripheral }
        self.queue(for: peripheral).async {
            block(corePeripheral)
        }
    }
    
    private func queue(for peripheral: Peripheral) -> DispatchQueue {
        return self.peripheralQueue[peripheral, default: DispatchQueue(label: "Peripheral \(peripheral) Queue")]
    }
    
    
}

// MARK: - Supporting Types

    /// - Parameter The peripheral to which the central manager is either trying to connect or has already connected.
    internal func cancelConnection(for peripheral: Peripheral) {
        self.queue.async {
            self.cache.peripherals[peripheral].flatMap {
                self.internalManager.cancelPeripheralConnection($0)
            }
        }
