 
 public protocol StringConductionModelType: StringBindable {
    // MARK: – Keys
-   var modelKeyStrings: [String] { get }
-   var viewKeyStrings: [String] { get }
+   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 modelKeys: [Key] { get }
-   var viewKeys: [Key] { get }
+   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 {
-   var modelKeyStrings: [String] {
-      return modelKeys.map { return $0.rawValue }
-   }
-   var viewKeyStrings: [String] {
-      return viewKeys.map { return $0.rawValue }
-   }
-   
+   // 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 {

      }
   }
   public var onStateChange: ((State) -> Void)?
   
   // MARK: Public
   public func value<T>(for key: Key, default defaultValue: T?) -> T? {

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