@blueid/access-proto 0.13.0

package/swift/BlueSystem.pb.swift

@@ -0,0 +1,2489 @@
+// DO NOT EDIT.
+// swift-format-ignore-file
+//
+// Generated by the Swift generator plugin for the protocol buffer compiler.
+// Source: BlueSystem.proto
+//
+// For information on using the generated types, please see the documentation:
+//   https://github.com/apple/swift-protobuf/
+
+import Foundation
+import SwiftProtobuf
+
+// If the compiler emits an error on this type, it is because this file
+// was generated by a version of the `protoc` Swift plug-in that is
+// incompatible with the version of SwiftProtobuf to which you are linking.
+// Please ensure that you are building against the same version of the API
+// that was used to generate this file.
+fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck {
+  struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {}
+  typealias Version = _2
+}
+
+public enum BlueOnlineMode: SwiftProtobuf.Enum {
+  public typealias RawValue = Int
+
+  /// Offline mode
+  case offlineMode // = 0
+
+  /// Wifi is manually re-connected whenever required
+  case manualWifi // = 1
+
+  /// Wifi is always connected and re-connects automatically
+  case alwaysOnWifi // = 2
+
+  /// A LAN connection is available that shall be used
+  case useLan // = 3
+
+  public init() {
+    self = .offlineMode
+  }
+
+  public init?(rawValue: Int) {
+    switch rawValue {
+    case 0: self = .offlineMode
+    case 1: self = .manualWifi
+    case 2: self = .alwaysOnWifi
+    case 3: self = .useLan
+    default: return nil
+    }
+  }
+
+  public var rawValue: Int {
+    switch self {
+    case .offlineMode: return 0
+    case .manualWifi: return 1
+    case .alwaysOnWifi: return 2
+    case .useLan: return 3
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension BlueOnlineMode: CaseIterable {
+  // Support synthesized by the compiler.
+}
+
+#endif  // swift(>=4.2)
+
+public struct BlueTimeOffsetPeriod {
+  // 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.
+
+  /// UTC-epoch when this shift occurs
+  public var epoch: UInt32 {
+    get {return _epoch ?? 0}
+    set {_epoch = newValue}
+  }
+  /// Returns true if `epoch` has been explicitly set.
+  public var hasEpoch: Bool {return self._epoch != nil}
+  /// Clears the value of `epoch`. Subsequent reads from it will return its default value.
+  public mutating func clearEpoch() {self._epoch = nil}
+
+  /// The time offset in minutes, negative or positive
+  public var offset: Int32 {
+    get {return _offset ?? 0}
+    set {_offset = newValue}
+  }
+  /// Returns true if `offset` has been explicitly set.
+  public var hasOffset: Bool {return self._offset != nil}
+  /// Clears the value of `offset`. Subsequent reads from it will return its default value.
+  public mutating func clearOffset() {self._offset = nil}
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+
+  fileprivate var _epoch: UInt32? = nil
+  fileprivate var _offset: Int32? = nil
+}
+
+public struct BlueBaseConfig {
+  // 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.
+
+  /// The time offsets that get shifted automatically
+  public var timeOffsetPeriods: [BlueTimeOffsetPeriod] = []
+
+  /// If enabled this will check the system-status every 24-hours and
+  /// react accordingly ie like when battery is running low opening the lock
+  /// and logging accordingly etc
+  public var autoCheckSystemStatus: Bool {
+    get {return _autoCheckSystemStatus ?? false}
+    set {_autoCheckSystemStatus = newValue}
+  }
+  /// Returns true if `autoCheckSystemStatus` has been explicitly set.
+  public var hasAutoCheckSystemStatus: Bool {return self._autoCheckSystemStatus != nil}
+  /// Clears the value of `autoCheckSystemStatus`. Subsequent reads from it will return its default value.
+  public mutating func clearAutoCheckSystemStatus() {self._autoCheckSystemStatus = nil}
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+
+  fileprivate var _autoCheckSystemStatus: Bool? = nil
+}
+
+public struct BlueBleConfig {
+  // 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.
+
+  /// Whether ble is enabled or not
+  public var isAdvertising: Bool {
+    get {return _isAdvertising ?? true}
+    set {_isAdvertising = newValue}
+  }
+  /// Returns true if `isAdvertising` has been explicitly set.
+  public var hasIsAdvertising: Bool {return self._isAdvertising != nil}
+  /// Clears the value of `isAdvertising`. Subsequent reads from it will return its default value.
+  public mutating func clearIsAdvertising() {self._isAdvertising = nil}
+
+  /// Optional schedule on when ble advertising is enabled, if none
+  /// set then ble is always on when enabled
+  public var advertisingSchedules: [BlueLocalTimeSchedule] = []
+
+  /// Index of advertising schedules (starting at zero) where it should
+  /// use the max power level available for broader reach
+  public var maxPowerAdvertisingSchedulesIndices: [UInt32] = []
+
+  /// The desired advertising interval in ms
+  public var advertisingIntervalMs: UInt32 {
+    get {return _advertisingIntervalMs ?? 500}
+    set {_advertisingIntervalMs = newValue}
+  }
+  /// Returns true if `advertisingIntervalMs` has been explicitly set.
+  public var hasAdvertisingIntervalMs: Bool {return self._advertisingIntervalMs != nil}
+  /// Clears the value of `advertisingIntervalMs`. Subsequent reads from it will return its default value.
+  public mutating func clearAdvertisingIntervalMs() {self._advertisingIntervalMs = nil}
+
+  /// The maximal connection timeout per connection in milliseconds
+  public var maxConnectionTimeoutMs: UInt32 {
+    get {return _maxConnectionTimeoutMs ?? 3000}
+    set {_maxConnectionTimeoutMs = newValue}
+  }
+  /// Returns true if `maxConnectionTimeoutMs` has been explicitly set.
+  public var hasMaxConnectionTimeoutMs: Bool {return self._maxConnectionTimeoutMs != nil}
+  /// Clears the value of `maxConnectionTimeoutMs`. Subsequent reads from it will return its default value.
+  public mutating func clearMaxConnectionTimeoutMs() {self._maxConnectionTimeoutMs = nil}
+
+  /// The actual tx power level used for bluetooth from (0 - lowest) to 7
+  /// (highest)
+  public var txPowerLevel: UInt32 {
+    get {return _txPowerLevel ?? 3}
+    set {_txPowerLevel = newValue}
+  }
+  /// Returns true if `txPowerLevel` has been explicitly set.
+  public var hasTxPowerLevel: Bool {return self._txPowerLevel != nil}
+  /// Clears the value of `txPowerLevel`. Subsequent reads from it will return its default value.
+  public mutating func clearTxPowerLevel() {self._txPowerLevel = nil}
+
+  /// The advertised tx power level at 1 meter in decibel (-XX - +XX)
+  public var advertisedTxPower1Meter: Int32 {
+    get {return _advertisedTxPower1Meter ?? -77}
+    set {_advertisedTxPower1Meter = newValue}
+  }
+  /// Returns true if `advertisedTxPower1Meter` has been explicitly set.
+  public var hasAdvertisedTxPower1Meter: Bool {return self._advertisedTxPower1Meter != nil}
+  /// Clears the value of `advertisedTxPower1Meter`. Subsequent reads from it will return its default value.
+  public mutating func clearAdvertisedTxPower1Meter() {self._advertisedTxPower1Meter = nil}
+
+  /// If set then advertises as IBeacon otherwise uses regular advertising
+  public var isIbeaconAdvertisement: Bool {
+    get {return _isIbeaconAdvertisement ?? false}
+    set {_isIbeaconAdvertisement = newValue}
+  }
+  /// Returns true if `isIbeaconAdvertisement` has been explicitly set.
+  public var hasIsIbeaconAdvertisement: Bool {return self._isIbeaconAdvertisement != nil}
+  /// Clears the value of `isIbeaconAdvertisement`. Subsequent reads from it will return its default value.
+  public mutating func clearIsIbeaconAdvertisement() {self._isIbeaconAdvertisement = nil}
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+
+  fileprivate var _isAdvertising: Bool? = nil
+  fileprivate var _advertisingIntervalMs: UInt32? = nil
+  fileprivate var _maxConnectionTimeoutMs: UInt32? = nil
+  fileprivate var _txPowerLevel: UInt32? = nil
+  fileprivate var _advertisedTxPower1Meter: Int32? = nil
+  fileprivate var _isIbeaconAdvertisement: Bool? = nil
+}
+
+public struct BlueOnlineConfig {
+  // 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.
+
+  /// The online mode
+  public var mode: BlueOnlineMode {
+    get {return _mode ?? .offlineMode}
+    set {_mode = newValue}
+  }
+  /// Returns true if `mode` has been explicitly set.
+  public var hasMode: Bool {return self._mode != nil}
+  /// Clears the value of `mode`. Subsequent reads from it will return its default value.
+  public mutating func clearMode() {self._mode = nil}
+
+  /// Schedules when it should go online for updating. Only takes effect if
+  /// online mode is set to manual wifi. The end time is not used.
+  public var connectSchedules: [BlueLocalTimeSchedule] = []
+
+  /// The SSID of the wifi network
+  public var wifiSsid: String {
+    get {return _wifiSsid ?? String()}
+    set {_wifiSsid = newValue}
+  }
+  /// Returns true if `wifiSsid` has been explicitly set.
+  public var hasWifiSsid: Bool {return self._wifiSsid != nil}
+  /// Clears the value of `wifiSsid`. Subsequent reads from it will return its default value.
+  public mutating func clearWifiSsid() {self._wifiSsid = nil}
+
+  /// The wifi password
+  public var wifiPassword: String {
+    get {return _wifiPassword ?? String()}
+    set {_wifiPassword = newValue}
+  }
+  /// Returns true if `wifiPassword` has been explicitly set.
+  public var hasWifiPassword: Bool {return self._wifiPassword != nil}
+  /// Clears the value of `wifiPassword`. Subsequent reads from it will return its default value.
+  public mutating func clearWifiPassword() {self._wifiPassword = nil}
+
+  /// Default timeout for online connections
+  public var timeoutSec: UInt32 {
+    get {return _timeoutSec ?? 30}
+    set {_timeoutSec = newValue}
+  }
+  /// Returns true if `timeoutSec` has been explicitly set.
+  public var hasTimeoutSec: Bool {return self._timeoutSec != nil}
+  /// Clears the value of `timeoutSec`. Subsequent reads from it will return its default value.
+  public mutating func clearTimeoutSec() {self._timeoutSec = nil}
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+
+  fileprivate var _mode: BlueOnlineMode? = nil
+  fileprivate var _wifiSsid: String? = nil
+  fileprivate var _wifiPassword: String? = nil
+  fileprivate var _timeoutSec: UInt32? = nil
+}
+
+public struct BlueAccessConfig {
+  // 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.
+
+  /// The device's unique access id
+  public var id: UInt32 {
+    get {return _id ?? 1}
+    set {_id = newValue}
+  }
+  /// Returns true if `id` has been explicitly set.
+  public var hasID: Bool {return self._id != nil}
+  /// Clears the value of `id`. Subsequent reads from it will return its default value.
+  public mutating func clearID() {self._id = nil}
+
+  /// The site id bound to this device
+  public var siteID: UInt32 {
+    get {return _siteID ?? 1}
+    set {_siteID = newValue}
+  }
+  /// Returns true if `siteID` has been explicitly set.
+  public var hasSiteID: Bool {return self._siteID != nil}
+  /// Clears the value of `siteID`. Subsequent reads from it will return its default value.
+  public mutating func clearSiteID() {self._siteID = nil}
+
+  /// The access groups this device is part of
+  public var groupIds: [UInt32] = []
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+
+  fileprivate var _id: UInt32? = nil
+  fileprivate var _siteID: UInt32? = nil
+}
+
+///
+/// -- Oss SecureId --
+public struct BlueOssConfig {
+  // 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.
+
+  /// The mifare aes-key for reading the oss secure id application, default is
+  /// the oss sid demo key
+  public var sidMifareAesKey: Data {
+    get {return _sidMifareAesKey ?? Data([255, 238, 221, 204, 187, 170, 153, 136, 119, 102, 85, 68, 51, 34, 17, 0])}
+    set {_sidMifareAesKey = newValue}
+  }
+  /// Returns true if `sidMifareAesKey` has been explicitly set.
+  public var hasSidMifareAesKey: Bool {return self._sidMifareAesKey != nil}
+  /// Clears the value of `sidMifareAesKey`. Subsequent reads from it will return its default value.
+  public mutating func clearSidMifareAesKey() {self._sidMifareAesKey = nil}
+
+  /// The mifare application id for the oss secure id application, default is the
+  /// oss sid default aid. A value of 0 disables Oss Sid Mifare support.
+  public var sidMifareAid: UInt32 {
+    get {return _sidMifareAid ?? 16076801}
+    set {_sidMifareAid = newValue}
+  }
+  /// Returns true if `sidMifareAid` has been explicitly set.
+  public var hasSidMifareAid: Bool {return self._sidMifareAid != nil}
+  /// Clears the value of `sidMifareAid`. Subsequent reads from it will return its default value.
+  public mutating func clearSidMifareAid() {self._sidMifareAid = nil}
+
+  /// If set the system will try to connect online to refresh the presented oss
+  /// offline card if required as well as it will try to get and put the latest
+  /// blacklist on the card
+  public var soUpdater: Bool {
+    get {return _soUpdater ?? false}
+    set {_soUpdater = newValue}
+  }
+  /// Returns true if `soUpdater` has been explicitly set.
+  public var hasSoUpdater: Bool {return self._soUpdater != nil}
+  /// Clears the value of `soUpdater`. Subsequent reads from it will return its default value.
+  public mutating func clearSoUpdater() {self._soUpdater = nil}
+
+  /// If set the system will try to connect online if there are any events on a
+  /// presented card and transfer all events online
+  public var soPushEvents: Bool {
+    get {return _soPushEvents ?? false}
+    set {_soPushEvents = newValue}
+  }
+  /// Returns true if `soPushEvents` has been explicitly set.
+  public var hasSoPushEvents: Bool {return self._soPushEvents != nil}
+  /// Clears the value of `soPushEvents`. Subsequent reads from it will return its default value.
+  public mutating func clearSoPushEvents() {self._soPushEvents = nil}
+
+  /// If set the system will transfer pending events to an offline card
+  public var soWritePendingEvents: Bool {
+    get {return _soWritePendingEvents ?? true}
+    set {_soWritePendingEvents = newValue}
+  }
+  /// Returns true if `soWritePendingEvents` has been explicitly set.
+  public var hasSoWritePendingEvents: Bool {return self._soWritePendingEvents != nil}
+  /// Clears the value of `soWritePendingEvents`. Subsequent reads from it will return its default value.
+  public mutating func clearSoWritePendingEvents() {self._soWritePendingEvents = nil}
+
+  /// If set the system will update from the blacklist of an offline card
+  public var soUpdateFromBlacklist: Bool {
+    get {return _soUpdateFromBlacklist ?? true}
+    set {_soUpdateFromBlacklist = newValue}
+  }
+  /// Returns true if `soUpdateFromBlacklist` has been explicitly set.
+  public var hasSoUpdateFromBlacklist: Bool {return self._soUpdateFromBlacklist != nil}
+  /// Clears the value of `soUpdateFromBlacklist`. Subsequent reads from it will return its default value.
+  public mutating func clearSoUpdateFromBlacklist() {self._soUpdateFromBlacklist = nil}
+
+  /// The mifare aes-key for reading/writing the oss offline application, default
+  /// is the oss so demo key
+  public var soMifareAesKey: Data {
+    get {return _soMifareAesKey ?? Data([16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31])}
+    set {_soMifareAesKey = newValue}
+  }
+  /// Returns true if `soMifareAesKey` has been explicitly set.
+  public var hasSoMifareAesKey: Bool {return self._soMifareAesKey != nil}
+  /// Clears the value of `soMifareAesKey`. Subsequent reads from it will return its default value.
+  public mutating func clearSoMifareAesKey() {self._soMifareAesKey = nil}
+
+  /// The mifare application id for the oss offline application, default is the
+  /// oss so default aid. A value of 0 disables Oss So Mifare support.
+  public var soMifareAid: UInt32 {
+    get {return _soMifareAid ?? 16076800}
+    set {_soMifareAid = newValue}
+  }
+  /// Returns true if `soMifareAid` has been explicitly set.
+  public var hasSoMifareAid: Bool {return self._soMifareAid != nil}
+  /// Clears the value of `soMifareAid`. Subsequent reads from it will return its default value.
+  public mutating func clearSoMifareAid() {self._soMifareAid = nil}
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+
+  fileprivate var _sidMifareAesKey: Data? = nil
+  fileprivate var _sidMifareAid: UInt32? = nil
+  fileprivate var _soUpdater: Bool? = nil
+  fileprivate var _soPushEvents: Bool? = nil
+  fileprivate var _soWritePendingEvents: Bool? = nil
+  fileprivate var _soUpdateFromBlacklist: Bool? = nil
+  fileprivate var _soMifareAesKey: Data? = nil
+  fileprivate var _soMifareAid: UInt32? = nil
+}
+
+public struct BlueSystemConfig {
+  // 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 version: UInt32 {
+    get {return _storage._version ?? 0}
+    set {_uniqueStorage()._version = newValue}
+  }
+  /// Returns true if `version` has been explicitly set.
+  public var hasVersion: Bool {return _storage._version != nil}
+  /// Clears the value of `version`. Subsequent reads from it will return its default value.
+  public mutating func clearVersion() {_uniqueStorage()._version = nil}
+
+  /// -- Base
+  public var base: BlueBaseConfig {
+    get {return _storage._base ?? BlueBaseConfig()}
+    set {_uniqueStorage()._base = newValue}
+  }
+  /// Returns true if `base` has been explicitly set.
+  public var hasBase: Bool {return _storage._base != nil}
+  /// Clears the value of `base`. Subsequent reads from it will return its default value.
+  public mutating func clearBase() {_uniqueStorage()._base = nil}
+
+  public var ble: BlueBleConfig {
+    get {return _storage._ble ?? BlueBleConfig()}
+    set {_uniqueStorage()._ble = newValue}
+  }
+  /// Returns true if `ble` has been explicitly set.
+  public var hasBle: Bool {return _storage._ble != nil}
+  /// Clears the value of `ble`. Subsequent reads from it will return its default value.
+  public mutating func clearBle() {_uniqueStorage()._ble = nil}
+
+  public var online: BlueOnlineConfig {
+    get {return _storage._online ?? BlueOnlineConfig()}
+    set {_uniqueStorage()._online = newValue}
+  }
+  /// Returns true if `online` has been explicitly set.
+  public var hasOnline: Bool {return _storage._online != nil}
+  /// Clears the value of `online`. Subsequent reads from it will return its default value.
+  public mutating func clearOnline() {_uniqueStorage()._online = nil}
+
+  public var access: BlueAccessConfig {
+    get {return _storage._access ?? BlueAccessConfig()}
+    set {_uniqueStorage()._access = newValue}
+  }
+  /// Returns true if `access` has been explicitly set.
+  public var hasAccess: Bool {return _storage._access != nil}
+  /// Clears the value of `access`. Subsequent reads from it will return its default value.
+  public mutating func clearAccess() {_uniqueStorage()._access = nil}
+
+  public var oss: BlueOssConfig {
+    get {return _storage._oss ?? BlueOssConfig()}
+    set {_uniqueStorage()._oss = newValue}
+  }
+  /// Returns true if `oss` has been explicitly set.
+  public var hasOss: Bool {return _storage._oss != nil}
+  /// Clears the value of `oss`. Subsequent reads from it will return its default value.
+  public mutating func clearOss() {_uniqueStorage()._oss = nil}
+
+  /// -- Custom
+  public var lock: BlueLockConfig {
+    get {return _storage._lock ?? BlueLockConfig()}
+    set {_uniqueStorage()._lock = newValue}
+  }
+  /// Returns true if `lock` has been explicitly set.
+  public var hasLock: Bool {return _storage._lock != nil}
+  /// Clears the value of `lock`. Subsequent reads from it will return its default value.
+  public mutating func clearLock() {_uniqueStorage()._lock = nil}
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+
+  fileprivate var _storage = _StorageClass.defaultInstance
+}
+
+public struct BlueSystemTimeUnix {
+  // 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 epoch: UInt32 {
+    get {return _epoch ?? 0}
+    set {_epoch = newValue}
+  }
+  /// Returns true if `epoch` has been explicitly set.
+  public var hasEpoch: Bool {return self._epoch != nil}
+  /// Clears the value of `epoch`. Subsequent reads from it will return its default value.
+  public mutating func clearEpoch() {self._epoch = nil}
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+
+  fileprivate var _epoch: UInt32? = nil
+}
+
+public struct BlueSystemUpdate {
+  // 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 config: BlueSystemConfig {
+    get {return _config ?? BlueSystemConfig()}
+    set {_config = newValue}
+  }
+  /// Returns true if `config` has been explicitly set.
+  public var hasConfig: Bool {return self._config != nil}
+  /// Clears the value of `config`. Subsequent reads from it will return its default value.
+  public mutating func clearConfig() {self._config = nil}
+
+  public var timeUnix: BlueSystemTimeUnix {
+    get {return _timeUnix ?? BlueSystemTimeUnix()}
+    set {_timeUnix = newValue}
+  }
+  /// Returns true if `timeUnix` has been explicitly set.
+  public var hasTimeUnix: Bool {return self._timeUnix != nil}
+  /// Clears the value of `timeUnix`. Subsequent reads from it will return its default value.
+  public mutating func clearTimeUnix() {self._timeUnix = nil}
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+
+  fileprivate var _config: BlueSystemConfig? = nil
+  fileprivate var _timeUnix: BlueSystemTimeUnix? = nil
+}
+
+public struct BlueSystemSettings {
+  // 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 blacklistMaxEntriesCount: UInt32 {
+    get {return _blacklistMaxEntriesCount ?? 0}
+    set {_blacklistMaxEntriesCount = newValue}
+  }
+  /// Returns true if `blacklistMaxEntriesCount` has been explicitly set.
+  public var hasBlacklistMaxEntriesCount: Bool {return self._blacklistMaxEntriesCount != nil}
+  /// Clears the value of `blacklistMaxEntriesCount`. Subsequent reads from it will return its default value.
+  public mutating func clearBlacklistMaxEntriesCount() {self._blacklistMaxEntriesCount = nil}
+
+  public var blacklistEntriesCount: UInt32 {
+    get {return _blacklistEntriesCount ?? 0}
+    set {_blacklistEntriesCount = newValue}
+  }
+  /// Returns true if `blacklistEntriesCount` has been explicitly set.
+  public var hasBlacklistEntriesCount: Bool {return self._blacklistEntriesCount != nil}
+  /// Clears the value of `blacklistEntriesCount`. Subsequent reads from it will return its default value.
+  public mutating func clearBlacklistEntriesCount() {self._blacklistEntriesCount = nil}
+
+  public var eventLogMaxEntriesCount: UInt32 {
+    get {return _eventLogMaxEntriesCount ?? 0}
+    set {_eventLogMaxEntriesCount = newValue}
+  }
+  /// Returns true if `eventLogMaxEntriesCount` has been explicitly set.
+  public var hasEventLogMaxEntriesCount: Bool {return self._eventLogMaxEntriesCount != nil}
+  /// Clears the value of `eventLogMaxEntriesCount`. Subsequent reads from it will return its default value.
+  public mutating func clearEventLogMaxEntriesCount() {self._eventLogMaxEntriesCount = nil}
+
+  public var eventLogEntriesCount: UInt32 {
+    get {return _eventLogEntriesCount ?? 0}
+    set {_eventLogEntriesCount = newValue}
+  }
+  /// Returns true if `eventLogEntriesCount` has been explicitly set.
+  public var hasEventLogEntriesCount: Bool {return self._eventLogEntriesCount != nil}
+  /// Clears the value of `eventLogEntriesCount`. Subsequent reads from it will return its default value.
+  public mutating func clearEventLogEntriesCount() {self._eventLogEntriesCount = nil}
+
+  public var eventLogSequenceID: UInt32 {
+    get {return _eventLogSequenceID ?? 0}
+    set {_eventLogSequenceID = newValue}
+  }
+  /// Returns true if `eventLogSequenceID` has been explicitly set.
+  public var hasEventLogSequenceID: Bool {return self._eventLogSequenceID != nil}
+  /// Clears the value of `eventLogSequenceID`. Subsequent reads from it will return its default value.
+  public mutating func clearEventLogSequenceID() {self._eventLogSequenceID = nil}
+
+  public var eventLogIndex: UInt32 {
+    get {return _eventLogIndex ?? 0}
+    set {_eventLogIndex = newValue}
+  }
+  /// Returns true if `eventLogIndex` has been explicitly set.
+  public var hasEventLogIndex: Bool {return self._eventLogIndex != nil}
+  /// Clears the value of `eventLogIndex`. Subsequent reads from it will return its default value.
+  public mutating func clearEventLogIndex() {self._eventLogIndex = nil}
+
+  public var systemLogMaxEntriesCount: UInt32 {
+    get {return _systemLogMaxEntriesCount ?? 0}
+    set {_systemLogMaxEntriesCount = newValue}
+  }
+  /// Returns true if `systemLogMaxEntriesCount` has been explicitly set.
+  public var hasSystemLogMaxEntriesCount: Bool {return self._systemLogMaxEntriesCount != nil}
+  /// Clears the value of `systemLogMaxEntriesCount`. Subsequent reads from it will return its default value.
+  public mutating func clearSystemLogMaxEntriesCount() {self._systemLogMaxEntriesCount = nil}
+
+  public var systemLogEntriesCount: UInt32 {
+    get {return _systemLogEntriesCount ?? 0}
+    set {_systemLogEntriesCount = newValue}
+  }
+  /// Returns true if `systemLogEntriesCount` has been explicitly set.
+  public var hasSystemLogEntriesCount: Bool {return self._systemLogEntriesCount != nil}
+  /// Clears the value of `systemLogEntriesCount`. Subsequent reads from it will return its default value.
+  public mutating func clearSystemLogEntriesCount() {self._systemLogEntriesCount = nil}
+
+  public var systemLogSequenceID: UInt32 {
+    get {return _systemLogSequenceID ?? 0}
+    set {_systemLogSequenceID = newValue}
+  }
+  /// Returns true if `systemLogSequenceID` has been explicitly set.
+  public var hasSystemLogSequenceID: Bool {return self._systemLogSequenceID != nil}
+  /// Clears the value of `systemLogSequenceID`. Subsequent reads from it will return its default value.
+  public mutating func clearSystemLogSequenceID() {self._systemLogSequenceID = nil}
+
+  public var systemLogIndex: UInt32 {
+    get {return _systemLogIndex ?? 0}
+    set {_systemLogIndex = newValue}
+  }
+  /// Returns true if `systemLogIndex` has been explicitly set.
+  public var hasSystemLogIndex: Bool {return self._systemLogIndex != nil}
+  /// Clears the value of `systemLogIndex`. Subsequent reads from it will return its default value.
+  public mutating func clearSystemLogIndex() {self._systemLogIndex = nil}
+
+  public var timeWasSet: Bool {
+    get {return _timeWasSet ?? false}
+    set {_timeWasSet = newValue}
+  }
+  /// Returns true if `timeWasSet` has been explicitly set.
+  public var hasTimeWasSet: Bool {return self._timeWasSet != nil}
+  /// Clears the value of `timeWasSet`. Subsequent reads from it will return its default value.
+  public mutating func clearTimeWasSet() {self._timeWasSet = nil}
+
+  public var isBatteryLow: Bool {
+    get {return _isBatteryLow ?? false}
+    set {_isBatteryLow = newValue}
+  }
+  /// Returns true if `isBatteryLow` has been explicitly set.
+  public var hasIsBatteryLow: Bool {return self._isBatteryLow != nil}
+  /// Clears the value of `isBatteryLow`. Subsequent reads from it will return its default value.
+  public mutating func clearIsBatteryLow() {self._isBatteryLow = nil}
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+
+  fileprivate var _blacklistMaxEntriesCount: UInt32? = nil
+  fileprivate var _blacklistEntriesCount: UInt32? = nil
+  fileprivate var _eventLogMaxEntriesCount: UInt32? = nil
+  fileprivate var _eventLogEntriesCount: UInt32? = nil
+  fileprivate var _eventLogSequenceID: UInt32? = nil
+  fileprivate var _eventLogIndex: UInt32? = nil
+  fileprivate var _systemLogMaxEntriesCount: UInt32? = nil
+  fileprivate var _systemLogEntriesCount: UInt32? = nil
+  fileprivate var _systemLogSequenceID: UInt32? = nil
+  fileprivate var _systemLogIndex: UInt32? = nil
+  fileprivate var _timeWasSet: Bool? = nil
+  fileprivate var _isBatteryLow: Bool? = nil
+}
+
+public struct BlueSystemProvisioning {
+  // 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 hardwareType: BlueHardwareType {
+    get {return _hardwareType ?? .testHardware}
+    set {_hardwareType = newValue}
+  }
+  /// Returns true if `hardwareType` has been explicitly set.
+  public var hasHardwareType: Bool {return self._hardwareType != nil}
+  /// Clears the value of `hardwareType`. Subsequent reads from it will return its default value.
+  public mutating func clearHardwareType() {self._hardwareType = nil}
+
+  /// Unique id generated by blueid which identitifies this device (default set
+  /// from BlueSharedDemoKeys)
+  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}
+
+  /// Serial-number which is vendor specific stored as hex
+  public var serialNumber: String {
+    get {return _serialNumber ?? "00000000000000000000"}
+    set {_serialNumber = newValue}
+  }
+  /// Returns true if `serialNumber` has been explicitly set.
+  public var hasSerialNumber: Bool {return self._serialNumber != nil}
+  /// Clears the value of `serialNumber`. Subsequent reads from it will return its default value.
+  public mutating func clearSerialNumber() {self._serialNumber = nil}
+
+  /// Private key used for signing to proof authenticity of this device (default
+  /// set from BlueSharedDemoKeys)
+  public var terminalPrivateKey: Data {
+    get {return _terminalPrivateKey ?? Data()}
+    set {_terminalPrivateKey = newValue}
+  }
+  /// Returns true if `terminalPrivateKey` has been explicitly set.
+  public var hasTerminalPrivateKey: Bool {return self._terminalPrivateKey != nil}
+  /// Clears the value of `terminalPrivateKey`. Subsequent reads from it will return its default value.
+  public mutating func clearTerminalPrivateKey() {self._terminalPrivateKey = nil}
+
+  /// Public key used for verifying signatures being valid on this device
+  /// (default set from BlueSharedDemoKeys)
+  public var signaturePublicKey: Data {
+    get {return _signaturePublicKey ?? Data()}
+    set {_signaturePublicKey = newValue}
+  }
+  /// Returns true if `signaturePublicKey` has been explicitly set.
+  public var hasSignaturePublicKey: Bool {return self._signaturePublicKey != nil}
+  /// Clears the value of `signaturePublicKey`. Subsequent reads from it will return its default value.
+  public mutating func clearSignaturePublicKey() {self._signaturePublicKey = nil}
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+
+  fileprivate var _hardwareType: BlueHardwareType? = nil
+  fileprivate var _deviceID: String? = nil
+  fileprivate var _serialNumber: String? = nil
+  fileprivate var _terminalPrivateKey: Data? = nil
+  fileprivate var _signaturePublicKey: Data? = nil
+}
+
+public struct BlueSystemStatus {
+  // 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 configVersion: UInt32 {
+    get {return _storage._configVersion ?? 0}
+    set {_uniqueStorage()._configVersion = newValue}
+  }
+  /// Returns true if `configVersion` has been explicitly set.
+  public var hasConfigVersion: Bool {return _storage._configVersion != nil}
+  /// Clears the value of `configVersion`. Subsequent reads from it will return its default value.
+  public mutating func clearConfigVersion() {_uniqueStorage()._configVersion = nil}
+
+  public var deviceID: String {
+    get {return _storage._deviceID ?? String()}
+    set {_uniqueStorage()._deviceID = newValue}
+  }
+  /// Returns true if `deviceID` has been explicitly set.
+  public var hasDeviceID: Bool {return _storage._deviceID != nil}
+  /// Clears the value of `deviceID`. Subsequent reads from it will return its default value.
+  public mutating func clearDeviceID() {_uniqueStorage()._deviceID = nil}
+
+  public var serialNumber: String {
+    get {return _storage._serialNumber ?? String()}
+    set {_uniqueStorage()._serialNumber = newValue}
+  }
+  /// Returns true if `serialNumber` has been explicitly set.
+  public var hasSerialNumber: Bool {return _storage._serialNumber != nil}
+  /// Clears the value of `serialNumber`. Subsequent reads from it will return its default value.
+  public mutating func clearSerialNumber() {_uniqueStorage()._serialNumber = nil}
+
+  public var hardwareType: BlueHardwareType {
+    get {return _storage._hardwareType ?? .unknownHardware}
+    set {_uniqueStorage()._hardwareType = newValue}
+  }
+  /// Returns true if `hardwareType` has been explicitly set.
+  public var hasHardwareType: Bool {return _storage._hardwareType != nil}
+  /// Clears the value of `hardwareType`. Subsequent reads from it will return its default value.
+  public mutating func clearHardwareType() {_uniqueStorage()._hardwareType = nil}
+
+  public var batteryLevel: BlueBatteryLevel {
+    get {return _storage._batteryLevel ?? .unknownBattery}
+    set {_uniqueStorage()._batteryLevel = newValue}
+  }
+  /// Returns true if `batteryLevel` has been explicitly set.
+  public var hasBatteryLevel: Bool {return _storage._batteryLevel != nil}
+  /// Clears the value of `batteryLevel`. Subsequent reads from it will return its default value.
+  public mutating func clearBatteryLevel() {_uniqueStorage()._batteryLevel = nil}
+
+  public var applicationVersion: UInt32 {
+    get {return _storage._applicationVersion ?? 0}
+    set {_uniqueStorage()._applicationVersion = newValue}
+  }
+  /// Returns true if `applicationVersion` has been explicitly set.
+  public var hasApplicationVersion: Bool {return _storage._applicationVersion != nil}
+  /// Clears the value of `applicationVersion`. Subsequent reads from it will return its default value.
+  public mutating func clearApplicationVersion() {_uniqueStorage()._applicationVersion = nil}
+
+  public var localTime: BlueLocalTimestamp {
+    get {return _storage._localTime ?? BlueLocalTimestamp()}
+    set {_uniqueStorage()._localTime = newValue}
+  }
+  /// Returns true if `localTime` has been explicitly set.
+  public var hasLocalTime: Bool {return _storage._localTime != nil}
+  /// Clears the value of `localTime`. Subsequent reads from it will return its default value.
+  public mutating func clearLocalTime() {_uniqueStorage()._localTime = nil}
+
+  public var settings: BlueSystemSettings {
+    get {return _storage._settings ?? BlueSystemSettings()}
+    set {_uniqueStorage()._settings = newValue}
+  }
+  /// Returns true if `settings` has been explicitly set.
+  public var hasSettings: Bool {return _storage._settings != nil}
+  /// 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()}
+    set {_uniqueStorage()._lock = newValue}
+  }
+  /// Returns true if `lock` has been explicitly set.
+  public var hasLock: Bool {return _storage._lock != nil}
+  /// Clears the value of `lock`. Subsequent reads from it will return its default value.
+  public mutating func clearLock() {_uniqueStorage()._lock = nil}
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+
+  fileprivate var _storage = _StorageClass.defaultInstance
+}
+
+public struct BlueSystemLogQuery {
+  // 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 maxCount: UInt32 {
+    get {return _maxCount ?? 0}
+    set {_maxCount = newValue}
+  }
+  /// Returns true if `maxCount` has been explicitly set.
+  public var hasMaxCount: Bool {return self._maxCount != nil}
+  /// Clears the value of `maxCount`. Subsequent reads from it will return its default value.
+  public mutating func clearMaxCount() {self._maxCount = nil}
+
+  public var start: BlueSystemLogQuery.OneOf_Start? = nil
+
+  public var sequenceID: UInt32 {
+    get {
+      if case .sequenceID(let v)? = start {return v}
+      return 0
+    }
+    set {start = .sequenceID(newValue)}
+  }
+
+  /// false = starts from tail
+  public var fromHead: Bool {
+    get {
+      if case .fromHead(let v)? = start {return v}
+      return false
+    }
+    set {start = .fromHead(newValue)}
+  }
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public enum OneOf_Start: Equatable {
+    case sequenceID(UInt32)
+    /// false = starts from tail
+    case fromHead(Bool)
+
+  #if !swift(>=4.1)
+    public static func ==(lhs: BlueSystemLogQuery.OneOf_Start, rhs: BlueSystemLogQuery.OneOf_Start) -> Bool {
+      // 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 (lhs, rhs) {
+      case (.sequenceID, .sequenceID): return {
+        guard case .sequenceID(let l) = lhs, case .sequenceID(let r) = rhs else { preconditionFailure() }
+        return l == r
+      }()
+      case (.fromHead, .fromHead): return {
+        guard case .fromHead(let l) = lhs, case .fromHead(let r) = rhs else { preconditionFailure() }
+        return l == r
+      }()
+      default: return false
+      }
+    }
+  #endif
+  }
+
+  public init() {}
+
+  fileprivate var _maxCount: UInt32? = nil
+}
+
+public struct BlueSystemLogEntry {
+  // 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 sequenceID: UInt32 {
+    get {return _sequenceID ?? 0}
+    set {_sequenceID = newValue}
+  }
+  /// Returns true if `sequenceID` has been explicitly set.
+  public var hasSequenceID: Bool {return self._sequenceID != nil}
+  /// Clears the value of `sequenceID`. Subsequent reads from it will return its default value.
+  public mutating func clearSequenceID() {self._sequenceID = nil}
+
+  public var time: BlueLocalTimestamp {
+    get {return _time ?? BlueLocalTimestamp()}
+    set {_time = newValue}
+  }
+  /// Returns true if `time` has been explicitly set.
+  public var hasTime: Bool {return self._time != nil}
+  /// Clears the value of `time`. Subsequent reads from it will return its default value.
+  public mutating func clearTime() {self._time = nil}
+
+  public var severity: UInt32 {
+    get {return _severity ?? 0}
+    set {_severity = newValue}
+  }
+  /// Returns true if `severity` has been explicitly set.
+  public var hasSeverity: Bool {return self._severity != nil}
+  /// Clears the value of `severity`. Subsequent reads from it will return its default value.
+  public mutating func clearSeverity() {self._severity = nil}
+
+  public var line: UInt32 {
+    get {return _line ?? 0}
+    set {_line = newValue}
+  }
+  /// Returns true if `line` has been explicitly set.
+  public var hasLine: Bool {return self._line != nil}
+  /// Clears the value of `line`. Subsequent reads from it will return its default value.
+  public mutating func clearLine() {self._line = nil}
+
+  public var file: String {
+    get {return _file ?? String()}
+    set {_file = newValue}
+  }
+  /// Returns true if `file` has been explicitly set.
+  public var hasFile: Bool {return self._file != nil}
+  /// Clears the value of `file`. Subsequent reads from it will return its default value.
+  public mutating func clearFile() {self._file = nil}
+
+  public var message: String {
+    get {return _message ?? String()}
+    set {_message = newValue}
+  }
+  /// Returns true if `message` has been explicitly set.
+  public var hasMessage: Bool {return self._message != nil}
+  /// Clears the value of `message`. Subsequent reads from it will return its default value.
+  public mutating func clearMessage() {self._message = nil}
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+
+  fileprivate var _sequenceID: UInt32? = nil
+  fileprivate var _time: BlueLocalTimestamp? = nil
+  fileprivate var _severity: UInt32? = nil
+  fileprivate var _line: UInt32? = nil
+  fileprivate var _file: String? = nil
+  fileprivate var _message: String? = nil
+}
+
+public struct BlueSystemLogResult {
+  // 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 entries: [BlueSystemLogEntry] = []
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+}
+
+public struct BlueEventLogQuery {
+  // 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 maxCount: UInt32 {
+    get {return _maxCount ?? 0}
+    set {_maxCount = newValue}
+  }
+  /// Returns true if `maxCount` has been explicitly set.
+  public var hasMaxCount: Bool {return self._maxCount != nil}
+  /// Clears the value of `maxCount`. Subsequent reads from it will return its default value.
+  public mutating func clearMaxCount() {self._maxCount = nil}
+
+  public var start: BlueEventLogQuery.OneOf_Start? = nil
+
+  public var sequenceID: UInt32 {
+    get {
+      if case .sequenceID(let v)? = start {return v}
+      return 0
+    }
+    set {start = .sequenceID(newValue)}
+  }
+
+  /// false = starts from tail
+  public var fromHead: Bool {
+    get {
+      if case .fromHead(let v)? = start {return v}
+      return false
+    }
+    set {start = .fromHead(newValue)}
+  }
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public enum OneOf_Start: Equatable {
+    case sequenceID(UInt32)
+    /// false = starts from tail
+    case fromHead(Bool)
+
+  #if !swift(>=4.1)
+    public static func ==(lhs: BlueEventLogQuery.OneOf_Start, rhs: BlueEventLogQuery.OneOf_Start) -> Bool {
+      // 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 (lhs, rhs) {
+      case (.sequenceID, .sequenceID): return {
+        guard case .sequenceID(let l) = lhs, case .sequenceID(let r) = rhs else { preconditionFailure() }
+        return l == r
+      }()
+      case (.fromHead, .fromHead): return {
+        guard case .fromHead(let l) = lhs, case .fromHead(let r) = rhs else { preconditionFailure() }
+        return l == r
+      }()
+      default: return false
+      }
+    }
+  #endif
+  }
+
+  public init() {}
+
+  fileprivate var _maxCount: UInt32? = nil
+}
+
+public struct BlueEventLogResult {
+  // 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 events: [BlueEvent] = []
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+}
+
+public struct BlueBlacklistEntries {
+  // 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 entries: [BlueBlacklistEntry] = []
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+}
+
+#if swift(>=5.5) && canImport(_Concurrency)
+extension BlueOnlineMode: @unchecked Sendable {}
+extension BlueTimeOffsetPeriod: @unchecked Sendable {}
+extension BlueBaseConfig: @unchecked Sendable {}
+extension BlueBleConfig: @unchecked Sendable {}
+extension BlueOnlineConfig: @unchecked Sendable {}
+extension BlueAccessConfig: @unchecked Sendable {}
+extension BlueOssConfig: @unchecked Sendable {}
+extension BlueSystemConfig: @unchecked Sendable {}
+extension BlueSystemTimeUnix: @unchecked Sendable {}
+extension BlueSystemUpdate: @unchecked Sendable {}
+extension BlueSystemSettings: @unchecked Sendable {}
+extension BlueSystemProvisioning: @unchecked Sendable {}
+extension BlueSystemStatus: @unchecked Sendable {}
+extension BlueSystemLogQuery: @unchecked Sendable {}
+extension BlueSystemLogQuery.OneOf_Start: @unchecked Sendable {}
+extension BlueSystemLogEntry: @unchecked Sendable {}
+extension BlueSystemLogResult: @unchecked Sendable {}
+extension BlueEventLogQuery: @unchecked Sendable {}
+extension BlueEventLogQuery.OneOf_Start: @unchecked Sendable {}
+extension BlueEventLogResult: @unchecked Sendable {}
+extension BlueBlacklistEntries: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
+// MARK: - Code below here is support for the SwiftProtobuf runtime.
+
+extension BlueOnlineMode: SwiftProtobuf._ProtoNameProviding {
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "OfflineMode"),
+    1: .same(proto: "ManualWifi"),
+    2: .same(proto: "AlwaysOnWifi"),
+    3: .same(proto: "UseLan"),
+  ]
+}
+
+extension BlueTimeOffsetPeriod: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueTimeOffsetPeriod"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "epoch"),
+    2: .same(proto: "offset"),
+  ]
+
+  public var isInitialized: Bool {
+    if self._epoch == nil {return false}
+    if self._offset == 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.decodeSingularUInt32Field(value: &self._epoch) }()
+      case 2: try { try decoder.decodeSingularInt32Field(value: &self._offset) }()
+      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._epoch {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._offset {
+      try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueTimeOffsetPeriod, rhs: BlueTimeOffsetPeriod) -> Bool {
+    if lhs._epoch != rhs._epoch {return false}
+    if lhs._offset != rhs._offset {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueBaseConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueBaseConfig"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "timeOffsetPeriods"),
+    2: .same(proto: "autoCheckSystemStatus"),
+  ]
+
+  public var isInitialized: Bool {
+    if self._autoCheckSystemStatus == nil {return false}
+    if !SwiftProtobuf.Internal.areAllInitialized(self.timeOffsetPeriods) {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.timeOffsetPeriods) }()
+      case 2: try { try decoder.decodeSingularBoolField(value: &self._autoCheckSystemStatus) }()
+      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
+    if !self.timeOffsetPeriods.isEmpty {
+      try visitor.visitRepeatedMessageField(value: self.timeOffsetPeriods, fieldNumber: 1)
+    }
+    try { if let v = self._autoCheckSystemStatus {
+      try visitor.visitSingularBoolField(value: v, fieldNumber: 2)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueBaseConfig, rhs: BlueBaseConfig) -> Bool {
+    if lhs.timeOffsetPeriods != rhs.timeOffsetPeriods {return false}
+    if lhs._autoCheckSystemStatus != rhs._autoCheckSystemStatus {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueBleConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueBleConfig"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "isAdvertising"),
+    2: .same(proto: "advertisingSchedules"),
+    3: .same(proto: "maxPowerAdvertisingSchedulesIndices"),
+    4: .same(proto: "advertisingIntervalMs"),
+    5: .same(proto: "maxConnectionTimeoutMs"),
+    6: .same(proto: "txPowerLevel"),
+    7: .same(proto: "advertisedTxPower1Meter"),
+    8: .same(proto: "isIBeaconAdvertisement"),
+  ]
+
+  public var isInitialized: Bool {
+    if self._isAdvertising == nil {return false}
+    if self._advertisingIntervalMs == nil {return false}
+    if self._maxConnectionTimeoutMs == nil {return false}
+    if self._txPowerLevel == nil {return false}
+    if self._advertisedTxPower1Meter == nil {return false}
+    if self._isIbeaconAdvertisement == nil {return false}
+    if !SwiftProtobuf.Internal.areAllInitialized(self.advertisingSchedules) {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.decodeSingularBoolField(value: &self._isAdvertising) }()
+      case 2: try { try decoder.decodeRepeatedMessageField(value: &self.advertisingSchedules) }()
+      case 3: try { try decoder.decodeRepeatedUInt32Field(value: &self.maxPowerAdvertisingSchedulesIndices) }()
+      case 4: try { try decoder.decodeSingularUInt32Field(value: &self._advertisingIntervalMs) }()
+      case 5: try { try decoder.decodeSingularUInt32Field(value: &self._maxConnectionTimeoutMs) }()
+      case 6: try { try decoder.decodeSingularUInt32Field(value: &self._txPowerLevel) }()
+      case 7: try { try decoder.decodeSingularInt32Field(value: &self._advertisedTxPower1Meter) }()
+      case 8: try { try decoder.decodeSingularBoolField(value: &self._isIbeaconAdvertisement) }()
+      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._isAdvertising {
+      try visitor.visitSingularBoolField(value: v, fieldNumber: 1)
+    } }()
+    if !self.advertisingSchedules.isEmpty {
+      try visitor.visitRepeatedMessageField(value: self.advertisingSchedules, fieldNumber: 2)
+    }
+    if !self.maxPowerAdvertisingSchedulesIndices.isEmpty {
+      try visitor.visitRepeatedUInt32Field(value: self.maxPowerAdvertisingSchedulesIndices, fieldNumber: 3)
+    }
+    try { if let v = self._advertisingIntervalMs {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 4)
+    } }()
+    try { if let v = self._maxConnectionTimeoutMs {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 5)
+    } }()
+    try { if let v = self._txPowerLevel {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 6)
+    } }()
+    try { if let v = self._advertisedTxPower1Meter {
+      try visitor.visitSingularInt32Field(value: v, fieldNumber: 7)
+    } }()
+    try { if let v = self._isIbeaconAdvertisement {
+      try visitor.visitSingularBoolField(value: v, fieldNumber: 8)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueBleConfig, rhs: BlueBleConfig) -> Bool {
+    if lhs._isAdvertising != rhs._isAdvertising {return false}
+    if lhs.advertisingSchedules != rhs.advertisingSchedules {return false}
+    if lhs.maxPowerAdvertisingSchedulesIndices != rhs.maxPowerAdvertisingSchedulesIndices {return false}
+    if lhs._advertisingIntervalMs != rhs._advertisingIntervalMs {return false}
+    if lhs._maxConnectionTimeoutMs != rhs._maxConnectionTimeoutMs {return false}
+    if lhs._txPowerLevel != rhs._txPowerLevel {return false}
+    if lhs._advertisedTxPower1Meter != rhs._advertisedTxPower1Meter {return false}
+    if lhs._isIbeaconAdvertisement != rhs._isIbeaconAdvertisement {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueOnlineConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueOnlineConfig"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "mode"),
+    2: .same(proto: "connectSchedules"),
+    3: .same(proto: "wifiSSID"),
+    4: .same(proto: "wifiPassword"),
+    5: .same(proto: "timeoutSec"),
+  ]
+
+  public var isInitialized: Bool {
+    if self._mode == nil {return false}
+    if self._wifiSsid == nil {return false}
+    if self._wifiPassword == nil {return false}
+    if self._timeoutSec == nil {return false}
+    if !SwiftProtobuf.Internal.areAllInitialized(self.connectSchedules) {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.decodeSingularEnumField(value: &self._mode) }()
+      case 2: try { try decoder.decodeRepeatedMessageField(value: &self.connectSchedules) }()
+      case 3: try { try decoder.decodeSingularStringField(value: &self._wifiSsid) }()
+      case 4: try { try decoder.decodeSingularStringField(value: &self._wifiPassword) }()
+      case 5: try { try decoder.decodeSingularUInt32Field(value: &self._timeoutSec) }()
+      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._mode {
+      try visitor.visitSingularEnumField(value: v, fieldNumber: 1)
+    } }()
+    if !self.connectSchedules.isEmpty {
+      try visitor.visitRepeatedMessageField(value: self.connectSchedules, fieldNumber: 2)
+    }
+    try { if let v = self._wifiSsid {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 3)
+    } }()
+    try { if let v = self._wifiPassword {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 4)
+    } }()
+    try { if let v = self._timeoutSec {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 5)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueOnlineConfig, rhs: BlueOnlineConfig) -> Bool {
+    if lhs._mode != rhs._mode {return false}
+    if lhs.connectSchedules != rhs.connectSchedules {return false}
+    if lhs._wifiSsid != rhs._wifiSsid {return false}
+    if lhs._wifiPassword != rhs._wifiPassword {return false}
+    if lhs._timeoutSec != rhs._timeoutSec {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueAccessConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueAccessConfig"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "id"),
+    2: .same(proto: "siteId"),
+    3: .same(proto: "groupIds"),
+  ]
+
+  public var isInitialized: Bool {
+    if self._id == nil {return false}
+    if self._siteID == 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.decodeSingularUInt32Field(value: &self._id) }()
+      case 2: try { try decoder.decodeSingularUInt32Field(value: &self._siteID) }()
+      case 3: try { try decoder.decodeRepeatedUInt32Field(value: &self.groupIds) }()
+      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._id {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._siteID {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 2)
+    } }()
+    if !self.groupIds.isEmpty {
+      try visitor.visitRepeatedUInt32Field(value: self.groupIds, fieldNumber: 3)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueAccessConfig, rhs: BlueAccessConfig) -> Bool {
+    if lhs._id != rhs._id {return false}
+    if lhs._siteID != rhs._siteID {return false}
+    if lhs.groupIds != rhs.groupIds {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueOssConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueOssConfig"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "sidMifareAesKey"),
+    2: .same(proto: "sidMifareAid"),
+    3: .same(proto: "soUpdater"),
+    4: .same(proto: "soPushEvents"),
+    5: .same(proto: "soWritePendingEvents"),
+    6: .same(proto: "soUpdateFromBlacklist"),
+    7: .same(proto: "soMifareAesKey"),
+    8: .same(proto: "soMifareAid"),
+  ]
+
+  public var isInitialized: Bool {
+    if self._sidMifareAesKey == nil {return false}
+    if self._sidMifareAid == nil {return false}
+    if self._soUpdater == nil {return false}
+    if self._soPushEvents == nil {return false}
+    if self._soWritePendingEvents == nil {return false}
+    if self._soUpdateFromBlacklist == nil {return false}
+    if self._soMifareAesKey == nil {return false}
+    if self._soMifareAid == 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.decodeSingularBytesField(value: &self._sidMifareAesKey) }()
+      case 2: try { try decoder.decodeSingularUInt32Field(value: &self._sidMifareAid) }()
+      case 3: try { try decoder.decodeSingularBoolField(value: &self._soUpdater) }()
+      case 4: try { try decoder.decodeSingularBoolField(value: &self._soPushEvents) }()
+      case 5: try { try decoder.decodeSingularBoolField(value: &self._soWritePendingEvents) }()
+      case 6: try { try decoder.decodeSingularBoolField(value: &self._soUpdateFromBlacklist) }()
+      case 7: try { try decoder.decodeSingularBytesField(value: &self._soMifareAesKey) }()
+      case 8: try { try decoder.decodeSingularUInt32Field(value: &self._soMifareAid) }()
+      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._sidMifareAesKey {
+      try visitor.visitSingularBytesField(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._sidMifareAid {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 2)
+    } }()
+    try { if let v = self._soUpdater {
+      try visitor.visitSingularBoolField(value: v, fieldNumber: 3)
+    } }()
+    try { if let v = self._soPushEvents {
+      try visitor.visitSingularBoolField(value: v, fieldNumber: 4)
+    } }()
+    try { if let v = self._soWritePendingEvents {
+      try visitor.visitSingularBoolField(value: v, fieldNumber: 5)
+    } }()
+    try { if let v = self._soUpdateFromBlacklist {
+      try visitor.visitSingularBoolField(value: v, fieldNumber: 6)
+    } }()
+    try { if let v = self._soMifareAesKey {
+      try visitor.visitSingularBytesField(value: v, fieldNumber: 7)
+    } }()
+    try { if let v = self._soMifareAid {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 8)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueOssConfig, rhs: BlueOssConfig) -> Bool {
+    if lhs._sidMifareAesKey != rhs._sidMifareAesKey {return false}
+    if lhs._sidMifareAid != rhs._sidMifareAid {return false}
+    if lhs._soUpdater != rhs._soUpdater {return false}
+    if lhs._soPushEvents != rhs._soPushEvents {return false}
+    if lhs._soWritePendingEvents != rhs._soWritePendingEvents {return false}
+    if lhs._soUpdateFromBlacklist != rhs._soUpdateFromBlacklist {return false}
+    if lhs._soMifareAesKey != rhs._soMifareAesKey {return false}
+    if lhs._soMifareAid != rhs._soMifareAid {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueSystemConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueSystemConfig"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "version"),
+    2: .same(proto: "base"),
+    3: .same(proto: "ble"),
+    4: .same(proto: "online"),
+    5: .same(proto: "access"),
+    6: .same(proto: "oss"),
+    7: .same(proto: "lock"),
+  ]
+
+  fileprivate class _StorageClass {
+    var _version: UInt32? = nil
+    var _base: BlueBaseConfig? = nil
+    var _ble: BlueBleConfig? = nil
+    var _online: BlueOnlineConfig? = nil
+    var _access: BlueAccessConfig? = nil
+    var _oss: BlueOssConfig? = nil
+    var _lock: BlueLockConfig? = nil
+
+    static let defaultInstance = _StorageClass()
+
+    private init() {}
+
+    init(copying source: _StorageClass) {
+      _version = source._version
+      _base = source._base
+      _ble = source._ble
+      _online = source._online
+      _access = source._access
+      _oss = source._oss
+      _lock = source._lock
+    }
+  }
+
+  fileprivate mutating func _uniqueStorage() -> _StorageClass {
+    if !isKnownUniquelyReferenced(&_storage) {
+      _storage = _StorageClass(copying: _storage)
+    }
+    return _storage
+  }
+
+  public var isInitialized: Bool {
+    return withExtendedLifetime(_storage) { (_storage: _StorageClass) in
+      if _storage._version == nil {return false}
+      if _storage._base == nil {return false}
+      if _storage._ble == nil {return false}
+      if _storage._online == nil {return false}
+      if _storage._access == nil {return false}
+      if _storage._oss == nil {return false}
+      if let v = _storage._base, !v.isInitialized {return false}
+      if let v = _storage._ble, !v.isInitialized {return false}
+      if let v = _storage._online, !v.isInitialized {return false}
+      if let v = _storage._access, !v.isInitialized {return false}
+      if let v = _storage._oss, !v.isInitialized {return false}
+      if let v = _storage._lock, !v.isInitialized {return false}
+      return true
+    }
+  }
+
+  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    _ = _uniqueStorage()
+    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
+      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.decodeSingularUInt32Field(value: &_storage._version) }()
+        case 2: try { try decoder.decodeSingularMessageField(value: &_storage._base) }()
+        case 3: try { try decoder.decodeSingularMessageField(value: &_storage._ble) }()
+        case 4: try { try decoder.decodeSingularMessageField(value: &_storage._online) }()
+        case 5: try { try decoder.decodeSingularMessageField(value: &_storage._access) }()
+        case 6: try { try decoder.decodeSingularMessageField(value: &_storage._oss) }()
+        case 7: try { try decoder.decodeSingularMessageField(value: &_storage._lock) }()
+        default: break
+        }
+      }
+    }
+  }
+
+  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
+      // 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 = _storage._version {
+        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1)
+      } }()
+      try { if let v = _storage._base {
+        try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
+      } }()
+      try { if let v = _storage._ble {
+        try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
+      } }()
+      try { if let v = _storage._online {
+        try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
+      } }()
+      try { if let v = _storage._access {
+        try visitor.visitSingularMessageField(value: v, fieldNumber: 5)
+      } }()
+      try { if let v = _storage._oss {
+        try visitor.visitSingularMessageField(value: v, fieldNumber: 6)
+      } }()
+      try { if let v = _storage._lock {
+        try visitor.visitSingularMessageField(value: v, fieldNumber: 7)
+      } }()
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueSystemConfig, rhs: BlueSystemConfig) -> Bool {
+    if lhs._storage !== rhs._storage {
+      let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in
+        let _storage = _args.0
+        let rhs_storage = _args.1
+        if _storage._version != rhs_storage._version {return false}
+        if _storage._base != rhs_storage._base {return false}
+        if _storage._ble != rhs_storage._ble {return false}
+        if _storage._online != rhs_storage._online {return false}
+        if _storage._access != rhs_storage._access {return false}
+        if _storage._oss != rhs_storage._oss {return false}
+        if _storage._lock != rhs_storage._lock {return false}
+        return true
+      }
+      if !storagesAreEqual {return false}
+    }
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueSystemTimeUnix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueSystemTimeUnix"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "epoch"),
+  ]
+
+  public var isInitialized: Bool {
+    if self._epoch == 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.decodeSingularUInt32Field(value: &self._epoch) }()
+      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._epoch {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueSystemTimeUnix, rhs: BlueSystemTimeUnix) -> Bool {
+    if lhs._epoch != rhs._epoch {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueSystemUpdate: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueSystemUpdate"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "config"),
+    2: .same(proto: "timeUnix"),
+  ]
+
+  public var isInitialized: Bool {
+    if let v = self._config, !v.isInitialized {return false}
+    if let v = self._timeUnix, !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._config) }()
+      case 2: try { try decoder.decodeSingularMessageField(value: &self._timeUnix) }()
+      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._config {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._timeUnix {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueSystemUpdate, rhs: BlueSystemUpdate) -> Bool {
+    if lhs._config != rhs._config {return false}
+    if lhs._timeUnix != rhs._timeUnix {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueSystemSettings: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueSystemSettings"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "blacklistMaxEntriesCount"),
+    2: .same(proto: "blacklistEntriesCount"),
+    3: .same(proto: "eventLogMaxEntriesCount"),
+    4: .same(proto: "eventLogEntriesCount"),
+    5: .same(proto: "eventLogSequenceId"),
+    6: .same(proto: "eventLogIndex"),
+    7: .same(proto: "systemLogMaxEntriesCount"),
+    8: .same(proto: "systemLogEntriesCount"),
+    9: .same(proto: "systemLogSequenceId"),
+    10: .same(proto: "systemLogIndex"),
+    11: .same(proto: "timeWasSet"),
+    12: .same(proto: "isBatteryLow"),
+  ]
+
+  public var isInitialized: Bool {
+    if self._blacklistMaxEntriesCount == nil {return false}
+    if self._blacklistEntriesCount == nil {return false}
+    if self._eventLogMaxEntriesCount == nil {return false}
+    if self._eventLogEntriesCount == nil {return false}
+    if self._eventLogSequenceID == nil {return false}
+    if self._eventLogIndex == nil {return false}
+    if self._systemLogMaxEntriesCount == nil {return false}
+    if self._systemLogEntriesCount == nil {return false}
+    if self._systemLogSequenceID == nil {return false}
+    if self._systemLogIndex == nil {return false}
+    if self._timeWasSet == nil {return false}
+    if self._isBatteryLow == 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.decodeSingularUInt32Field(value: &self._blacklistMaxEntriesCount) }()
+      case 2: try { try decoder.decodeSingularUInt32Field(value: &self._blacklistEntriesCount) }()
+      case 3: try { try decoder.decodeSingularUInt32Field(value: &self._eventLogMaxEntriesCount) }()
+      case 4: try { try decoder.decodeSingularUInt32Field(value: &self._eventLogEntriesCount) }()
+      case 5: try { try decoder.decodeSingularUInt32Field(value: &self._eventLogSequenceID) }()
+      case 6: try { try decoder.decodeSingularUInt32Field(value: &self._eventLogIndex) }()
+      case 7: try { try decoder.decodeSingularUInt32Field(value: &self._systemLogMaxEntriesCount) }()
+      case 8: try { try decoder.decodeSingularUInt32Field(value: &self._systemLogEntriesCount) }()
+      case 9: try { try decoder.decodeSingularUInt32Field(value: &self._systemLogSequenceID) }()
+      case 10: try { try decoder.decodeSingularUInt32Field(value: &self._systemLogIndex) }()
+      case 11: try { try decoder.decodeSingularBoolField(value: &self._timeWasSet) }()
+      case 12: try { try decoder.decodeSingularBoolField(value: &self._isBatteryLow) }()
+      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._blacklistMaxEntriesCount {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._blacklistEntriesCount {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 2)
+    } }()
+    try { if let v = self._eventLogMaxEntriesCount {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3)
+    } }()
+    try { if let v = self._eventLogEntriesCount {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 4)
+    } }()
+    try { if let v = self._eventLogSequenceID {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 5)
+    } }()
+    try { if let v = self._eventLogIndex {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 6)
+    } }()
+    try { if let v = self._systemLogMaxEntriesCount {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 7)
+    } }()
+    try { if let v = self._systemLogEntriesCount {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 8)
+    } }()
+    try { if let v = self._systemLogSequenceID {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 9)
+    } }()
+    try { if let v = self._systemLogIndex {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 10)
+    } }()
+    try { if let v = self._timeWasSet {
+      try visitor.visitSingularBoolField(value: v, fieldNumber: 11)
+    } }()
+    try { if let v = self._isBatteryLow {
+      try visitor.visitSingularBoolField(value: v, fieldNumber: 12)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueSystemSettings, rhs: BlueSystemSettings) -> Bool {
+    if lhs._blacklistMaxEntriesCount != rhs._blacklistMaxEntriesCount {return false}
+    if lhs._blacklistEntriesCount != rhs._blacklistEntriesCount {return false}
+    if lhs._eventLogMaxEntriesCount != rhs._eventLogMaxEntriesCount {return false}
+    if lhs._eventLogEntriesCount != rhs._eventLogEntriesCount {return false}
+    if lhs._eventLogSequenceID != rhs._eventLogSequenceID {return false}
+    if lhs._eventLogIndex != rhs._eventLogIndex {return false}
+    if lhs._systemLogMaxEntriesCount != rhs._systemLogMaxEntriesCount {return false}
+    if lhs._systemLogEntriesCount != rhs._systemLogEntriesCount {return false}
+    if lhs._systemLogSequenceID != rhs._systemLogSequenceID {return false}
+    if lhs._systemLogIndex != rhs._systemLogIndex {return false}
+    if lhs._timeWasSet != rhs._timeWasSet {return false}
+    if lhs._isBatteryLow != rhs._isBatteryLow {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueSystemProvisioning: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueSystemProvisioning"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "hardwareType"),
+    2: .same(proto: "deviceId"),
+    3: .same(proto: "serialNumber"),
+    4: .same(proto: "terminalPrivateKey"),
+    5: .same(proto: "signaturePublicKey"),
+  ]
+
+  public var isInitialized: Bool {
+    if self._hardwareType == nil {return false}
+    if self._deviceID == nil {return false}
+    if self._serialNumber == nil {return false}
+    if self._terminalPrivateKey == nil {return false}
+    if self._signaturePublicKey == 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.decodeSingularEnumField(value: &self._hardwareType) }()
+      case 2: try { try decoder.decodeSingularStringField(value: &self._deviceID) }()
+      case 3: try { try decoder.decodeSingularStringField(value: &self._serialNumber) }()
+      case 4: try { try decoder.decodeSingularBytesField(value: &self._terminalPrivateKey) }()
+      case 5: try { try decoder.decodeSingularBytesField(value: &self._signaturePublicKey) }()
+      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._hardwareType {
+      try visitor.visitSingularEnumField(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._deviceID {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
+    } }()
+    try { if let v = self._serialNumber {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 3)
+    } }()
+    try { if let v = self._terminalPrivateKey {
+      try visitor.visitSingularBytesField(value: v, fieldNumber: 4)
+    } }()
+    try { if let v = self._signaturePublicKey {
+      try visitor.visitSingularBytesField(value: v, fieldNumber: 5)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueSystemProvisioning, rhs: BlueSystemProvisioning) -> Bool {
+    if lhs._hardwareType != rhs._hardwareType {return false}
+    if lhs._deviceID != rhs._deviceID {return false}
+    if lhs._serialNumber != rhs._serialNumber {return false}
+    if lhs._terminalPrivateKey != rhs._terminalPrivateKey {return false}
+    if lhs._signaturePublicKey != rhs._signaturePublicKey {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueSystemStatus: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueSystemStatus"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "configVersion"),
+    2: .same(proto: "deviceId"),
+    3: .same(proto: "serialNumber"),
+    4: .same(proto: "hardwareType"),
+    5: .same(proto: "batteryLevel"),
+    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"),
+  ]
+
+  fileprivate class _StorageClass {
+    var _configVersion: UInt32? = nil
+    var _deviceID: String? = nil
+    var _serialNumber: String? = nil
+    var _hardwareType: BlueHardwareType? = nil
+    var _batteryLevel: BlueBatteryLevel? = nil
+    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()
+
+    private init() {}
+
+    init(copying source: _StorageClass) {
+      _configVersion = source._configVersion
+      _deviceID = source._deviceID
+      _serialNumber = source._serialNumber
+      _hardwareType = source._hardwareType
+      _batteryLevel = source._batteryLevel
+      _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
+    }
+  }
+
+  fileprivate mutating func _uniqueStorage() -> _StorageClass {
+    if !isKnownUniquelyReferenced(&_storage) {
+      _storage = _StorageClass(copying: _storage)
+    }
+    return _storage
+  }
+
+  public var isInitialized: Bool {
+    return withExtendedLifetime(_storage) { (_storage: _StorageClass) in
+      if _storage._configVersion == nil {return false}
+      if _storage._deviceID == nil {return false}
+      if _storage._serialNumber == nil {return false}
+      if _storage._hardwareType == nil {return false}
+      if _storage._batteryLevel == nil {return false}
+      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}
+      return true
+    }
+  }
+
+  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    _ = _uniqueStorage()
+    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
+      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.decodeSingularUInt32Field(value: &_storage._configVersion) }()
+        case 2: try { try decoder.decodeSingularStringField(value: &_storage._deviceID) }()
+        case 3: try { try decoder.decodeSingularStringField(value: &_storage._serialNumber) }()
+        case 4: try { try decoder.decodeSingularEnumField(value: &_storage._hardwareType) }()
+        case 5: try { try decoder.decodeSingularEnumField(value: &_storage._batteryLevel) }()
+        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) }()
+        default: break
+        }
+      }
+    }
+  }
+
+  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
+      // 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 = _storage._configVersion {
+        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1)
+      } }()
+      try { if let v = _storage._deviceID {
+        try visitor.visitSingularStringField(value: v, fieldNumber: 2)
+      } }()
+      try { if let v = _storage._serialNumber {
+        try visitor.visitSingularStringField(value: v, fieldNumber: 3)
+      } }()
+      try { if let v = _storage._hardwareType {
+        try visitor.visitSingularEnumField(value: v, fieldNumber: 4)
+      } }()
+      try { if let v = _storage._batteryLevel {
+        try visitor.visitSingularEnumField(value: v, fieldNumber: 5)
+      } }()
+      try { if let v = _storage._applicationVersion {
+        try visitor.visitSingularUInt32Field(value: v, fieldNumber: 6)
+      } }()
+      try { if let v = _storage._localTime {
+        try visitor.visitSingularMessageField(value: v, fieldNumber: 7)
+      } }()
+      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 unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueSystemStatus, rhs: BlueSystemStatus) -> Bool {
+    if lhs._storage !== rhs._storage {
+      let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in
+        let _storage = _args.0
+        let rhs_storage = _args.1
+        if _storage._configVersion != rhs_storage._configVersion {return false}
+        if _storage._deviceID != rhs_storage._deviceID {return false}
+        if _storage._serialNumber != rhs_storage._serialNumber {return false}
+        if _storage._hardwareType != rhs_storage._hardwareType {return false}
+        if _storage._batteryLevel != rhs_storage._batteryLevel {return false}
+        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
+      }
+      if !storagesAreEqual {return false}
+    }
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueSystemLogQuery: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueSystemLogQuery"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "maxCount"),
+    2: .same(proto: "sequenceId"),
+    3: .same(proto: "fromHead"),
+  ]
+
+  public var isInitialized: Bool {
+    if self._maxCount == 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.decodeSingularUInt32Field(value: &self._maxCount) }()
+      case 2: try {
+        var v: UInt32?
+        try decoder.decodeSingularUInt32Field(value: &v)
+        if let v = v {
+          if self.start != nil {try decoder.handleConflictingOneOf()}
+          self.start = .sequenceID(v)
+        }
+      }()
+      case 3: try {
+        var v: Bool?
+        try decoder.decodeSingularBoolField(value: &v)
+        if let v = v {
+          if self.start != nil {try decoder.handleConflictingOneOf()}
+          self.start = .fromHead(v)
+        }
+      }()
+      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._maxCount {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1)
+    } }()
+    switch self.start {
+    case .sequenceID?: try {
+      guard case .sequenceID(let v)? = self.start else { preconditionFailure() }
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 2)
+    }()
+    case .fromHead?: try {
+      guard case .fromHead(let v)? = self.start else { preconditionFailure() }
+      try visitor.visitSingularBoolField(value: v, fieldNumber: 3)
+    }()
+    case nil: break
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueSystemLogQuery, rhs: BlueSystemLogQuery) -> Bool {
+    if lhs._maxCount != rhs._maxCount {return false}
+    if lhs.start != rhs.start {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueSystemLogEntry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueSystemLogEntry"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "sequenceId"),
+    2: .same(proto: "time"),
+    3: .same(proto: "severity"),
+    4: .same(proto: "line"),
+    5: .same(proto: "file"),
+    6: .same(proto: "message"),
+  ]
+
+  public var isInitialized: Bool {
+    if self._sequenceID == nil {return false}
+    if self._time == nil {return false}
+    if self._severity == nil {return false}
+    if self._line == nil {return false}
+    if self._file == nil {return false}
+    if self._message == nil {return false}
+    if let v = self._time, !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.decodeSingularUInt32Field(value: &self._sequenceID) }()
+      case 2: try { try decoder.decodeSingularMessageField(value: &self._time) }()
+      case 3: try { try decoder.decodeSingularUInt32Field(value: &self._severity) }()
+      case 4: try { try decoder.decodeSingularUInt32Field(value: &self._line) }()
+      case 5: try { try decoder.decodeSingularStringField(value: &self._file) }()
+      case 6: try { try decoder.decodeSingularStringField(value: &self._message) }()
+      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._sequenceID {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._time {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
+    } }()
+    try { if let v = self._severity {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3)
+    } }()
+    try { if let v = self._line {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 4)
+    } }()
+    try { if let v = self._file {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 5)
+    } }()
+    try { if let v = self._message {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 6)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueSystemLogEntry, rhs: BlueSystemLogEntry) -> Bool {
+    if lhs._sequenceID != rhs._sequenceID {return false}
+    if lhs._time != rhs._time {return false}
+    if lhs._severity != rhs._severity {return false}
+    if lhs._line != rhs._line {return false}
+    if lhs._file != rhs._file {return false}
+    if lhs._message != rhs._message {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueSystemLogResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueSystemLogResult"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "entries"),
+  ]
+
+  public var isInitialized: Bool {
+    if !SwiftProtobuf.Internal.areAllInitialized(self.entries) {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.entries) }()
+      default: break
+      }
+    }
+  }
+
+  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.entries.isEmpty {
+      try visitor.visitRepeatedMessageField(value: self.entries, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueSystemLogResult, rhs: BlueSystemLogResult) -> Bool {
+    if lhs.entries != rhs.entries {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueEventLogQuery: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueEventLogQuery"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "maxCount"),
+    2: .same(proto: "sequenceId"),
+    3: .same(proto: "fromHead"),
+  ]
+
+  public var isInitialized: Bool {
+    if self._maxCount == 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.decodeSingularUInt32Field(value: &self._maxCount) }()
+      case 2: try {
+        var v: UInt32?
+        try decoder.decodeSingularUInt32Field(value: &v)
+        if let v = v {
+          if self.start != nil {try decoder.handleConflictingOneOf()}
+          self.start = .sequenceID(v)
+        }
+      }()
+      case 3: try {
+        var v: Bool?
+        try decoder.decodeSingularBoolField(value: &v)
+        if let v = v {
+          if self.start != nil {try decoder.handleConflictingOneOf()}
+          self.start = .fromHead(v)
+        }
+      }()
+      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._maxCount {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1)
+    } }()
+    switch self.start {
+    case .sequenceID?: try {
+      guard case .sequenceID(let v)? = self.start else { preconditionFailure() }
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 2)
+    }()
+    case .fromHead?: try {
+      guard case .fromHead(let v)? = self.start else { preconditionFailure() }
+      try visitor.visitSingularBoolField(value: v, fieldNumber: 3)
+    }()
+    case nil: break
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueEventLogQuery, rhs: BlueEventLogQuery) -> Bool {
+    if lhs._maxCount != rhs._maxCount {return false}
+    if lhs.start != rhs.start {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueEventLogResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueEventLogResult"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "events"),
+  ]
+
+  public var isInitialized: Bool {
+    if !SwiftProtobuf.Internal.areAllInitialized(self.events) {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.events) }()
+      default: break
+      }
+    }
+  }
+
+  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.events.isEmpty {
+      try visitor.visitRepeatedMessageField(value: self.events, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueEventLogResult, rhs: BlueEventLogResult) -> Bool {
+    if lhs.events != rhs.events {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueBlacklistEntries: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueBlacklistEntries"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "entries"),
+  ]
+
+  public var isInitialized: Bool {
+    if !SwiftProtobuf.Internal.areAllInitialized(self.entries) {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.entries) }()
+      default: break
+      }
+    }
+  }
+
+  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.entries.isEmpty {
+      try visitor.visitRepeatedMessageField(value: self.entries, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueBlacklistEntries, rhs: BlueBlacklistEntries) -> Bool {
+    if lhs.entries != rhs.entries {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}