@blueid/access-proto 9.20.0 → 9.22.0

package/swift/BlueCore.pb.swift

@@ -50,6 +50,7 @@ public enum BlueReturnCode: Int, SwiftProtobuf.Enum, Swift.CaseIterable {
   case pointerConversionFailed = -20
   case unavailable = -21
   case aborted = -22
+  case outOfMemory = -23
   case test = -29
   case encodeDataWriteFailed = -30
   case encodeDataWriteNothingWritten = -31
@@ -1163,6 +1164,198 @@ public struct BlueSPResult: @unchecked Sendable {
   fileprivate var _data: Data? = nil
 }
 
+public struct BlueWebSPHandshake: @unchecked Sendable {
+  // 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 salt: Data {
+    get {return _salt ?? Data()}
+    set {_salt = newValue}
+  }
+  /// Returns true if `salt` has been explicitly set.
+  public var hasSalt: Bool {return self._salt != nil}
+  /// Clears the value of `salt`. Subsequent reads from it will return its default value.
+  public mutating func clearSalt() {self._salt = nil}
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+
+  fileprivate var _salt: Data? = nil
+}
+
+public struct BlueWebSPHandshakeReply: @unchecked Sendable {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  public var deviceID: String {
+    get {return _deviceID ?? String()}
+    set {_deviceID = newValue}
+  }
+  /// Returns true if `deviceID` has been explicitly set.
+  public var hasDeviceID: Bool {return self._deviceID != nil}
+  /// Clears the value of `deviceID`. Subsequent reads from it will return its default value.
+  public mutating func clearDeviceID() {self._deviceID = nil}
+
+  public var signature: Data {
+    get {return _signature ?? Data()}
+    set {_signature = newValue}
+  }
+  /// Returns true if `signature` has been explicitly set.
+  public var hasSignature: Bool {return self._signature != nil}
+  /// Clears the value of `signature`. Subsequent reads from it will return its default value.
+  public mutating func clearSignature() {self._signature = nil}
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+
+  fileprivate var _deviceID: String? = nil
+  fileprivate var _signature: Data? = nil
+}
+
+public struct BlueWebSPMessage: Sendable {
+  // 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 transactionID: UInt32 {
+    get {return _transactionID ?? 0}
+    set {_transactionID = newValue}
+  }
+  /// Returns true if `transactionID` has been explicitly set.
+  public var hasTransactionID: Bool {return self._transactionID != nil}
+  /// Clears the value of `transactionID`. Subsequent reads from it will return its default value.
+  public mutating func clearTransactionID() {self._transactionID = nil}
+
+  public var payload: BlueSPResult {
+    get {return _payload ?? BlueSPResult()}
+    set {_payload = newValue}
+  }
+  /// Returns true if `payload` has been explicitly set.
+  public var hasPayload: Bool {return self._payload != nil}
+  /// Clears the value of `payload`. Subsequent reads from it will return its default value.
+  public mutating func clearPayload() {self._payload = nil}
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+
+  fileprivate var _transactionID: UInt32? = nil
+  fileprivate var _payload: BlueSPResult? = nil
+}
+
+/// Message sent by the server to the device
+public struct BlueWebSPServerMessage: Sendable {
+  // 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 payload: BlueWebSPServerMessage.OneOf_Payload? = nil
+
+  public var handshake: BlueWebSPHandshake {
+    get {
+      if case .handshake(let v)? = payload {return v}
+      return BlueWebSPHandshake()
+    }
+    set {payload = .handshake(newValue)}
+  }
+
+  public var command: BlueSPTokenCommand {
+    get {
+      if case .command(let v)? = payload {return v}
+      return BlueSPTokenCommand()
+    }
+    set {payload = .command(newValue)}
+  }
+
+  public var ossSo: BlueOssSoMobile {
+    get {
+      if case .ossSo(let v)? = payload {return v}
+      return BlueOssSoMobile()
+    }
+    set {payload = .ossSo(newValue)}
+  }
+
+  public var ossSid: BlueOssSidMobile {
+    get {
+      if case .ossSid(let v)? = payload {return v}
+      return BlueOssSidMobile()
+    }
+    set {payload = .ossSid(newValue)}
+  }
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public enum OneOf_Payload: Equatable, Sendable {
+    case handshake(BlueWebSPHandshake)
+    case command(BlueSPTokenCommand)
+    case ossSo(BlueOssSoMobile)
+    case ossSid(BlueOssSidMobile)
+
+    fileprivate var isInitialized: 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 self {
+      case .handshake: return {
+        guard case .handshake(let v) = self else { preconditionFailure() }
+        return v.isInitialized
+      }()
+      case .command: return {
+        guard case .command(let v) = self else { preconditionFailure() }
+        return v.isInitialized
+      }()
+      case .ossSo: return {
+        guard case .ossSo(let v) = self else { preconditionFailure() }
+        return v.isInitialized
+      }()
+      case .ossSid: return {
+        guard case .ossSid(let v) = self else { preconditionFailure() }
+        return v.isInitialized
+      }()
+      }
+    }
+
+  }
+
+  public init() {}
+}
+
+/// TODO: payload
+public struct BlueWebSPClientMessage: Sendable {
+  // 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 unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+}
+
+public struct BlueWebSPStatusMessage: Sendable {
+  // 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 status: BlueReturnCode {
+    get {return _status ?? .ok}
+    set {_status = newValue}
+  }
+  /// Returns true if `status` has been explicitly set.
+  public var hasStatus: Bool {return self._status != nil}
+  /// Clears the value of `status`. Subsequent reads from it will return its default value.
+  public mutating func clearStatus() {self._status = nil}
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+
+  fileprivate var _status: BlueReturnCode? = nil
+}
+
 public struct BlueOssAccessResult: Sendable {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
@@ -3016,6 +3209,7 @@ extension BlueReturnCode: SwiftProtobuf._ProtoNameProviding {
     -31: .same(proto: "EncodeDataWriteNothingWritten"),
     -30: .same(proto: "EncodeDataWriteFailed"),
     -29: .same(proto: "Test"),
+    -23: .same(proto: "OutOfMemory"),
     -22: .same(proto: "Aborted"),
     -21: .same(proto: "Unavailable"),
     -20: .same(proto: "PointerConversionFailed"),
@@ -4143,6 +4337,315 @@ extension BlueSPResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementat
   }
 }
 
+extension BlueWebSPHandshake: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueWebSPHandshake"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "salt"),
+  ]
+
+  public var isInitialized: Bool {
+    if self._salt == 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._salt) }()
+      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._salt {
+      try visitor.visitSingularBytesField(value: v, fieldNumber: 1)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueWebSPHandshake, rhs: BlueWebSPHandshake) -> Bool {
+    if lhs._salt != rhs._salt {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueWebSPHandshakeReply: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueWebSPHandshakeReply"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "deviceId"),
+    2: .same(proto: "signature"),
+  ]
+
+  public var isInitialized: Bool {
+    if self._deviceID == nil {return false}
+    if self._signature == nil {return false}
+    return true
+  }
+
+  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularStringField(value: &self._deviceID) }()
+      case 2: try { try decoder.decodeSingularBytesField(value: &self._signature) }()
+      default: break
+      }
+    }
+  }
+
+  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._deviceID {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._signature {
+      try visitor.visitSingularBytesField(value: v, fieldNumber: 2)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueWebSPHandshakeReply, rhs: BlueWebSPHandshakeReply) -> Bool {
+    if lhs._deviceID != rhs._deviceID {return false}
+    if lhs._signature != rhs._signature {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueWebSPMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueWebSPMessage"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "transactionId"),
+    2: .same(proto: "payload"),
+  ]
+
+  public var isInitialized: Bool {
+    if self._transactionID == nil {return false}
+    if self._payload == nil {return false}
+    if let v = self._payload, !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._transactionID) }()
+      case 2: try { try decoder.decodeSingularMessageField(value: &self._payload) }()
+      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._transactionID {
+      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._payload {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueWebSPMessage, rhs: BlueWebSPMessage) -> Bool {
+    if lhs._transactionID != rhs._transactionID {return false}
+    if lhs._payload != rhs._payload {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueWebSPServerMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueWebSPServerMessage"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    2: .same(proto: "handshake"),
+    3: .same(proto: "command"),
+    4: .same(proto: "ossSo"),
+    5: .same(proto: "ossSid"),
+  ]
+
+  public var isInitialized: Bool {
+    if let v = self.payload, !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 2: try {
+        var v: BlueWebSPHandshake?
+        var hadOneofValue = false
+        if let current = self.payload {
+          hadOneofValue = true
+          if case .handshake(let m) = current {v = m}
+        }
+        try decoder.decodeSingularMessageField(value: &v)
+        if let v = v {
+          if hadOneofValue {try decoder.handleConflictingOneOf()}
+          self.payload = .handshake(v)
+        }
+      }()
+      case 3: try {
+        var v: BlueSPTokenCommand?
+        var hadOneofValue = false
+        if let current = self.payload {
+          hadOneofValue = true
+          if case .command(let m) = current {v = m}
+        }
+        try decoder.decodeSingularMessageField(value: &v)
+        if let v = v {
+          if hadOneofValue {try decoder.handleConflictingOneOf()}
+          self.payload = .command(v)
+        }
+      }()
+      case 4: try {
+        var v: BlueOssSoMobile?
+        var hadOneofValue = false
+        if let current = self.payload {
+          hadOneofValue = true
+          if case .ossSo(let m) = current {v = m}
+        }
+        try decoder.decodeSingularMessageField(value: &v)
+        if let v = v {
+          if hadOneofValue {try decoder.handleConflictingOneOf()}
+          self.payload = .ossSo(v)
+        }
+      }()
+      case 5: try {
+        var v: BlueOssSidMobile?
+        var hadOneofValue = false
+        if let current = self.payload {
+          hadOneofValue = true
+          if case .ossSid(let m) = current {v = m}
+        }
+        try decoder.decodeSingularMessageField(value: &v)
+        if let v = v {
+          if hadOneofValue {try decoder.handleConflictingOneOf()}
+          self.payload = .ossSid(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
+    switch self.payload {
+    case .handshake?: try {
+      guard case .handshake(let v)? = self.payload else { preconditionFailure() }
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
+    }()
+    case .command?: try {
+      guard case .command(let v)? = self.payload else { preconditionFailure() }
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
+    }()
+    case .ossSo?: try {
+      guard case .ossSo(let v)? = self.payload else { preconditionFailure() }
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
+    }()
+    case .ossSid?: try {
+      guard case .ossSid(let v)? = self.payload else { preconditionFailure() }
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 5)
+    }()
+    case nil: break
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueWebSPServerMessage, rhs: BlueWebSPServerMessage) -> Bool {
+    if lhs.payload != rhs.payload {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueWebSPClientMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueWebSPClientMessage"
+  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()
+
+  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    // Load everything into unknown fields
+    while try decoder.nextFieldNumber() != nil {}
+  }
+
+  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueWebSPClientMessage, rhs: BlueWebSPClientMessage) -> Bool {
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueWebSPStatusMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueWebSPStatusMessage"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "status"),
+  ]
+
+  public var isInitialized: Bool {
+    if self._status == 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._status) }()
+      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._status {
+      try visitor.visitSingularEnumField(value: v, fieldNumber: 1)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueWebSPStatusMessage, rhs: BlueWebSPStatusMessage) -> Bool {
+    if lhs._status != rhs._status {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
 extension BlueOssAccessResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
   public static let protoMessageName: String = "BlueOssAccessResult"
   public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
@@ -5710,11 +6213,15 @@ extension BlueOssSoConfiguration: SwiftProtobuf.Message, SwiftProtobuf._MessageI
     var _blacklist: BlueOssSoFileBlacklist? = nil
     var _customerExtensions: BlueOssSoFileCustomerExtensions? = nil
 
+    #if swift(>=5.10)
       // This property is used as the initial default value for new instances of the type.
       // The type itself is protecting the reference to its storage via CoW semantics.
       // This will force a copy to be made of this reference when the first mutation occurs;
       // hence, it is safe to mark this as `nonisolated(unsafe)`.
       static nonisolated(unsafe) let defaultInstance = _StorageClass()
+    #else
+      static let defaultInstance = _StorageClass()
+    #endif
 
     private init() {}