    open func set(conductedValue: Any?, for key: Key) throws {}
    
    // MARK: - ConductionModelType Protocol
-   open var modelKeys: [Key] { return [] }
-   open var viewKeys: [Key] { return [] }
+   open var modelReadKeys: [Key] { return modelReadOnlyKeys + modelReadWriteKeys }
+   open var modelWriteKeys: [Key] { return modelReadWriteKeys + modelWriteOnlyKeys }
+   open var viewReadKeys: [Key] { return viewReadOnlyKeys + viewReadWriteKeys }
+   open var viewWriteKeys: [Key] { return viewReadWriteKeys + viewWriteOnlyKeys }
    
    public func bindings(for key: Key) -> [Binding] {
       let bindings = modelBindings.filter(key: key)

   public var keysBeingSet: [Key] = []
   
   public func value(for key: Key) -> Any? {
      let bindings = modelBindings.filter(key: key)
      guard bindings.isEmpty else { return bindings.last!.targetValue }
      return conductedValue(for: key)
   }
   
   public func setOwn(value: Any?, for key: Key) throws {
      let bindings = modelBindings.filter(key: key)
      guard bindings.isEmpty else {
         try bindings.forEach { try $0.set(targetValue: value) }
         return
      }
      try set(conductedValue: value, for: key)
   }
}


public protocol StringConductionModelType: StringBindable {
   // MARK: – Keys
   var modelReadKeyStrings: [String] { get }
   var modelWriteKeyStrings: [String] { get }
   var viewReadKeyStrings: [String] { get }
   var viewWriteKeyStrings: [String] { get }
   
   func bindings(for keyString: String) -> [Binding]
}

public extension StringConductionModelType {
   // MARK: - Keys
   var modelKeyStrings: [String] { return modelReadKeyStrings + modelWriteKeyStrings }
   var viewKeyStrings: [String] { return modelReadKeyStrings + modelWriteKeyStrings }
}

public protocol ConductionModelType: Bindable, StringConductionModelType {
   // MARK: – Keys
   var modelReadKeys: [Key] { get }
   var modelWriteKeys: [Key] { get }
   var viewReadKeys: [Key] { get }
   var viewWriteKeys: [Key] { get }
   
   // MARK: - Bindings
   func bindings(for key: Key) -> [Binding]
}

public extension ConductionModelType {
   // MARK: - Keys
   var modelKeys: [Key] { return modelReadKeys + modelWriteKeys }
   var viewKeys: [Key] { return modelReadKeys + modelWriteKeys }

   // MARK: - Bindings
   func bindings(for keyString: String) -> [Binding] {
      guard let key = Key(rawValue: keyString) else { return [] }
      return bindings(for: key)
   }

   // MARK: - StringConductionModelType Protocol
   var modelReadKeyStrings: [String] {
      return modelReadKeys.map { return $0.rawValue }
   }
   var modelWriteKeyStrings: [String] {
      return modelWriteKeys.map { return $0.rawValue }
   }
   var viewReadKeyStrings: [String] {
      return viewReadKeys.map { return $0.rawValue }
   }
   var viewWriteKeyStrings: [String] {
      return viewWriteKeys.map { return $0.rawValue }
   }
   
}

public protocol ConductionModelState {
