@blueid/access-proto 0.22.0 → 0.24.0

package/swift/BlueLock.pb.swift

@@ -79,8 +79,15 @@ public struct BlueLockConfig {
   /// Clears the value of `openScheduleByUser`. Subsequent reads from it will return its default value.
   public mutating func clearOpenScheduleByUser() {self._openScheduleByUser = nil}
 
-  /// Days of year (1-366) the open schedule is ignored (ie vacation days)
-  public var closedDays: [UInt32] = []
+  /// If set keeps the lock closed on federal vacation days
+  public var keepClosedOnHolidays: Bool {
+    get {return _keepClosedOnHolidays ?? false}
+    set {_keepClosedOnHolidays = newValue}
+  }
+  /// Returns true if `keepClosedOnHolidays` has been explicitly set.
+  public var hasKeepClosedOnHolidays: Bool {return self._keepClosedOnHolidays != nil}
+  /// Clears the value of `keepClosedOnHolidays`. Subsequent reads from it will return its default value.
+  public mutating func clearKeepClosedOnHolidays() {self._keepClosedOnHolidays = nil}
 
   /// Default time in seconds to keep the lock open
   public var defaultOpenTimeSec: UInt32 {
@@ -107,6 +114,7 @@ public struct BlueLockConfig {
   public init() {}
 
   fileprivate var _openScheduleByUser: Bool? = nil
+  fileprivate var _keepClosedOnHolidays: Bool? = nil
   fileprivate var _defaultOpenTimeSec: UInt32? = nil
   fileprivate var _extendedOpenTimeSec: UInt32? = nil
 }
@@ -164,13 +172,14 @@ extension BlueLockConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplement
   public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
     1: .same(proto: "openSchedules"),
     2: .same(proto: "openScheduleByUser"),
-    20: .same(proto: "closedDays"),
+    20: .same(proto: "keepClosedOnHolidays"),
     21: .same(proto: "defaultOpenTimeSec"),
     22: .same(proto: "extendedOpenTimeSec"),
   ]
 
   public var isInitialized: Bool {
     if self._openScheduleByUser == nil {return false}
+    if self._keepClosedOnHolidays == nil {return false}
     if self._defaultOpenTimeSec == nil {return false}
     if self._extendedOpenTimeSec == nil {return false}
     if !SwiftProtobuf.Internal.areAllInitialized(self.openSchedules) {return false}
@@ -185,7 +194,7 @@ extension BlueLockConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplement
       switch fieldNumber {
       case 1: try { try decoder.decodeRepeatedMessageField(value: &self.openSchedules) }()
       case 2: try { try decoder.decodeSingularBoolField(value: &self._openScheduleByUser) }()
-      case 20: try { try decoder.decodeRepeatedUInt32Field(value: &self.closedDays) }()
+      case 20: try { try decoder.decodeSingularBoolField(value: &self._keepClosedOnHolidays) }()
       case 21: try { try decoder.decodeSingularUInt32Field(value: &self._defaultOpenTimeSec) }()
       case 22: try { try decoder.decodeSingularUInt32Field(value: &self._extendedOpenTimeSec) }()
       default: break
@@ -204,9 +213,9 @@ extension BlueLockConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplement
     try { if let v = self._openScheduleByUser {
       try visitor.visitSingularBoolField(value: v, fieldNumber: 2)
     } }()
-    if !self.closedDays.isEmpty {
-      try visitor.visitRepeatedUInt32Field(value: self.closedDays, fieldNumber: 20)
-    }
+    try { if let v = self._keepClosedOnHolidays {
+      try visitor.visitSingularBoolField(value: v, fieldNumber: 20)
+    } }()
     try { if let v = self._defaultOpenTimeSec {
       try visitor.visitSingularUInt32Field(value: v, fieldNumber: 21)
     } }()
@@ -219,7 +228,7 @@ extension BlueLockConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplement
   public static func ==(lhs: BlueLockConfig, rhs: BlueLockConfig) -> Bool {
     if lhs.openSchedules != rhs.openSchedules {return false}
     if lhs._openScheduleByUser != rhs._openScheduleByUser {return false}
-    if lhs.closedDays != rhs.closedDays {return false}
+    if lhs._keepClosedOnHolidays != rhs._keepClosedOnHolidays {return false}
     if lhs._defaultOpenTimeSec != rhs._defaultOpenTimeSec {return false}
     if lhs._extendedOpenTimeSec != rhs._extendedOpenTimeSec {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}

package/swift/BlueSDK.pb.swift

@@ -316,6 +316,110 @@ public struct BlueDeviceInfo {
   fileprivate var _manufacturerInfo: BlueBleManufacturerInfo? = nil
 }
 
+public struct BlueAccessCredential {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  public var credentialID: BlueCredentialId {
+    get {return _credentialID ?? BlueCredentialId()}
+    set {_credentialID = newValue}
+  }
+  /// Returns true if `credentialID` has been explicitly set.
+  public var hasCredentialID: Bool {return self._credentialID != nil}
+  /// Clears the value of `credentialID`. Subsequent reads from it will return its default value.
+  public mutating func clearCredentialID() {self._credentialID = nil}
+
+  public var credentialType: BlueCredentialType {
+    get {return _credentialType ?? .regular}
+    set {_credentialType = newValue}
+  }
+  /// Returns true if `credentialType` has been explicitly set.
+  public var hasCredentialType: Bool {return self._credentialType != nil}
+  /// Clears the value of `credentialType`. Subsequent reads from it will return its default value.
+  public mutating func clearCredentialType() {self._credentialType = nil}
+
+  public var validFrom: BlueLocalTimestamp {
+    get {return _validFrom ?? BlueLocalTimestamp()}
+    set {_validFrom = newValue}
+  }
+  /// Returns true if `validFrom` has been explicitly set.
+  public var hasValidFrom: Bool {return self._validFrom != nil}
+  /// Clears the value of `validFrom`. Subsequent reads from it will return its default value.
+  public mutating func clearValidFrom() {self._validFrom = nil}
+
+  public var validTo: BlueLocalTimestamp {
+    get {return _validTo ?? BlueLocalTimestamp()}
+    set {_validTo = newValue}
+  }
+  /// Returns true if `validTo` has been explicitly set.
+  public var hasValidTo: Bool {return self._validTo != nil}
+  /// Clears the value of `validTo`. Subsequent reads from it will return its default value.
+  public mutating func clearValidTo() {self._validTo = nil}
+
+  public var privateKey: Data {
+    get {return _privateKey ?? Data()}
+    set {_privateKey = newValue}
+  }
+  /// Returns true if `privateKey` has been explicitly set.
+  public var hasPrivateKey: Bool {return self._privateKey != nil}
+  /// Clears the value of `privateKey`. Subsequent reads from it will return its default value.
+  public mutating func clearPrivateKey() {self._privateKey = nil}
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+
+  fileprivate var _credentialID: BlueCredentialId? = nil
+  fileprivate var _credentialType: BlueCredentialType? = nil
+  fileprivate var _validFrom: BlueLocalTimestamp? = nil
+  fileprivate var _validTo: BlueLocalTimestamp? = nil
+  fileprivate var _privateKey: Data? = nil
+}
+
+public struct BlueAccessDevice {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  public var deviceID: String {
+    get {return _deviceID ?? String()}
+    set {_deviceID = newValue}
+  }
+  /// Returns true if `deviceID` has been explicitly set.
+  public var hasDeviceID: Bool {return self._deviceID != nil}
+  /// Clears the value of `deviceID`. Subsequent reads from it will return its default value.
+  public mutating func clearDeviceID() {self._deviceID = nil}
+
+  public var name: String {
+    get {return _name ?? String()}
+    set {_name = newValue}
+  }
+  /// Returns true if `name` has been explicitly set.
+  public var hasName: Bool {return self._name != nil}
+  /// Clears the value of `name`. Subsequent reads from it will return its default value.
+  public mutating func clearName() {self._name = nil}
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+
+  fileprivate var _deviceID: String? = nil
+  fileprivate var _name: String? = nil
+}
+
+public struct BlueAccessDeviceList {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  public var devices: [BlueAccessDevice] = []
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+}
+
 #if swift(>=5.5) && canImport(_Concurrency)
 extension BlueDeviceType: @unchecked Sendable {}
 extension BlueI18n: @unchecked Sendable {}
@@ -323,6 +427,9 @@ extension BlueDeviceDetailsBluetooth: @unchecked Sendable {}
 extension BlueDeviceDetailsUWB: @unchecked Sendable {}
 extension BlueDeviceInfo: @unchecked Sendable {}
 extension BlueDeviceInfo.OneOf_Details: @unchecked Sendable {}
+extension BlueAccessCredential: @unchecked Sendable {}
+extension BlueAccessDevice: @unchecked Sendable {}
+extension BlueAccessDeviceList: @unchecked Sendable {}
 #endif  // swift(>=5.5) && canImport(_Concurrency)
 
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
@@ -622,3 +729,157 @@ extension BlueDeviceInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplement
     return true
   }
 }
+
+extension BlueAccessCredential: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueAccessCredential"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "credentialId"),
+    2: .same(proto: "credentialType"),
+    3: .same(proto: "validFrom"),
+    4: .same(proto: "validTo"),
+    5: .same(proto: "privateKey"),
+  ]
+
+  public var isInitialized: Bool {
+    if self._credentialID == nil {return false}
+    if self._credentialType == nil {return false}
+    if self._privateKey == nil {return false}
+    if let v = self._credentialID, !v.isInitialized {return false}
+    if let v = self._validFrom, !v.isInitialized {return false}
+    if let v = self._validTo, !v.isInitialized {return false}
+    return true
+  }
+
+  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularMessageField(value: &self._credentialID) }()
+      case 2: try { try decoder.decodeSingularEnumField(value: &self._credentialType) }()
+      case 3: try { try decoder.decodeSingularMessageField(value: &self._validFrom) }()
+      case 4: try { try decoder.decodeSingularMessageField(value: &self._validTo) }()
+      case 5: try { try decoder.decodeSingularBytesField(value: &self._privateKey) }()
+      default: break
+      }
+    }
+  }
+
+  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._credentialID {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._credentialType {
+      try visitor.visitSingularEnumField(value: v, fieldNumber: 2)
+    } }()
+    try { if let v = self._validFrom {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
+    } }()
+    try { if let v = self._validTo {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
+    } }()
+    try { if let v = self._privateKey {
+      try visitor.visitSingularBytesField(value: v, fieldNumber: 5)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueAccessCredential, rhs: BlueAccessCredential) -> Bool {
+    if lhs._credentialID != rhs._credentialID {return false}
+    if lhs._credentialType != rhs._credentialType {return false}
+    if lhs._validFrom != rhs._validFrom {return false}
+    if lhs._validTo != rhs._validTo {return false}
+    if lhs._privateKey != rhs._privateKey {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueAccessDevice: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueAccessDevice"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "deviceId"),
+    2: .same(proto: "name"),
+  ]
+
+  public var isInitialized: Bool {
+    if self._deviceID == nil {return false}
+    return true
+  }
+
+  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularStringField(value: &self._deviceID) }()
+      case 2: try { try decoder.decodeSingularStringField(value: &self._name) }()
+      default: break
+      }
+    }
+  }
+
+  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._deviceID {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._name {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueAccessDevice, rhs: BlueAccessDevice) -> Bool {
+    if lhs._deviceID != rhs._deviceID {return false}
+    if lhs._name != rhs._name {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueAccessDeviceList: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueAccessDeviceList"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "devices"),
+  ]
+
+  public var isInitialized: Bool {
+    if !SwiftProtobuf.Internal.areAllInitialized(self.devices) {return false}
+    return true
+  }
+
+  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeRepeatedMessageField(value: &self.devices) }()
+      default: break
+      }
+    }
+  }
+
+  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.devices.isEmpty {
+      try visitor.visitRepeatedMessageField(value: self.devices, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueAccessDeviceList, rhs: BlueAccessDeviceList) -> Bool {
+    if lhs.devices != rhs.devices {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}

package/swift/BlueSystem.pb.swift

@@ -781,51 +781,6 @@ public struct BlueSystemStatus {
   /// Clears the value of `settings`. Subsequent reads from it will return its default value.
   public mutating func clearSettings() {_uniqueStorage()._settings = nil}
 
-  public var blacklistEntriesCount: UInt32 {
-    get {return _storage._blacklistEntriesCount ?? 0}
-    set {_uniqueStorage()._blacklistEntriesCount = newValue}
-  }
-  /// Returns true if `blacklistEntriesCount` has been explicitly set.
-  public var hasBlacklistEntriesCount: Bool {return _storage._blacklistEntriesCount != nil}
-  /// Clears the value of `blacklistEntriesCount`. Subsequent reads from it will return its default value.
-  public mutating func clearBlacklistEntriesCount() {_uniqueStorage()._blacklistEntriesCount = nil}
-
-  public var eventLogEntriesCount: UInt32 {
-    get {return _storage._eventLogEntriesCount ?? 0}
-    set {_uniqueStorage()._eventLogEntriesCount = newValue}
-  }
-  /// Returns true if `eventLogEntriesCount` has been explicitly set.
-  public var hasEventLogEntriesCount: Bool {return _storage._eventLogEntriesCount != nil}
-  /// Clears the value of `eventLogEntriesCount`. Subsequent reads from it will return its default value.
-  public mutating func clearEventLogEntriesCount() {_uniqueStorage()._eventLogEntriesCount = nil}
-
-  public var eventLogSequenceID: UInt32 {
-    get {return _storage._eventLogSequenceID ?? 0}
-    set {_uniqueStorage()._eventLogSequenceID = newValue}
-  }
-  /// Returns true if `eventLogSequenceID` has been explicitly set.
-  public var hasEventLogSequenceID: Bool {return _storage._eventLogSequenceID != nil}
-  /// Clears the value of `eventLogSequenceID`. Subsequent reads from it will return its default value.
-  public mutating func clearEventLogSequenceID() {_uniqueStorage()._eventLogSequenceID = nil}
-
-  public var systemLogEntriesCount: UInt32 {
-    get {return _storage._systemLogEntriesCount ?? 0}
-    set {_uniqueStorage()._systemLogEntriesCount = newValue}
-  }
-  /// Returns true if `systemLogEntriesCount` has been explicitly set.
-  public var hasSystemLogEntriesCount: Bool {return _storage._systemLogEntriesCount != nil}
-  /// Clears the value of `systemLogEntriesCount`. Subsequent reads from it will return its default value.
-  public mutating func clearSystemLogEntriesCount() {_uniqueStorage()._systemLogEntriesCount = nil}
-
-  public var systemLogSequenceID: UInt32 {
-    get {return _storage._systemLogSequenceID ?? 0}
-    set {_uniqueStorage()._systemLogSequenceID = newValue}
-  }
-  /// Returns true if `systemLogSequenceID` has been explicitly set.
-  public var hasSystemLogSequenceID: Bool {return _storage._systemLogSequenceID != nil}
-  /// Clears the value of `systemLogSequenceID`. Subsequent reads from it will return its default value.
-  public mutating func clearSystemLogSequenceID() {_uniqueStorage()._systemLogSequenceID = nil}
-
   /// -- Custom
   public var lock: BlueLockStatus {
     get {return _storage._lock ?? BlueLockStatus()}
@@ -1932,12 +1887,7 @@ extension BlueSystemStatus: SwiftProtobuf.Message, SwiftProtobuf._MessageImpleme
     6: .same(proto: "applicationVersion"),
     7: .same(proto: "localTime"),
     8: .same(proto: "settings"),
-    9: .same(proto: "blacklistEntriesCount"),
-    10: .same(proto: "eventLogEntriesCount"),
-    11: .same(proto: "eventLogSequenceId"),
-    12: .same(proto: "systemLogEntriesCount"),
-    13: .same(proto: "systemLogSequenceId"),
-    14: .same(proto: "lock"),
+    9: .same(proto: "lock"),
   ]
 
   fileprivate class _StorageClass {
@@ -1949,11 +1899,6 @@ extension BlueSystemStatus: SwiftProtobuf.Message, SwiftProtobuf._MessageImpleme
     var _applicationVersion: UInt32? = nil
     var _localTime: BlueLocalTimestamp? = nil
     var _settings: BlueSystemSettings? = nil
-    var _blacklistEntriesCount: UInt32? = nil
-    var _eventLogEntriesCount: UInt32? = nil
-    var _eventLogSequenceID: UInt32? = nil
-    var _systemLogEntriesCount: UInt32? = nil
-    var _systemLogSequenceID: UInt32? = nil
     var _lock: BlueLockStatus? = nil
 
     static let defaultInstance = _StorageClass()
@@ -1969,11 +1914,6 @@ extension BlueSystemStatus: SwiftProtobuf.Message, SwiftProtobuf._MessageImpleme
       _applicationVersion = source._applicationVersion
       _localTime = source._localTime
       _settings = source._settings
-      _blacklistEntriesCount = source._blacklistEntriesCount
-      _eventLogEntriesCount = source._eventLogEntriesCount
-      _eventLogSequenceID = source._eventLogSequenceID
-      _systemLogEntriesCount = source._systemLogEntriesCount
-      _systemLogSequenceID = source._systemLogSequenceID
       _lock = source._lock
     }
   }
@@ -1995,11 +1935,6 @@ extension BlueSystemStatus: SwiftProtobuf.Message, SwiftProtobuf._MessageImpleme
       if _storage._applicationVersion == nil {return false}
       if _storage._localTime == nil {return false}
       if _storage._settings == nil {return false}
-      if _storage._blacklistEntriesCount == nil {return false}
-      if _storage._eventLogEntriesCount == nil {return false}
-      if _storage._eventLogSequenceID == nil {return false}
-      if _storage._systemLogEntriesCount == nil {return false}
-      if _storage._systemLogSequenceID == nil {return false}
       if let v = _storage._localTime, !v.isInitialized {return false}
       if let v = _storage._settings, !v.isInitialized {return false}
       if let v = _storage._lock, !v.isInitialized {return false}
@@ -2023,12 +1958,7 @@ extension BlueSystemStatus: SwiftProtobuf.Message, SwiftProtobuf._MessageImpleme
         case 6: try { try decoder.decodeSingularUInt32Field(value: &_storage._applicationVersion) }()
         case 7: try { try decoder.decodeSingularMessageField(value: &_storage._localTime) }()
         case 8: try { try decoder.decodeSingularMessageField(value: &_storage._settings) }()
-        case 9: try { try decoder.decodeSingularUInt32Field(value: &_storage._blacklistEntriesCount) }()
-        case 10: try { try decoder.decodeSingularUInt32Field(value: &_storage._eventLogEntriesCount) }()
-        case 11: try { try decoder.decodeSingularUInt32Field(value: &_storage._eventLogSequenceID) }()
-        case 12: try { try decoder.decodeSingularUInt32Field(value: &_storage._systemLogEntriesCount) }()
-        case 13: try { try decoder.decodeSingularUInt32Field(value: &_storage._systemLogSequenceID) }()
-        case 14: try { try decoder.decodeSingularMessageField(value: &_storage._lock) }()
+        case 9: try { try decoder.decodeSingularMessageField(value: &_storage._lock) }()
         default: break
         }
       }
@@ -2065,23 +1995,8 @@ extension BlueSystemStatus: SwiftProtobuf.Message, SwiftProtobuf._MessageImpleme
       try { if let v = _storage._settings {
         try visitor.visitSingularMessageField(value: v, fieldNumber: 8)
       } }()
-      try { if let v = _storage._blacklistEntriesCount {
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 9)
-      } }()
-      try { if let v = _storage._eventLogEntriesCount {
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 10)
-      } }()
-      try { if let v = _storage._eventLogSequenceID {
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 11)
-      } }()
-      try { if let v = _storage._systemLogEntriesCount {
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 12)
-      } }()
-      try { if let v = _storage._systemLogSequenceID {
-        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 13)
-      } }()
       try { if let v = _storage._lock {
-        try visitor.visitSingularMessageField(value: v, fieldNumber: 14)
+        try visitor.visitSingularMessageField(value: v, fieldNumber: 9)
       } }()
     }
     try unknownFields.traverse(visitor: &visitor)
@@ -2100,11 +2015,6 @@ extension BlueSystemStatus: SwiftProtobuf.Message, SwiftProtobuf._MessageImpleme
         if _storage._applicationVersion != rhs_storage._applicationVersion {return false}
         if _storage._localTime != rhs_storage._localTime {return false}
         if _storage._settings != rhs_storage._settings {return false}
-        if _storage._blacklistEntriesCount != rhs_storage._blacklistEntriesCount {return false}
-        if _storage._eventLogEntriesCount != rhs_storage._eventLogEntriesCount {return false}
-        if _storage._eventLogSequenceID != rhs_storage._eventLogSequenceID {return false}
-        if _storage._systemLogEntriesCount != rhs_storage._systemLogEntriesCount {return false}
-        if _storage._systemLogSequenceID != rhs_storage._systemLogSequenceID {return false}
         if _storage._lock != rhs_storage._lock {return false}
         return true
       }