QuickDrop/NearbyShare/Model/Protobuf/wire_format.pb.swift

// DO NOT EDIT.
// swift-format-ignore-file
// swiftlint:disable all
//
// Generated by the Swift generator plugin for the protocol buffer compiler.
// Source: wire_format.proto
//
// For information on using the generated types, please see the documentation:
//   https://github.com/apple/swift-protobuf/

// Copyright 2023 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

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
}

/// File metadata. Does not include the actual bytes of the file.
/// NEXT_ID=10
struct Sharing_Nearby_FileMetadata: 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.

  /// The human readable name of this file (eg. 'Cookbook.pdf').
  var name: String {
    get {return _name ?? String()}
    set {_name = newValue}
  }
  /// Returns true if `name` has been explicitly set.
  var hasName: Bool {return self._name != nil}
  /// Clears the value of `name`. Subsequent reads from it will return its default value.
  mutating func clearName() {self._name = nil}

  /// The type of file (eg. 'IMAGE' from 'dog.jpg'). Specifying a type helps
  /// provide a richer experience on the receiving side.
  var type: Sharing_Nearby_FileMetadata.TypeEnum {
    get {return _type ?? .unknown}
    set {_type = newValue}
  }
  /// Returns true if `type` has been explicitly set.
  var hasType: Bool {return self._type != nil}
  /// Clears the value of `type`. Subsequent reads from it will return its default value.
  mutating func clearType() {self._type = nil}

  /// The FILE payload id that will be sent as a follow up containing the actual
  /// bytes of the file.
  var payloadID: Int64 {
    get {return _payloadID ?? 0}
    set {_payloadID = newValue}
  }
  /// Returns true if `payloadID` has been explicitly set.
  var hasPayloadID: Bool {return self._payloadID != nil}
  /// Clears the value of `payloadID`. Subsequent reads from it will return its default value.
  mutating func clearPayloadID() {self._payloadID = nil}

  /// The total size of the file.
  var size: Int64 {
    get {return _size ?? 0}
    set {_size = newValue}
  }
  /// Returns true if `size` has been explicitly set.
  var hasSize: Bool {return self._size != nil}
  /// Clears the value of `size`. Subsequent reads from it will return its default value.
  mutating func clearSize() {self._size = nil}

  /// The mimeType of file (eg. 'image/jpeg' from 'dog.jpg'). Specifying a
  /// mimeType helps provide a richer experience on receiving side.
  var mimeType: String {
    get {return _mimeType ?? "application/octet-stream"}
    set {_mimeType = newValue}
  }
  /// Returns true if `mimeType` has been explicitly set.
  var hasMimeType: Bool {return self._mimeType != nil}
  /// Clears the value of `mimeType`. Subsequent reads from it will return its default value.
  mutating func clearMimeType() {self._mimeType = nil}

  /// A uuid for the attachment. Should be unique across all attachments.
  var id: Int64 {
    get {return _id ?? 0}
    set {_id = newValue}
  }
  /// Returns true if `id` has been explicitly set.
  var hasID: Bool {return self._id != nil}
  /// Clears the value of `id`. Subsequent reads from it will return its default value.
  mutating func clearID() {self._id = nil}

  /// The parent folder.
  var parentFolder: String {
    get {return _parentFolder ?? String()}
    set {_parentFolder = newValue}
  }
  /// Returns true if `parentFolder` has been explicitly set.
  var hasParentFolder: Bool {return self._parentFolder != nil}
  /// Clears the value of `parentFolder`. Subsequent reads from it will return its default value.
  mutating func clearParentFolder() {self._parentFolder = nil}

  /// A stable identifier for the attachment. Used for receiver to identify same
  /// attachment from different transfers.
  var attachmentHash: Int64 {
    get {return _attachmentHash ?? 0}
    set {_attachmentHash = newValue}
  }
  /// Returns true if `attachmentHash` has been explicitly set.
  var hasAttachmentHash: Bool {return self._attachmentHash != nil}
  /// Clears the value of `attachmentHash`. Subsequent reads from it will return its default value.
  mutating func clearAttachmentHash() {self._attachmentHash = nil}

  /// True, if image in file attachment is sensitive
  var isSensitiveContent: Bool {
    get {return _isSensitiveContent ?? false}
    set {_isSensitiveContent = newValue}
  }
  /// Returns true if `isSensitiveContent` has been explicitly set.
  var hasIsSensitiveContent: Bool {return self._isSensitiveContent != nil}
  /// Clears the value of `isSensitiveContent`. Subsequent reads from it will return its default value.
  mutating func clearIsSensitiveContent() {self._isSensitiveContent = nil}

  var unknownFields = SwiftProtobuf.UnknownStorage()

  enum TypeEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable {
    case unknown = 0
    case image = 1
    case video = 2
    case androidApp = 3
    case audio = 4
    case document = 5
    case contactCard = 6

    init() {
      self = .unknown
    }

  }

  init() {}

  fileprivate var _name: String? = nil
  fileprivate var _type: Sharing_Nearby_FileMetadata.TypeEnum? = nil
  fileprivate var _payloadID: Int64? = nil
  fileprivate var _size: Int64? = nil
  fileprivate var _mimeType: String? = nil
  fileprivate var _id: Int64? = nil
  fileprivate var _parentFolder: String? = nil
  fileprivate var _attachmentHash: Int64? = nil
  fileprivate var _isSensitiveContent: Bool? = nil
}

/// NEXT_ID=8
struct Sharing_Nearby_TextMetadata: 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.

  /// The title of the text content.
  var textTitle: String {
    get {return _textTitle ?? String()}
    set {_textTitle = newValue}
  }
  /// Returns true if `textTitle` has been explicitly set.
  var hasTextTitle: Bool {return self._textTitle != nil}
  /// Clears the value of `textTitle`. Subsequent reads from it will return its default value.
  mutating func clearTextTitle() {self._textTitle = nil}

  /// The type of text (phone number, url, address, or plain text).
  var type: Sharing_Nearby_TextMetadata.TypeEnum {
    get {return _type ?? .unknown}
    set {_type = newValue}
  }
  /// Returns true if `type` has been explicitly set.
  var hasType: Bool {return self._type != nil}
  /// Clears the value of `type`. Subsequent reads from it will return its default value.
  mutating func clearType() {self._type = nil}

  /// The BYTE payload id that will be sent as a follow up containing the actual
  /// bytes of the text.
  var payloadID: Int64 {
    get {return _payloadID ?? 0}
    set {_payloadID = newValue}
  }
  /// Returns true if `payloadID` has been explicitly set.
  var hasPayloadID: Bool {return self._payloadID != nil}
  /// Clears the value of `payloadID`. Subsequent reads from it will return its default value.
  mutating func clearPayloadID() {self._payloadID = nil}

  /// The size of the text content.
  var size: Int64 {
    get {return _size ?? 0}
    set {_size = newValue}
  }
  /// Returns true if `size` has been explicitly set.
  var hasSize: Bool {return self._size != nil}
  /// Clears the value of `size`. Subsequent reads from it will return its default value.
  mutating func clearSize() {self._size = nil}

  /// A uuid for the attachment. Should be unique across all attachments.
  var id: Int64 {
    get {return _id ?? 0}
    set {_id = newValue}
  }
  /// Returns true if `id` has been explicitly set.
  var hasID: Bool {return self._id != nil}
  /// Clears the value of `id`. Subsequent reads from it will return its default value.
  mutating func clearID() {self._id = nil}

  /// True if text is sensitive, e.g. password
  var isSensitiveText: Bool {
    get {return _isSensitiveText ?? false}
    set {_isSensitiveText = newValue}
  }
  /// Returns true if `isSensitiveText` has been explicitly set.
  var hasIsSensitiveText: Bool {return self._isSensitiveText != nil}
  /// Clears the value of `isSensitiveText`. Subsequent reads from it will return its default value.
  mutating func clearIsSensitiveText() {self._isSensitiveText = nil}

  var unknownFields = SwiftProtobuf.UnknownStorage()

  enum TypeEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable {
    case unknown = 0
    case text = 1

    /// Open with browsers.
    case url = 2

    /// Open with map apps.
    case address = 3

    /// Dial.
    case phoneNumber = 4

    init() {
      self = .unknown
    }

  }

  init() {}

  fileprivate var _textTitle: String? = nil
  fileprivate var _type: Sharing_Nearby_TextMetadata.TypeEnum? = nil
  fileprivate var _payloadID: Int64? = nil
  fileprivate var _size: Int64? = nil
  fileprivate var _id: Int64? = nil
  fileprivate var _isSensitiveText: Bool? = nil
}

/// NEXT_ID=6
struct Sharing_Nearby_WifiCredentialsMetadata: 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.

  /// The Wifi network name. This will be sent in introduction.
  var ssid: String {
    get {return _ssid ?? String()}
    set {_ssid = newValue}
  }
  /// Returns true if `ssid` has been explicitly set.
  var hasSsid: Bool {return self._ssid != nil}
  /// Clears the value of `ssid`. Subsequent reads from it will return its default value.
  mutating func clearSsid() {self._ssid = nil}

  /// The security type of network (OPEN, WPA_PSK, WEP).
  var securityType: Sharing_Nearby_WifiCredentialsMetadata.SecurityType {
    get {return _securityType ?? .unknownSecurityType}
    set {_securityType = newValue}
  }
  /// Returns true if `securityType` has been explicitly set.
  var hasSecurityType: Bool {return self._securityType != nil}
  /// Clears the value of `securityType`. Subsequent reads from it will return its default value.
  mutating func clearSecurityType() {self._securityType = nil}

  /// The BYTE payload id that will be sent as a follow up containing the
  /// password.
  var payloadID: Int64 {
    get {return _payloadID ?? 0}
    set {_payloadID = newValue}
  }
  /// Returns true if `payloadID` has been explicitly set.
  var hasPayloadID: Bool {return self._payloadID != nil}
  /// Clears the value of `payloadID`. Subsequent reads from it will return its default value.
  mutating func clearPayloadID() {self._payloadID = nil}

  /// A uuid for the attachment. Should be unique across all attachments.
  var id: Int64 {
    get {return _id ?? 0}
    set {_id = newValue}
  }
  /// Returns true if `id` has been explicitly set.
  var hasID: Bool {return self._id != nil}
  /// Clears the value of `id`. Subsequent reads from it will return its default value.
  mutating func clearID() {self._id = nil}

  var unknownFields = SwiftProtobuf.UnknownStorage()

  enum SecurityType: Int, SwiftProtobuf.Enum, Swift.CaseIterable {
    case unknownSecurityType = 0
    case `open` = 1
    case wpaPsk = 2
    case wep = 3
    case sae = 4

    init() {
      self = .unknownSecurityType
    }

  }

  init() {}

  fileprivate var _ssid: String? = nil
  fileprivate var _securityType: Sharing_Nearby_WifiCredentialsMetadata.SecurityType? = nil
  fileprivate var _payloadID: Int64? = nil
  fileprivate var _id: Int64? = nil
}

/// NEXT_ID=10
struct Sharing_Nearby_MirroredNotificationMetadata: 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.

  var version: Int32 {
    get {return _version ?? 1}
    set {_version = newValue}
  }
  /// Returns true if `version` has been explicitly set.
  var hasVersion: Bool {return self._version != nil}
  /// Clears the value of `version`. Subsequent reads from it will return its default value.
  mutating func clearVersion() {self._version = nil}

  var notificationKey: String {
    get {return _notificationKey ?? String()}
    set {_notificationKey = newValue}
  }
  /// Returns true if `notificationKey` has been explicitly set.
  var hasNotificationKey: Bool {return self._notificationKey != nil}
  /// Clears the value of `notificationKey`. Subsequent reads from it will return its default value.
  mutating func clearNotificationKey() {self._notificationKey = nil}

  var packageName: String {
    get {return _packageName ?? String()}
    set {_packageName = newValue}
  }
  /// Returns true if `packageName` has been explicitly set.
  var hasPackageName: Bool {return self._packageName != nil}
  /// Clears the value of `packageName`. Subsequent reads from it will return its default value.
  mutating func clearPackageName() {self._packageName = nil}

  var appName: String {
    get {return _appName ?? String()}
    set {_appName = newValue}
  }
  /// Returns true if `appName` has been explicitly set.
  var hasAppName: Bool {return self._appName != nil}
  /// Clears the value of `appName`. Subsequent reads from it will return its default value.
  mutating func clearAppName() {self._appName = nil}

  var title: String {
    get {return _title ?? String()}
    set {_title = newValue}
  }
  /// Returns true if `title` has been explicitly set.
  var hasTitle: Bool {return self._title != nil}
  /// Clears the value of `title`. Subsequent reads from it will return its default value.
  mutating func clearTitle() {self._title = nil}

  var body: String {
    get {return _body ?? String()}
    set {_body = newValue}
  }
  /// Returns true if `body` has been explicitly set.
  var hasBody: Bool {return self._body != nil}
  /// Clears the value of `body`. Subsequent reads from it will return its default value.
  mutating func clearBody() {self._body = nil}

  var postedAtEpochMs: Int64 {
    get {return _postedAtEpochMs ?? 0}
    set {_postedAtEpochMs = newValue}
  }
  /// Returns true if `postedAtEpochMs` has been explicitly set.
  var hasPostedAtEpochMs: Bool {return self._postedAtEpochMs != nil}
  /// Clears the value of `postedAtEpochMs`. Subsequent reads from it will return its default value.
  mutating func clearPostedAtEpochMs() {self._postedAtEpochMs = nil}

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  fileprivate var _version: Int32? = nil
  fileprivate var _notificationKey: String? = nil
  fileprivate var _packageName: String? = nil
  fileprivate var _appName: String? = nil
  fileprivate var _title: String? = nil
  fileprivate var _body: String? = nil
  fileprivate var _postedAtEpochMs: Int64? = nil
}

/// NEXT_ID=5
struct Sharing_Nearby_PairingMetadata: 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.

  var version: Int32 {
    get {return _version ?? 1}
    set {_version = newValue}
  }
  /// Returns true if `version` has been explicitly set.
  var hasVersion: Bool {return self._version != nil}
  /// Clears the value of `version`. Subsequent reads from it will return its default value.
  mutating func clearVersion() {self._version = nil}

  var useCase: Sharing_Nearby_PairingMetadata.UseCase {
    get {return _useCase ?? .unknown}
    set {_useCase = newValue}
  }
  /// Returns true if `useCase` has been explicitly set.
  var hasUseCase: Bool {return self._useCase != nil}
  /// Clears the value of `useCase`. Subsequent reads from it will return its default value.
  mutating func clearUseCase() {self._useCase = nil}

  var setupRequest: Bool {
    get {return _setupRequest ?? false}
    set {_setupRequest = newValue}
  }
  /// Returns true if `setupRequest` has been explicitly set.
  var hasSetupRequest: Bool {return self._setupRequest != nil}
  /// Clears the value of `setupRequest`. Subsequent reads from it will return its default value.
  mutating func clearSetupRequest() {self._setupRequest = nil}

  var setupPinHash: Data {
    get {return _setupPinHash ?? Data()}
    set {_setupPinHash = newValue}
  }
  /// Returns true if `setupPinHash` has been explicitly set.
  var hasSetupPinHash: Bool {return self._setupPinHash != nil}
  /// Clears the value of `setupPinHash`. Subsequent reads from it will return its default value.
  mutating func clearSetupPinHash() {self._setupPinHash = nil}

  var unknownFields = SwiftProtobuf.UnknownStorage()

  enum UseCase: Int, SwiftProtobuf.Enum, Swift.CaseIterable {
    case unknown = 0
    case notificationSync = 1
    case clipboardSync = 2

    init() {
      self = .unknown
    }

  }

  init() {}

  fileprivate var _version: Int32? = nil
  fileprivate var _useCase: Sharing_Nearby_PairingMetadata.UseCase? = nil
  fileprivate var _setupRequest: Bool? = nil
  fileprivate var _setupPinHash: Data? = nil
}

/// NEXT_ID=8
struct Sharing_Nearby_AppMetadata: 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.

  /// The app name. This will be sent in introduction.
  var appName: String {
    get {return _appName ?? String()}
    set {_appName = newValue}
  }
  /// Returns true if `appName` has been explicitly set.
  var hasAppName: Bool {return self._appName != nil}
  /// Clears the value of `appName`. Subsequent reads from it will return its default value.
  mutating func clearAppName() {self._appName = nil}

  /// The size of the all split of apks.
  var size: Int64 {
    get {return _size ?? 0}
    set {_size = newValue}
  }
  /// Returns true if `size` has been explicitly set.
  var hasSize: Bool {return self._size != nil}
  /// Clears the value of `size`. Subsequent reads from it will return its default value.
  mutating func clearSize() {self._size = nil}

  /// The File payload id that will be sent as a follow up containing the
  /// apk paths.
  var payloadID: [Int64] = []

  /// A uuid for the attachment. Should be unique across all attachments.
  var id: Int64 {
    get {return _id ?? 0}
    set {_id = newValue}
  }
  /// Returns true if `id` has been explicitly set.
  var hasID: Bool {return self._id != nil}
  /// Clears the value of `id`. Subsequent reads from it will return its default value.
  mutating func clearID() {self._id = nil}

  /// The name of apk file. This will be sent in introduction.
  var fileName: [String] = []

  /// The size of apk file. This will be sent in introduction.
  var fileSize: [Int64] = []

  /// The package name. This will be sent in introduction.
  var packageName: String {
    get {return _packageName ?? String()}
    set {_packageName = newValue}
  }
  /// Returns true if `packageName` has been explicitly set.
  var hasPackageName: Bool {return self._packageName != nil}
  /// Clears the value of `packageName`. Subsequent reads from it will return its default value.
  mutating func clearPackageName() {self._packageName = nil}

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  fileprivate var _appName: String? = nil
  fileprivate var _size: Int64? = nil
  fileprivate var _id: Int64? = nil
  fileprivate var _packageName: String? = nil
}

/// NEXT_ID=5
struct Sharing_Nearby_StreamMetadata: 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.

  /// A human readable description for the stream.
  var description_p: String {
    get {return _description_p ?? String()}
    set {_description_p = newValue}
  }
  /// Returns true if `description_p` has been explicitly set.
  var hasDescription_p: Bool {return self._description_p != nil}
  /// Clears the value of `description_p`. Subsequent reads from it will return its default value.
  mutating func clearDescription_p() {self._description_p = nil}

  /// The package name of the sending application.
  var packageName: String {
    get {return _packageName ?? String()}
    set {_packageName = newValue}
  }
  /// Returns true if `packageName` has been explicitly set.
  var hasPackageName: Bool {return self._packageName != nil}
  /// Clears the value of `packageName`. Subsequent reads from it will return its default value.
  mutating func clearPackageName() {self._packageName = nil}

  /// The <TYPE> payload id that will be send as a followup containing the
  /// ParcelFileDescriptor.
  var payloadID: Int64 {
    get {return _payloadID ?? 0}
    set {_payloadID = newValue}
  }
  /// Returns true if `payloadID` has been explicitly set.
  var hasPayloadID: Bool {return self._payloadID != nil}
  /// Clears the value of `payloadID`. Subsequent reads from it will return its default value.
  mutating func clearPayloadID() {self._payloadID = nil}

  /// The human-readable name of the package that should be displayed as
  /// attribution if no other information is available (i.e. the package is not
  /// installed locally yet).
  var attributedAppName: String {
    get {return _attributedAppName ?? String()}
    set {_attributedAppName = newValue}
  }
  /// Returns true if `attributedAppName` has been explicitly set.
  var hasAttributedAppName: Bool {return self._attributedAppName != nil}
  /// Clears the value of `attributedAppName`. Subsequent reads from it will return its default value.
  mutating func clearAttributedAppName() {self._attributedAppName = nil}

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  fileprivate var _description_p: String? = nil
  fileprivate var _packageName: String? = nil
  fileprivate var _payloadID: Int64? = nil
  fileprivate var _attributedAppName: String? = nil
}

/// A frame used when sending messages over the wire.
/// NEXT_ID=3
struct Sharing_Nearby_Frame: 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.

  var version: Sharing_Nearby_Frame.Version {
    get {return _version ?? .unknownVersion}
    set {_version = newValue}
  }
  /// Returns true if `version` has been explicitly set.
  var hasVersion: Bool {return self._version != nil}
  /// Clears the value of `version`. Subsequent reads from it will return its default value.
  mutating func clearVersion() {self._version = nil}

  /// Right now there's only 1 version, but if there are more, exactly one of
  /// the following fields will be set.
  var v1: Sharing_Nearby_V1Frame {
    get {return _v1 ?? Sharing_Nearby_V1Frame()}
    set {_v1 = newValue}
  }
  /// Returns true if `v1` has been explicitly set.
  var hasV1: Bool {return self._v1 != nil}
  /// Clears the value of `v1`. Subsequent reads from it will return its default value.
  mutating func clearV1() {self._v1 = nil}

  var unknownFields = SwiftProtobuf.UnknownStorage()

  enum Version: Int, SwiftProtobuf.Enum, Swift.CaseIterable {
    case unknownVersion = 0
    case v1 = 1

    init() {
      self = .unknownVersion
    }

  }

  init() {}

  fileprivate var _version: Sharing_Nearby_Frame.Version? = nil
  fileprivate var _v1: Sharing_Nearby_V1Frame? = nil
}

/// NEXT_ID=8
struct Sharing_Nearby_V1Frame: 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.

  var type: Sharing_Nearby_V1Frame.FrameType {
    get {return _type ?? .unknownFrameType}
    set {_type = newValue}
  }
  /// Returns true if `type` has been explicitly set.
  var hasType: Bool {return self._type != nil}
  /// Clears the value of `type`. Subsequent reads from it will return its default value.
  mutating func clearType() {self._type = nil}

  /// At most one of the following fields will be set.
  var introduction: Sharing_Nearby_IntroductionFrame {
    get {return _introduction ?? Sharing_Nearby_IntroductionFrame()}
    set {_introduction = newValue}
  }
  /// Returns true if `introduction` has been explicitly set.
  var hasIntroduction: Bool {return self._introduction != nil}
  /// Clears the value of `introduction`. Subsequent reads from it will return its default value.
  mutating func clearIntroduction() {self._introduction = nil}

  var connectionResponse: Sharing_Nearby_ConnectionResponseFrame {
    get {return _connectionResponse ?? Sharing_Nearby_ConnectionResponseFrame()}
    set {_connectionResponse = newValue}
  }
  /// Returns true if `connectionResponse` has been explicitly set.
  var hasConnectionResponse: Bool {return self._connectionResponse != nil}
  /// Clears the value of `connectionResponse`. Subsequent reads from it will return its default value.
  mutating func clearConnectionResponse() {self._connectionResponse = nil}

  var pairedKeyEncryption: Sharing_Nearby_PairedKeyEncryptionFrame {
    get {return _pairedKeyEncryption ?? Sharing_Nearby_PairedKeyEncryptionFrame()}
    set {_pairedKeyEncryption = newValue}
  }
  /// Returns true if `pairedKeyEncryption` has been explicitly set.
  var hasPairedKeyEncryption: Bool {return self._pairedKeyEncryption != nil}
  /// Clears the value of `pairedKeyEncryption`. Subsequent reads from it will return its default value.
  mutating func clearPairedKeyEncryption() {self._pairedKeyEncryption = nil}

  var pairedKeyResult: Sharing_Nearby_PairedKeyResultFrame {
    get {return _pairedKeyResult ?? Sharing_Nearby_PairedKeyResultFrame()}
    set {_pairedKeyResult = newValue}
  }
  /// Returns true if `pairedKeyResult` has been explicitly set.
  var hasPairedKeyResult: Bool {return self._pairedKeyResult != nil}
  /// Clears the value of `pairedKeyResult`. Subsequent reads from it will return its default value.
  mutating func clearPairedKeyResult() {self._pairedKeyResult = nil}

  /// NOTE: This field was marked as deprecated in the .proto file.
  var certificateInfo: Sharing_Nearby_CertificateInfoFrame {
    get {return _certificateInfo ?? Sharing_Nearby_CertificateInfoFrame()}
    set {_certificateInfo = newValue}
  }
  /// Returns true if `certificateInfo` has been explicitly set.
  var hasCertificateInfo: Bool {return self._certificateInfo != nil}
  /// Clears the value of `certificateInfo`. Subsequent reads from it will return its default value.
  mutating func clearCertificateInfo() {self._certificateInfo = nil}

  /// NOTE: This field was marked as deprecated in the .proto file.
  var progressUpdate: Sharing_Nearby_ProgressUpdateFrame {
    get {return _progressUpdate ?? Sharing_Nearby_ProgressUpdateFrame()}
    set {_progressUpdate = newValue}
  }
  /// Returns true if `progressUpdate` has been explicitly set.
  var hasProgressUpdate: Bool {return self._progressUpdate != nil}
  /// Clears the value of `progressUpdate`. Subsequent reads from it will return its default value.
  mutating func clearProgressUpdate() {self._progressUpdate = nil}

  var unknownFields = SwiftProtobuf.UnknownStorage()

  enum FrameType: Int, SwiftProtobuf.Enum, Swift.CaseIterable {
    case unknownFrameType = 0
    case introduction = 1
    case response = 2
    case pairedKeyEncryption = 3
    case pairedKeyResult = 4

    /// No longer used.
    case certificateInfo = 5
    case cancel = 6

    /// No longer used.
    case progressUpdate = 7

    init() {
      self = .unknownFrameType
    }

  }

  init() {}

  fileprivate var _type: Sharing_Nearby_V1Frame.FrameType? = nil
  fileprivate var _introduction: Sharing_Nearby_IntroductionFrame? = nil
  fileprivate var _connectionResponse: Sharing_Nearby_ConnectionResponseFrame? = nil
  fileprivate var _pairedKeyEncryption: Sharing_Nearby_PairedKeyEncryptionFrame? = nil
  fileprivate var _pairedKeyResult: Sharing_Nearby_PairedKeyResultFrame? = nil
  fileprivate var _certificateInfo: Sharing_Nearby_CertificateInfoFrame? = nil
  fileprivate var _progressUpdate: Sharing_Nearby_ProgressUpdateFrame? = nil
}

/// An introduction packet sent by the sending side. Contains a list of files
/// they'd like to share.
/// NEXT_ID=1003
struct Sharing_Nearby_IntroductionFrame: @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.

  var fileMetadata: [Sharing_Nearby_FileMetadata] {
    get {return _storage._fileMetadata}
    set {_uniqueStorage()._fileMetadata = newValue}
  }

  var textMetadata: [Sharing_Nearby_TextMetadata] {
    get {return _storage._textMetadata}
    set {_uniqueStorage()._textMetadata = newValue}
  }

  /// The required app package to open the content. May be null.
  var requiredPackage: String {
    get {return _storage._requiredPackage ?? String()}
    set {_uniqueStorage()._requiredPackage = newValue}
  }
  /// Returns true if `requiredPackage` has been explicitly set.
  var hasRequiredPackage: Bool {return _storage._requiredPackage != nil}
  /// Clears the value of `requiredPackage`. Subsequent reads from it will return its default value.
  mutating func clearRequiredPackage() {_uniqueStorage()._requiredPackage = nil}

  var wifiCredentialsMetadata: [Sharing_Nearby_WifiCredentialsMetadata] {
    get {return _storage._wifiCredentialsMetadata}
    set {_uniqueStorage()._wifiCredentialsMetadata = newValue}
  }

  var appMetadata: [Sharing_Nearby_AppMetadata] {
    get {return _storage._appMetadata}
    set {_uniqueStorage()._appMetadata = newValue}
  }

  var startTransfer: Bool {
    get {return _storage._startTransfer ?? false}
    set {_uniqueStorage()._startTransfer = newValue}
  }
  /// Returns true if `startTransfer` has been explicitly set.
  var hasStartTransfer: Bool {return _storage._startTransfer != nil}
  /// Clears the value of `startTransfer`. Subsequent reads from it will return its default value.
  mutating func clearStartTransfer() {_uniqueStorage()._startTransfer = nil}

  var streamMetadata: [Sharing_Nearby_StreamMetadata] {
    get {return _storage._streamMetadata}
    set {_uniqueStorage()._streamMetadata = newValue}
  }

  var useCase: Sharing_Nearby_IntroductionFrame.SharingUseCase {
    get {return _storage._useCase ?? .unknown}
    set {_uniqueStorage()._useCase = newValue}
  }
  /// Returns true if `useCase` has been explicitly set.
  var hasUseCase: Bool {return _storage._useCase != nil}
  /// Clears the value of `useCase`. Subsequent reads from it will return its default value.
  mutating func clearUseCase() {_uniqueStorage()._useCase = nil}

  var previewPayloadIds: [Int64] {
    get {return _storage._previewPayloadIds}
    set {_uniqueStorage()._previewPayloadIds = newValue}
  }

  var mirroredNotificationMetadata: Sharing_Nearby_MirroredNotificationMetadata {
    get {return _storage._mirroredNotificationMetadata ?? Sharing_Nearby_MirroredNotificationMetadata()}
    set {_uniqueStorage()._mirroredNotificationMetadata = newValue}
  }
  /// Returns true if `mirroredNotificationMetadata` has been explicitly set.
  var hasMirroredNotificationMetadata: Bool {return _storage._mirroredNotificationMetadata != nil}
  /// Clears the value of `mirroredNotificationMetadata`. Subsequent reads from it will return its default value.
  mutating func clearMirroredNotificationMetadata() {_uniqueStorage()._mirroredNotificationMetadata = nil}

  var pairingMetadata: Sharing_Nearby_PairingMetadata {
    get {return _storage._pairingMetadata ?? Sharing_Nearby_PairingMetadata()}
    set {_uniqueStorage()._pairingMetadata = newValue}
  }
  /// Returns true if `pairingMetadata` has been explicitly set.
  var hasPairingMetadata: Bool {return _storage._pairingMetadata != nil}
  /// Clears the value of `pairingMetadata`. Subsequent reads from it will return its default value.
  mutating func clearPairingMetadata() {_uniqueStorage()._pairingMetadata = nil}

  var unknownFields = SwiftProtobuf.UnknownStorage()

  enum SharingUseCase: Int, SwiftProtobuf.Enum, Swift.CaseIterable {
    case unknown = 0
    case nearbyShare = 1
    case remoteCopy = 2

    init() {
      self = .unknown
    }

  }

  init() {}

  fileprivate var _storage = _StorageClass.defaultInstance
}

/// A progress update packet sent by the sending side. Contains transfer progress
/// value. NEXT_ID=3
struct Sharing_Nearby_ProgressUpdateFrame: 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.

  var progress: Float {
    get {return _progress ?? 0}
    set {_progress = newValue}
  }
  /// Returns true if `progress` has been explicitly set.
  var hasProgress: Bool {return self._progress != nil}
  /// Clears the value of `progress`. Subsequent reads from it will return its default value.
  mutating func clearProgress() {self._progress = nil}

  /// True, if the receiver should start bandwidth upgrade and receiving the
  /// payloads.
  var startTransfer: Bool {
    get {return _startTransfer ?? false}
    set {_startTransfer = newValue}
  }
  /// Returns true if `startTransfer` has been explicitly set.
  var hasStartTransfer: Bool {return self._startTransfer != nil}
  /// Clears the value of `startTransfer`. Subsequent reads from it will return its default value.
  mutating func clearStartTransfer() {self._startTransfer = nil}

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  fileprivate var _progress: Float? = nil
  fileprivate var _startTransfer: Bool? = nil
}

/// A response packet sent by the receiving side. Accepts or rejects the list of
/// files.
/// NEXT_ID=4
struct Sharing_Nearby_ConnectionResponseFrame: 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.

  /// The receiving side's response.
  var status: Sharing_Nearby_ConnectionResponseFrame.Status {
    get {return _status ?? .unknown}
    set {_status = newValue}
  }
  /// Returns true if `status` has been explicitly set.
  var hasStatus: Bool {return self._status != nil}
  /// Clears the value of `status`. Subsequent reads from it will return its default value.
  mutating func clearStatus() {self._status = nil}

  /// Key is attachment hash, value is the details of attachment.
  var attachmentDetails: Dictionary<Int64,Sharing_Nearby_AttachmentDetails> = [:]

  /// In the case of a stream attachments, the other side of the pipe.
  /// Both sender and receiver should validate matching counts.
  var streamMetadata: [Sharing_Nearby_StreamMetadata] = []

  var unknownFields = SwiftProtobuf.UnknownStorage()

  enum Status: Int, SwiftProtobuf.Enum, Swift.CaseIterable {
    case unknown = 0
    case accept = 1
    case reject = 2
    case notEnoughSpace = 3
    case unsupportedAttachmentType = 4
    case timedOut = 5

    init() {
      self = .unknown
    }

  }

  init() {}

  fileprivate var _status: Sharing_Nearby_ConnectionResponseFrame.Status? = nil
}

/// Attachment details that sent in ConnectionResponseFrame.
/// NEXT_ID=3
struct Sharing_Nearby_AttachmentDetails: 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.

  /// The attachment family type.
  var type: Sharing_Nearby_AttachmentDetails.TypeEnum {
    get {return _type ?? .unknown}
    set {_type = newValue}
  }
  /// Returns true if `type` has been explicitly set.
  var hasType: Bool {return self._type != nil}
  /// Clears the value of `type`. Subsequent reads from it will return its default value.
  mutating func clearType() {self._type = nil}

  /// This field is only for FILE type.
  var fileAttachmentDetails: Sharing_Nearby_FileAttachmentDetails {
    get {return _fileAttachmentDetails ?? Sharing_Nearby_FileAttachmentDetails()}
    set {_fileAttachmentDetails = newValue}
  }
  /// Returns true if `fileAttachmentDetails` has been explicitly set.
  var hasFileAttachmentDetails: Bool {return self._fileAttachmentDetails != nil}
  /// Clears the value of `fileAttachmentDetails`. Subsequent reads from it will return its default value.
  mutating func clearFileAttachmentDetails() {self._fileAttachmentDetails = nil}

  var unknownFields = SwiftProtobuf.UnknownStorage()

  /// LINT.IfChange
  enum TypeEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable {
    case unknown = 0

    /// Represents FileAttachment.
    case file = 1

    /// Represents TextAttachment.
    case text = 2

    /// Represents WifiCredentialsAttachment.
    case wifiCredentials = 3

    /// Represents AppAttachment.
    case app = 4

    /// Represents StreamAttachment.
    case stream = 5

    init() {
      self = .unknown
    }

  }

  init() {}

  fileprivate var _type: Sharing_Nearby_AttachmentDetails.TypeEnum? = nil
  fileprivate var _fileAttachmentDetails: Sharing_Nearby_FileAttachmentDetails? = nil
}

/// File attachment details included in ConnectionResponseFrame.
/// NEXT_ID=3
struct Sharing_Nearby_FileAttachmentDetails: 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.

  /// Existing local file size on receiver side.
  var receiverExistingFileSize: Int64 {
    get {return _receiverExistingFileSize ?? 0}
    set {_receiverExistingFileSize = newValue}
  }
  /// Returns true if `receiverExistingFileSize` has been explicitly set.
  var hasReceiverExistingFileSize: Bool {return self._receiverExistingFileSize != nil}
  /// Clears the value of `receiverExistingFileSize`. Subsequent reads from it will return its default value.
  mutating func clearReceiverExistingFileSize() {self._receiverExistingFileSize = nil}

  /// The key is attachment hash, a stable identifier for the attachment.
  /// Value is list of payload details transferred for the attachment.
  var attachmentHashPayloads: Dictionary<Int64,Sharing_Nearby_PayloadsDetails> = [:]

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  fileprivate var _receiverExistingFileSize: Int64? = nil
}

/// NEXT_ID=2
struct Sharing_Nearby_PayloadsDetails: 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.

  /// The list should be sorted by creation timestamp.
  var payloadDetails: [Sharing_Nearby_PayloadDetails] = []

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

/// Metadata of a payload file created by Nearby Connections.
/// NEXT_ID=4
struct Sharing_Nearby_PayloadDetails: 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.

  var id: Int64 {
    get {return _id ?? 0}
    set {_id = newValue}
  }
  /// Returns true if `id` has been explicitly set.
  var hasID: Bool {return self._id != nil}
  /// Clears the value of `id`. Subsequent reads from it will return its default value.
  mutating func clearID() {self._id = nil}

  var creationTimestampMillis: Int64 {
    get {return _creationTimestampMillis ?? 0}
    set {_creationTimestampMillis = newValue}
  }
  /// Returns true if `creationTimestampMillis` has been explicitly set.
  var hasCreationTimestampMillis: Bool {return self._creationTimestampMillis != nil}
  /// Clears the value of `creationTimestampMillis`. Subsequent reads from it will return its default value.
  mutating func clearCreationTimestampMillis() {self._creationTimestampMillis = nil}

  var size: Int64 {
    get {return _size ?? 0}
    set {_size = newValue}
  }
  /// Returns true if `size` has been explicitly set.
  var hasSize: Bool {return self._size != nil}
  /// Clears the value of `size`. Subsequent reads from it will return its default value.
  mutating func clearSize() {self._size = nil}

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  fileprivate var _id: Int64? = nil
  fileprivate var _creationTimestampMillis: Int64? = nil
  fileprivate var _size: Int64? = nil
}

/// A paired key encryption packet sent between devices, contains signed data.
/// NEXT_ID=5
struct Sharing_Nearby_PairedKeyEncryptionFrame: 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.

  /// The encrypted data in byte array format.
  var signedData: Data {
    get {return _signedData ?? Data()}
    set {_signedData = newValue}
  }
  /// Returns true if `signedData` has been explicitly set.
  var hasSignedData: Bool {return self._signedData != nil}
  /// Clears the value of `signedData`. Subsequent reads from it will return its default value.
  mutating func clearSignedData() {self._signedData = nil}

  /// The hash of a certificate id.
  var secretIDHash: Data {
    get {return _secretIDHash ?? Data()}
    set {_secretIDHash = newValue}
  }
  /// Returns true if `secretIDHash` has been explicitly set.
  var hasSecretIDHash: Bool {return self._secretIDHash != nil}
  /// Clears the value of `secretIDHash`. Subsequent reads from it will return its default value.
  mutating func clearSecretIDHash() {self._secretIDHash = nil}

  /// An optional encrypted data in byte array format.
  var optionalSignedData: Data {
    get {return _optionalSignedData ?? Data()}
    set {_optionalSignedData = newValue}
  }
  /// Returns true if `optionalSignedData` has been explicitly set.
  var hasOptionalSignedData: Bool {return self._optionalSignedData != nil}
  /// Clears the value of `optionalSignedData`. Subsequent reads from it will return its default value.
  mutating func clearOptionalSignedData() {self._optionalSignedData = nil}

  /// An optional QR code handshake data in a byte array format.
  /// For incoming connection contains a signature of the UKEY2
  /// token, created with the sender's private key.
  /// For outgoing connection contains an HKDF of the connection token and of the
  /// UKEY2 token
  var qrCodeHandshakeData: Data {
    get {return _qrCodeHandshakeData ?? Data()}
    set {_qrCodeHandshakeData = newValue}
  }
  /// Returns true if `qrCodeHandshakeData` has been explicitly set.
  var hasQrCodeHandshakeData: Bool {return self._qrCodeHandshakeData != nil}
  /// Clears the value of `qrCodeHandshakeData`. Subsequent reads from it will return its default value.
  mutating func clearQrCodeHandshakeData() {self._qrCodeHandshakeData = nil}

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  fileprivate var _signedData: Data? = nil
  fileprivate var _secretIDHash: Data? = nil
  fileprivate var _optionalSignedData: Data? = nil
  fileprivate var _qrCodeHandshakeData: Data? = nil
}

/// A paired key verification result packet sent between devices.
/// NEXT_ID=3
struct Sharing_Nearby_PairedKeyResultFrame: 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.

  /// The verification result.
  var status: Sharing_Nearby_PairedKeyResultFrame.Status {
    get {return _status ?? .unknown}
    set {_status = newValue}
  }
  /// Returns true if `status` has been explicitly set.
  var hasStatus: Bool {return self._status != nil}
  /// Clears the value of `status`. Subsequent reads from it will return its default value.
  mutating func clearStatus() {self._status = nil}

  /// OS type.
  var osType: Location_Nearby_Proto_Sharing_OSType {
    get {return _osType ?? .unknownOsType}
    set {_osType = newValue}
  }
  /// Returns true if `osType` has been explicitly set.
  var hasOsType: Bool {return self._osType != nil}
  /// Clears the value of `osType`. Subsequent reads from it will return its default value.
  mutating func clearOsType() {self._osType = nil}

  var unknownFields = SwiftProtobuf.UnknownStorage()

  enum Status: Int, SwiftProtobuf.Enum, Swift.CaseIterable {
    case unknown = 0
    case success = 1
    case fail = 2
    case unable = 3

    init() {
      self = .unknown
    }

  }

  init() {}

  fileprivate var _status: Sharing_Nearby_PairedKeyResultFrame.Status? = nil
  fileprivate var _osType: Location_Nearby_Proto_Sharing_OSType? = nil
}

/// A package containing certificate info to be shared to remote device offline.
/// NEXT_ID=2
struct Sharing_Nearby_CertificateInfoFrame: 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.

  /// The public certificates to be shared with remote devices.
  var publicCertificate: [Sharing_Nearby_PublicCertificate] = []

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

/// A public certificate from the local device.
/// NEXT_ID=8
struct Sharing_Nearby_PublicCertificate: 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.

  /// The unique id of the public certificate.
  var secretID: Data {
    get {return _secretID ?? Data()}
    set {_secretID = newValue}
  }
  /// Returns true if `secretID` has been explicitly set.
  var hasSecretID: Bool {return self._secretID != nil}
  /// Clears the value of `secretID`. Subsequent reads from it will return its default value.
  mutating func clearSecretID() {self._secretID = nil}

  /// A bytes representation of a Secret Key owned by contact, to decrypt the
  /// metadata_key stored within the advertisement.
  var authenticityKey: Data {
    get {return _authenticityKey ?? Data()}
    set {_authenticityKey = newValue}
  }
  /// Returns true if `authenticityKey` has been explicitly set.
  var hasAuthenticityKey: Bool {return self._authenticityKey != nil}
  /// Clears the value of `authenticityKey`. Subsequent reads from it will return its default value.
  mutating func clearAuthenticityKey() {self._authenticityKey = nil}

  /// A bytes representation a public key of X509Certificate, owned by contact,
  /// to decrypt encrypted UKEY2 (from Nearby Connections API) as a hand shake in
  /// contact verification phase.
  var publicKey: Data {
    get {return _publicKey ?? Data()}
    set {_publicKey = newValue}
  }
  /// Returns true if `publicKey` has been explicitly set.
  var hasPublicKey: Bool {return self._publicKey != nil}
  /// Clears the value of `publicKey`. Subsequent reads from it will return its default value.
  mutating func clearPublicKey() {self._publicKey = nil}

  /// The time in millis from epoch when this certificate becomes effective.
  var startTime: Int64 {
    get {return _startTime ?? 0}
    set {_startTime = newValue}
  }
  /// Returns true if `startTime` has been explicitly set.
  var hasStartTime: Bool {return self._startTime != nil}
  /// Clears the value of `startTime`. Subsequent reads from it will return its default value.
  mutating func clearStartTime() {self._startTime = nil}

  /// The time in millis from epoch when this certificate expires.
  var endTime: Int64 {
    get {return _endTime ?? 0}
    set {_endTime = newValue}
  }
  /// Returns true if `endTime` has been explicitly set.
  var hasEndTime: Bool {return self._endTime != nil}
  /// Clears the value of `endTime`. Subsequent reads from it will return its default value.
  mutating func clearEndTime() {self._endTime = nil}

  /// The encrypted metadata in bytes, contains personal information of the
  /// device/user who created this certificate. Needs to be decrypted into bytes,
  /// and converted back to EncryptedMetadata object to access fields.
  var encryptedMetadataBytes: Data {
    get {return _encryptedMetadataBytes ?? Data()}
    set {_encryptedMetadataBytes = newValue}
  }
  /// Returns true if `encryptedMetadataBytes` has been explicitly set.
  var hasEncryptedMetadataBytes: Bool {return self._encryptedMetadataBytes != nil}
  /// Clears the value of `encryptedMetadataBytes`. Subsequent reads from it will return its default value.
  mutating func clearEncryptedMetadataBytes() {self._encryptedMetadataBytes = nil}

  /// The tag for verifying metadata_encryption_key.
  var metadataEncryptionKeyTag: Data {
    get {return _metadataEncryptionKeyTag ?? Data()}
    set {_metadataEncryptionKeyTag = newValue}
  }
  /// Returns true if `metadataEncryptionKeyTag` has been explicitly set.
  var hasMetadataEncryptionKeyTag: Bool {return self._metadataEncryptionKeyTag != nil}
  /// Clears the value of `metadataEncryptionKeyTag`. Subsequent reads from it will return its default value.
  mutating func clearMetadataEncryptionKeyTag() {self._metadataEncryptionKeyTag = nil}

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  fileprivate var _secretID: Data? = nil
  fileprivate var _authenticityKey: Data? = nil
  fileprivate var _publicKey: Data? = nil
  fileprivate var _startTime: Int64? = nil
  fileprivate var _endTime: Int64? = nil
  fileprivate var _encryptedMetadataBytes: Data? = nil
  fileprivate var _metadataEncryptionKeyTag: Data? = nil
}

/// NEXT_ID=3
struct Sharing_Nearby_WifiCredentials: 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.

  /// Wi-Fi password.
  var password: String {
    get {return _password ?? String()}
    set {_password = newValue}
  }
  /// Returns true if `password` has been explicitly set.
  var hasPassword: Bool {return self._password != nil}
  /// Clears the value of `password`. Subsequent reads from it will return its default value.
  mutating func clearPassword() {self._password = nil}

  /// True if the network is a hidden network that is not broadcasting its SSID.
  /// Default is false.
  var hiddenSsid: Bool {
    get {return _hiddenSsid ?? false}
    set {_hiddenSsid = newValue}
  }
  /// Returns true if `hiddenSsid` has been explicitly set.
  var hasHiddenSsid: Bool {return self._hiddenSsid != nil}
  /// Clears the value of `hiddenSsid`. Subsequent reads from it will return its default value.
  mutating func clearHiddenSsid() {self._hiddenSsid = nil}

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  fileprivate var _password: String? = nil
  fileprivate var _hiddenSsid: Bool? = nil
}

/// NEXT_ID=2
struct Sharing_Nearby_StreamDetails: 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.

  /// Serialized ParcelFileDescriptor for input stream (for the receiver).
  var inputStreamParcelFileDescriptorBytes: Data {
    get {return _inputStreamParcelFileDescriptorBytes ?? Data()}
    set {_inputStreamParcelFileDescriptorBytes = newValue}
  }
  /// Returns true if `inputStreamParcelFileDescriptorBytes` has been explicitly set.
  var hasInputStreamParcelFileDescriptorBytes: Bool {return self._inputStreamParcelFileDescriptorBytes != nil}
  /// Clears the value of `inputStreamParcelFileDescriptorBytes`. Subsequent reads from it will return its default value.
  mutating func clearInputStreamParcelFileDescriptorBytes() {self._inputStreamParcelFileDescriptorBytes = nil}

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  fileprivate var _inputStreamParcelFileDescriptorBytes: Data? = nil
}

// MARK: - Code below here is support for the SwiftProtobuf runtime.

fileprivate let _protobuf_package = "sharing.nearby"

extension Sharing_Nearby_FileMetadata: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".FileMetadata"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}name\0\u{1}type\0\u{3}payload_id\0\u{1}size\0\u{3}mime_type\0\u{1}id\0\u{3}parent_folder\0\u{3}attachment_hash\0\u{3}is_sensitive_content\0")

  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._name) }()
      case 2: try { try decoder.decodeSingularEnumField(value: &self._type) }()
      case 3: try { try decoder.decodeSingularInt64Field(value: &self._payloadID) }()
      case 4: try { try decoder.decodeSingularInt64Field(value: &self._size) }()
      case 5: try { try decoder.decodeSingularStringField(value: &self._mimeType) }()
      case 6: try { try decoder.decodeSingularInt64Field(value: &self._id) }()
      case 7: try { try decoder.decodeSingularStringField(value: &self._parentFolder) }()
      case 8: try { try decoder.decodeSingularInt64Field(value: &self._attachmentHash) }()
      case 9: try { try decoder.decodeSingularBoolField(value: &self._isSensitiveContent) }()
      default: break
      }
    }
  }

  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._name {
      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
    } }()
    try { if let v = self._type {
      try visitor.visitSingularEnumField(value: v, fieldNumber: 2)
    } }()
    try { if let v = self._payloadID {
      try visitor.visitSingularInt64Field(value: v, fieldNumber: 3)
    } }()
    try { if let v = self._size {
      try visitor.visitSingularInt64Field(value: v, fieldNumber: 4)
    } }()
    try { if let v = self._mimeType {
      try visitor.visitSingularStringField(value: v, fieldNumber: 5)
    } }()
    try { if let v = self._id {
      try visitor.visitSingularInt64Field(value: v, fieldNumber: 6)
    } }()
    try { if let v = self._parentFolder {
      try visitor.visitSingularStringField(value: v, fieldNumber: 7)
    } }()
    try { if let v = self._attachmentHash {
      try visitor.visitSingularInt64Field(value: v, fieldNumber: 8)
    } }()
    try { if let v = self._isSensitiveContent {
      try visitor.visitSingularBoolField(value: v, fieldNumber: 9)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Sharing_Nearby_FileMetadata, rhs: Sharing_Nearby_FileMetadata) -> Bool {
    if lhs._name != rhs._name {return false}
    if lhs._type != rhs._type {return false}
    if lhs._payloadID != rhs._payloadID {return false}
    if lhs._size != rhs._size {return false}
    if lhs._mimeType != rhs._mimeType {return false}
    if lhs._id != rhs._id {return false}
    if lhs._parentFolder != rhs._parentFolder {return false}
    if lhs._attachmentHash != rhs._attachmentHash {return false}
    if lhs._isSensitiveContent != rhs._isSensitiveContent {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Sharing_Nearby_FileMetadata.TypeEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNKNOWN\0\u{1}IMAGE\0\u{1}VIDEO\0\u{1}ANDROID_APP\0\u{1}AUDIO\0\u{1}DOCUMENT\0\u{1}CONTACT_CARD\0")
}

extension Sharing_Nearby_TextMetadata: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".TextMetadata"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{2}text_title\0\u{1}type\0\u{3}payload_id\0\u{1}size\0\u{1}id\0\u{3}is_sensitive_text\0")

  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 { try decoder.decodeSingularStringField(value: &self._textTitle) }()
      case 3: try { try decoder.decodeSingularEnumField(value: &self._type) }()
      case 4: try { try decoder.decodeSingularInt64Field(value: &self._payloadID) }()
      case 5: try { try decoder.decodeSingularInt64Field(value: &self._size) }()
      case 6: try { try decoder.decodeSingularInt64Field(value: &self._id) }()
      case 7: try { try decoder.decodeSingularBoolField(value: &self._isSensitiveText) }()
      default: break
      }
    }
  }

  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._textTitle {
      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
    } }()
    try { if let v = self._type {
      try visitor.visitSingularEnumField(value: v, fieldNumber: 3)
    } }()
    try { if let v = self._payloadID {
      try visitor.visitSingularInt64Field(value: v, fieldNumber: 4)
    } }()
    try { if let v = self._size {
      try visitor.visitSingularInt64Field(value: v, fieldNumber: 5)
    } }()
    try { if let v = self._id {
      try visitor.visitSingularInt64Field(value: v, fieldNumber: 6)
    } }()
    try { if let v = self._isSensitiveText {
      try visitor.visitSingularBoolField(value: v, fieldNumber: 7)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Sharing_Nearby_TextMetadata, rhs: Sharing_Nearby_TextMetadata) -> Bool {
    if lhs._textTitle != rhs._textTitle {return false}
    if lhs._type != rhs._type {return false}
    if lhs._payloadID != rhs._payloadID {return false}
    if lhs._size != rhs._size {return false}
    if lhs._id != rhs._id {return false}
    if lhs._isSensitiveText != rhs._isSensitiveText {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Sharing_Nearby_TextMetadata.TypeEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNKNOWN\0\u{1}TEXT\0\u{1}URL\0\u{1}ADDRESS\0\u{1}PHONE_NUMBER\0")
}

extension Sharing_Nearby_WifiCredentialsMetadata: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".WifiCredentialsMetadata"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{2}ssid\0\u{3}security_type\0\u{3}payload_id\0\u{1}id\0")

  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 { try decoder.decodeSingularStringField(value: &self._ssid) }()
      case 3: try { try decoder.decodeSingularEnumField(value: &self._securityType) }()
      case 4: try { try decoder.decodeSingularInt64Field(value: &self._payloadID) }()
      case 5: try { try decoder.decodeSingularInt64Field(value: &self._id) }()
      default: break
      }
    }
  }

  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._ssid {
      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
    } }()
    try { if let v = self._securityType {
      try visitor.visitSingularEnumField(value: v, fieldNumber: 3)
    } }()
    try { if let v = self._payloadID {
      try visitor.visitSingularInt64Field(value: v, fieldNumber: 4)
    } }()
    try { if let v = self._id {
      try visitor.visitSingularInt64Field(value: v, fieldNumber: 5)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Sharing_Nearby_WifiCredentialsMetadata, rhs: Sharing_Nearby_WifiCredentialsMetadata) -> Bool {
    if lhs._ssid != rhs._ssid {return false}
    if lhs._securityType != rhs._securityType {return false}
    if lhs._payloadID != rhs._payloadID {return false}
    if lhs._id != rhs._id {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Sharing_Nearby_WifiCredentialsMetadata.SecurityType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNKNOWN_SECURITY_TYPE\0\u{1}OPEN\0\u{1}WPA_PSK\0\u{1}WEP\0\u{1}SAE\0")
}

extension Sharing_Nearby_MirroredNotificationMetadata: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".MirroredNotificationMetadata"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}version\0\u{3}notification_key\0\u{3}package_name\0\u{3}app_name\0\u{1}title\0\u{1}body\0\u{3}posted_at_epoch_ms\0\u{c}\u{8}\u{1}\u{c}\u{9}\u{1}")

  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.decodeSingularInt32Field(value: &self._version) }()
      case 2: try { try decoder.decodeSingularStringField(value: &self._notificationKey) }()
      case 3: try { try decoder.decodeSingularStringField(value: &self._packageName) }()
      case 4: try { try decoder.decodeSingularStringField(value: &self._appName) }()
      case 5: try { try decoder.decodeSingularStringField(value: &self._title) }()
      case 6: try { try decoder.decodeSingularStringField(value: &self._body) }()
      case 7: try { try decoder.decodeSingularInt64Field(value: &self._postedAtEpochMs) }()
      default: break
      }
    }
  }

  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._version {
      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
    } }()
    try { if let v = self._notificationKey {
      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
    } }()
    try { if let v = self._packageName {
      try visitor.visitSingularStringField(value: v, fieldNumber: 3)
    } }()
    try { if let v = self._appName {
      try visitor.visitSingularStringField(value: v, fieldNumber: 4)
    } }()
    try { if let v = self._title {
      try visitor.visitSingularStringField(value: v, fieldNumber: 5)
    } }()
    try { if let v = self._body {
      try visitor.visitSingularStringField(value: v, fieldNumber: 6)
    } }()
    try { if let v = self._postedAtEpochMs {
      try visitor.visitSingularInt64Field(value: v, fieldNumber: 7)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Sharing_Nearby_MirroredNotificationMetadata, rhs: Sharing_Nearby_MirroredNotificationMetadata) -> Bool {
    if lhs._version != rhs._version {return false}
    if lhs._notificationKey != rhs._notificationKey {return false}
    if lhs._packageName != rhs._packageName {return false}
    if lhs._appName != rhs._appName {return false}
    if lhs._title != rhs._title {return false}
    if lhs._body != rhs._body {return false}
    if lhs._postedAtEpochMs != rhs._postedAtEpochMs {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Sharing_Nearby_PairingMetadata: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".PairingMetadata"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}version\0\u{3}use_case\0\u{3}setup_request\0\u{3}setup_pin_hash\0")

  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.decodeSingularInt32Field(value: &self._version) }()
      case 2: try { try decoder.decodeSingularEnumField(value: &self._useCase) }()
      case 3: try { try decoder.decodeSingularBoolField(value: &self._setupRequest) }()
      case 4: try { try decoder.decodeSingularBytesField(value: &self._setupPinHash) }()
      default: break
      }
    }
  }

  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._version {
      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
    } }()
    try { if let v = self._useCase {
      try visitor.visitSingularEnumField(value: v, fieldNumber: 2)
    } }()
    try { if let v = self._setupRequest {
      try visitor.visitSingularBoolField(value: v, fieldNumber: 3)
    } }()
    try { if let v = self._setupPinHash {
      try visitor.visitSingularBytesField(value: v, fieldNumber: 4)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Sharing_Nearby_PairingMetadata, rhs: Sharing_Nearby_PairingMetadata) -> Bool {
    if lhs._version != rhs._version {return false}
    if lhs._useCase != rhs._useCase {return false}
    if lhs._setupRequest != rhs._setupRequest {return false}
    if lhs._setupPinHash != rhs._setupPinHash {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Sharing_Nearby_PairingMetadata.UseCase: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNKNOWN\0\u{1}NOTIFICATION_SYNC\0\u{1}CLIPBOARD_SYNC\0")
}

extension Sharing_Nearby_AppMetadata: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".AppMetadata"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}app_name\0\u{1}size\0\u{3}payload_id\0\u{1}id\0\u{3}file_name\0\u{3}file_size\0\u{3}package_name\0")

  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._appName) }()
      case 2: try { try decoder.decodeSingularInt64Field(value: &self._size) }()
      case 3: try { try decoder.decodeRepeatedInt64Field(value: &self.payloadID) }()
      case 4: try { try decoder.decodeSingularInt64Field(value: &self._id) }()
      case 5: try { try decoder.decodeRepeatedStringField(value: &self.fileName) }()
      case 6: try { try decoder.decodeRepeatedInt64Field(value: &self.fileSize) }()
      case 7: try { try decoder.decodeSingularStringField(value: &self._packageName) }()
      default: break
      }
    }
  }

  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._appName {
      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
    } }()
    try { if let v = self._size {
      try visitor.visitSingularInt64Field(value: v, fieldNumber: 2)
    } }()
    if !self.payloadID.isEmpty {
      try visitor.visitPackedInt64Field(value: self.payloadID, fieldNumber: 3)
    }
    try { if let v = self._id {
      try visitor.visitSingularInt64Field(value: v, fieldNumber: 4)
    } }()
    if !self.fileName.isEmpty {
      try visitor.visitRepeatedStringField(value: self.fileName, fieldNumber: 5)
    }
    if !self.fileSize.isEmpty {
      try visitor.visitPackedInt64Field(value: self.fileSize, fieldNumber: 6)
    }
    try { if let v = self._packageName {
      try visitor.visitSingularStringField(value: v, fieldNumber: 7)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Sharing_Nearby_AppMetadata, rhs: Sharing_Nearby_AppMetadata) -> Bool {
    if lhs._appName != rhs._appName {return false}
    if lhs._size != rhs._size {return false}
    if lhs.payloadID != rhs.payloadID {return false}
    if lhs._id != rhs._id {return false}
    if lhs.fileName != rhs.fileName {return false}
    if lhs.fileSize != rhs.fileSize {return false}
    if lhs._packageName != rhs._packageName {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Sharing_Nearby_StreamMetadata: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".StreamMetadata"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}description\0\u{3}package_name\0\u{3}payload_id\0\u{3}attributed_app_name\0")

  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._description_p) }()
      case 2: try { try decoder.decodeSingularStringField(value: &self._packageName) }()
      case 3: try { try decoder.decodeSingularInt64Field(value: &self._payloadID) }()
      case 4: try { try decoder.decodeSingularStringField(value: &self._attributedAppName) }()
      default: break
      }
    }
  }

  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._description_p {
      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
    } }()
    try { if let v = self._packageName {
      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
    } }()
    try { if let v = self._payloadID {
      try visitor.visitSingularInt64Field(value: v, fieldNumber: 3)
    } }()
    try { if let v = self._attributedAppName {
      try visitor.visitSingularStringField(value: v, fieldNumber: 4)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Sharing_Nearby_StreamMetadata, rhs: Sharing_Nearby_StreamMetadata) -> Bool {
    if lhs._description_p != rhs._description_p {return false}
    if lhs._packageName != rhs._packageName {return false}
    if lhs._payloadID != rhs._payloadID {return false}
    if lhs._attributedAppName != rhs._attributedAppName {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Sharing_Nearby_Frame: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".Frame"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}version\0\u{1}v1\0")

  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._version) }()
      case 2: try { try decoder.decodeSingularMessageField(value: &self._v1) }()
      default: break
      }
    }
  }

  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._version {
      try visitor.visitSingularEnumField(value: v, fieldNumber: 1)
    } }()
    try { if let v = self._v1 {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Sharing_Nearby_Frame, rhs: Sharing_Nearby_Frame) -> Bool {
    if lhs._version != rhs._version {return false}
    if lhs._v1 != rhs._v1 {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Sharing_Nearby_Frame.Version: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNKNOWN_VERSION\0\u{1}V1\0")
}

extension Sharing_Nearby_V1Frame: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".V1Frame"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}type\0\u{1}introduction\0\u{3}connection_response\0\u{3}paired_key_encryption\0\u{3}paired_key_result\0\u{3}certificate_info\0\u{3}progress_update\0")

  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._type) }()
      case 2: try { try decoder.decodeSingularMessageField(value: &self._introduction) }()
      case 3: try { try decoder.decodeSingularMessageField(value: &self._connectionResponse) }()
      case 4: try { try decoder.decodeSingularMessageField(value: &self._pairedKeyEncryption) }()
      case 5: try { try decoder.decodeSingularMessageField(value: &self._pairedKeyResult) }()
      case 6: try { try decoder.decodeSingularMessageField(value: &self._certificateInfo) }()
      case 7: try { try decoder.decodeSingularMessageField(value: &self._progressUpdate) }()
      default: break
      }
    }
  }

  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._type {
      try visitor.visitSingularEnumField(value: v, fieldNumber: 1)
    } }()
    try { if let v = self._introduction {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
    } }()
    try { if let v = self._connectionResponse {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
    } }()
    try { if let v = self._pairedKeyEncryption {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
    } }()
    try { if let v = self._pairedKeyResult {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 5)
    } }()
    try { if let v = self._certificateInfo {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 6)
    } }()
    try { if let v = self._progressUpdate {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 7)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Sharing_Nearby_V1Frame, rhs: Sharing_Nearby_V1Frame) -> Bool {
    if lhs._type != rhs._type {return false}
    if lhs._introduction != rhs._introduction {return false}
    if lhs._connectionResponse != rhs._connectionResponse {return false}
    if lhs._pairedKeyEncryption != rhs._pairedKeyEncryption {return false}
    if lhs._pairedKeyResult != rhs._pairedKeyResult {return false}
    if lhs._certificateInfo != rhs._certificateInfo {return false}
    if lhs._progressUpdate != rhs._progressUpdate {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Sharing_Nearby_V1Frame.FrameType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNKNOWN_FRAME_TYPE\0\u{1}INTRODUCTION\0\u{1}RESPONSE\0\u{1}PAIRED_KEY_ENCRYPTION\0\u{1}PAIRED_KEY_RESULT\0\u{1}CERTIFICATE_INFO\0\u{1}CANCEL\0\u{1}PROGRESS_UPDATE\0")
}

extension Sharing_Nearby_IntroductionFrame: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".IntroductionFrame"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}file_metadata\0\u{3}text_metadata\0\u{3}required_package\0\u{3}wifi_credentials_metadata\0\u{3}app_metadata\0\u{3}start_transfer\0\u{3}stream_metadata\0\u{3}use_case\0\u{3}preview_payload_ids\0\u{4}`\u{f}mirrored_notification_metadata\0\u{3}pairing_metadata\0")

  fileprivate class _StorageClass {
    var _fileMetadata: [Sharing_Nearby_FileMetadata] = []
    var _textMetadata: [Sharing_Nearby_TextMetadata] = []
    var _requiredPackage: String? = nil
    var _wifiCredentialsMetadata: [Sharing_Nearby_WifiCredentialsMetadata] = []
    var _appMetadata: [Sharing_Nearby_AppMetadata] = []
    var _startTransfer: Bool? = nil
    var _streamMetadata: [Sharing_Nearby_StreamMetadata] = []
    var _useCase: Sharing_Nearby_IntroductionFrame.SharingUseCase? = nil
    var _previewPayloadIds: [Int64] = []
    var _mirroredNotificationMetadata: Sharing_Nearby_MirroredNotificationMetadata? = nil
    var _pairingMetadata: Sharing_Nearby_PairingMetadata? = nil

      // 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()

    private init() {}

    init(copying source: _StorageClass) {
      _fileMetadata = source._fileMetadata
      _textMetadata = source._textMetadata
      _requiredPackage = source._requiredPackage
      _wifiCredentialsMetadata = source._wifiCredentialsMetadata
      _appMetadata = source._appMetadata
      _startTransfer = source._startTransfer
      _streamMetadata = source._streamMetadata
      _useCase = source._useCase
      _previewPayloadIds = source._previewPayloadIds
      _mirroredNotificationMetadata = source._mirroredNotificationMetadata
      _pairingMetadata = source._pairingMetadata
    }
  }

  fileprivate mutating func _uniqueStorage() -> _StorageClass {
    if !isKnownUniquelyReferenced(&_storage) {
      _storage = _StorageClass(copying: _storage)
    }
    return _storage
  }

  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.decodeRepeatedMessageField(value: &_storage._fileMetadata) }()
        case 2: try { try decoder.decodeRepeatedMessageField(value: &_storage._textMetadata) }()
        case 3: try { try decoder.decodeSingularStringField(value: &_storage._requiredPackage) }()
        case 4: try { try decoder.decodeRepeatedMessageField(value: &_storage._wifiCredentialsMetadata) }()
        case 5: try { try decoder.decodeRepeatedMessageField(value: &_storage._appMetadata) }()
        case 6: try { try decoder.decodeSingularBoolField(value: &_storage._startTransfer) }()
        case 7: try { try decoder.decodeRepeatedMessageField(value: &_storage._streamMetadata) }()
        case 8: try { try decoder.decodeSingularEnumField(value: &_storage._useCase) }()
        case 9: try { try decoder.decodeRepeatedInt64Field(value: &_storage._previewPayloadIds) }()
        case 1001: try { try decoder.decodeSingularMessageField(value: &_storage._mirroredNotificationMetadata) }()
        case 1002: try { try decoder.decodeSingularMessageField(value: &_storage._pairingMetadata) }()
        default: break
        }
      }
    }
  }

  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
      if !_storage._fileMetadata.isEmpty {
        try visitor.visitRepeatedMessageField(value: _storage._fileMetadata, fieldNumber: 1)
      }
      if !_storage._textMetadata.isEmpty {
        try visitor.visitRepeatedMessageField(value: _storage._textMetadata, fieldNumber: 2)
      }
      try { if let v = _storage._requiredPackage {
        try visitor.visitSingularStringField(value: v, fieldNumber: 3)
      } }()
      if !_storage._wifiCredentialsMetadata.isEmpty {
        try visitor.visitRepeatedMessageField(value: _storage._wifiCredentialsMetadata, fieldNumber: 4)
      }
      if !_storage._appMetadata.isEmpty {
        try visitor.visitRepeatedMessageField(value: _storage._appMetadata, fieldNumber: 5)
      }
      try { if let v = _storage._startTransfer {
        try visitor.visitSingularBoolField(value: v, fieldNumber: 6)
      } }()
      if !_storage._streamMetadata.isEmpty {
        try visitor.visitRepeatedMessageField(value: _storage._streamMetadata, fieldNumber: 7)
      }
      try { if let v = _storage._useCase {
        try visitor.visitSingularEnumField(value: v, fieldNumber: 8)
      } }()
      if !_storage._previewPayloadIds.isEmpty {
        try visitor.visitRepeatedInt64Field(value: _storage._previewPayloadIds, fieldNumber: 9)
      }
      try { if let v = _storage._mirroredNotificationMetadata {
        try visitor.visitSingularMessageField(value: v, fieldNumber: 1001)
      } }()
      try { if let v = _storage._pairingMetadata {
        try visitor.visitSingularMessageField(value: v, fieldNumber: 1002)
      } }()
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Sharing_Nearby_IntroductionFrame, rhs: Sharing_Nearby_IntroductionFrame) -> 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._fileMetadata != rhs_storage._fileMetadata {return false}
        if _storage._textMetadata != rhs_storage._textMetadata {return false}
        if _storage._requiredPackage != rhs_storage._requiredPackage {return false}
        if _storage._wifiCredentialsMetadata != rhs_storage._wifiCredentialsMetadata {return false}
        if _storage._appMetadata != rhs_storage._appMetadata {return false}
        if _storage._startTransfer != rhs_storage._startTransfer {return false}
        if _storage._streamMetadata != rhs_storage._streamMetadata {return false}
        if _storage._useCase != rhs_storage._useCase {return false}
        if _storage._previewPayloadIds != rhs_storage._previewPayloadIds {return false}
        if _storage._mirroredNotificationMetadata != rhs_storage._mirroredNotificationMetadata {return false}
        if _storage._pairingMetadata != rhs_storage._pairingMetadata {return false}
        return true
      }
      if !storagesAreEqual {return false}
    }
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Sharing_Nearby_IntroductionFrame.SharingUseCase: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNKNOWN\0\u{1}NEARBY_SHARE\0\u{1}REMOTE_COPY\0")
}

extension Sharing_Nearby_ProgressUpdateFrame: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".ProgressUpdateFrame"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}progress\0\u{3}start_transfer\0")

  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.decodeSingularFloatField(value: &self._progress) }()
      case 2: try { try decoder.decodeSingularBoolField(value: &self._startTransfer) }()
      default: break
      }
    }
  }

  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._progress {
      try visitor.visitSingularFloatField(value: v, fieldNumber: 1)
    } }()
    try { if let v = self._startTransfer {
      try visitor.visitSingularBoolField(value: v, fieldNumber: 2)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Sharing_Nearby_ProgressUpdateFrame, rhs: Sharing_Nearby_ProgressUpdateFrame) -> Bool {
    if lhs._progress != rhs._progress {return false}
    if lhs._startTransfer != rhs._startTransfer {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Sharing_Nearby_ConnectionResponseFrame: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".ConnectionResponseFrame"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}status\0\u{3}attachment_details\0\u{3}stream_metadata\0")

  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) }()
      case 2: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt64,Sharing_Nearby_AttachmentDetails>.self, value: &self.attachmentDetails) }()
      case 3: try { try decoder.decodeRepeatedMessageField(value: &self.streamMetadata) }()
      default: break
      }
    }
  }

  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)
    } }()
    if !self.attachmentDetails.isEmpty {
      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt64,Sharing_Nearby_AttachmentDetails>.self, value: self.attachmentDetails, fieldNumber: 2)
    }
    if !self.streamMetadata.isEmpty {
      try visitor.visitRepeatedMessageField(value: self.streamMetadata, fieldNumber: 3)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Sharing_Nearby_ConnectionResponseFrame, rhs: Sharing_Nearby_ConnectionResponseFrame) -> Bool {
    if lhs._status != rhs._status {return false}
    if lhs.attachmentDetails != rhs.attachmentDetails {return false}
    if lhs.streamMetadata != rhs.streamMetadata {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Sharing_Nearby_ConnectionResponseFrame.Status: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNKNOWN\0\u{1}ACCEPT\0\u{1}REJECT\0\u{1}NOT_ENOUGH_SPACE\0\u{1}UNSUPPORTED_ATTACHMENT_TYPE\0\u{1}TIMED_OUT\0")
}

extension Sharing_Nearby_AttachmentDetails: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".AttachmentDetails"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}type\0\u{3}file_attachment_details\0")

  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._type) }()
      case 2: try { try decoder.decodeSingularMessageField(value: &self._fileAttachmentDetails) }()
      default: break
      }
    }
  }

  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._type {
      try visitor.visitSingularEnumField(value: v, fieldNumber: 1)
    } }()
    try { if let v = self._fileAttachmentDetails {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Sharing_Nearby_AttachmentDetails, rhs: Sharing_Nearby_AttachmentDetails) -> Bool {
    if lhs._type != rhs._type {return false}
    if lhs._fileAttachmentDetails != rhs._fileAttachmentDetails {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Sharing_Nearby_AttachmentDetails.TypeEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNKNOWN\0\u{1}FILE\0\u{1}TEXT\0\u{1}WIFI_CREDENTIALS\0\u{1}APP\0\u{1}STREAM\0")
}

extension Sharing_Nearby_FileAttachmentDetails: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".FileAttachmentDetails"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}receiver_existing_file_size\0\u{3}attachment_hash_payloads\0")

  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.decodeSingularInt64Field(value: &self._receiverExistingFileSize) }()
      case 2: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt64,Sharing_Nearby_PayloadsDetails>.self, value: &self.attachmentHashPayloads) }()
      default: break
      }
    }
  }

  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._receiverExistingFileSize {
      try visitor.visitSingularInt64Field(value: v, fieldNumber: 1)
    } }()
    if !self.attachmentHashPayloads.isEmpty {
      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufInt64,Sharing_Nearby_PayloadsDetails>.self, value: self.attachmentHashPayloads, fieldNumber: 2)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Sharing_Nearby_FileAttachmentDetails, rhs: Sharing_Nearby_FileAttachmentDetails) -> Bool {
    if lhs._receiverExistingFileSize != rhs._receiverExistingFileSize {return false}
    if lhs.attachmentHashPayloads != rhs.attachmentHashPayloads {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Sharing_Nearby_PayloadsDetails: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".PayloadsDetails"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}payload_details\0")

  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.payloadDetails) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.payloadDetails.isEmpty {
      try visitor.visitRepeatedMessageField(value: self.payloadDetails, fieldNumber: 1)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Sharing_Nearby_PayloadsDetails, rhs: Sharing_Nearby_PayloadsDetails) -> Bool {
    if lhs.payloadDetails != rhs.payloadDetails {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Sharing_Nearby_PayloadDetails: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".PayloadDetails"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}id\0\u{3}creation_timestamp_millis\0\u{1}size\0")

  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.decodeSingularInt64Field(value: &self._id) }()
      case 2: try { try decoder.decodeSingularInt64Field(value: &self._creationTimestampMillis) }()
      case 3: try { try decoder.decodeSingularInt64Field(value: &self._size) }()
      default: break
      }
    }
  }

  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.visitSingularInt64Field(value: v, fieldNumber: 1)
    } }()
    try { if let v = self._creationTimestampMillis {
      try visitor.visitSingularInt64Field(value: v, fieldNumber: 2)
    } }()
    try { if let v = self._size {
      try visitor.visitSingularInt64Field(value: v, fieldNumber: 3)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Sharing_Nearby_PayloadDetails, rhs: Sharing_Nearby_PayloadDetails) -> Bool {
    if lhs._id != rhs._id {return false}
    if lhs._creationTimestampMillis != rhs._creationTimestampMillis {return false}
    if lhs._size != rhs._size {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Sharing_Nearby_PairedKeyEncryptionFrame: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".PairedKeyEncryptionFrame"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}signed_data\0\u{3}secret_id_hash\0\u{3}optional_signed_data\0\u{3}qr_code_handshake_data\0")

  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._signedData) }()
      case 2: try { try decoder.decodeSingularBytesField(value: &self._secretIDHash) }()
      case 3: try { try decoder.decodeSingularBytesField(value: &self._optionalSignedData) }()
      case 4: try { try decoder.decodeSingularBytesField(value: &self._qrCodeHandshakeData) }()
      default: break
      }
    }
  }

  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._signedData {
      try visitor.visitSingularBytesField(value: v, fieldNumber: 1)
    } }()
    try { if let v = self._secretIDHash {
      try visitor.visitSingularBytesField(value: v, fieldNumber: 2)
    } }()
    try { if let v = self._optionalSignedData {
      try visitor.visitSingularBytesField(value: v, fieldNumber: 3)
    } }()
    try { if let v = self._qrCodeHandshakeData {
      try visitor.visitSingularBytesField(value: v, fieldNumber: 4)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Sharing_Nearby_PairedKeyEncryptionFrame, rhs: Sharing_Nearby_PairedKeyEncryptionFrame) -> Bool {
    if lhs._signedData != rhs._signedData {return false}
    if lhs._secretIDHash != rhs._secretIDHash {return false}
    if lhs._optionalSignedData != rhs._optionalSignedData {return false}
    if lhs._qrCodeHandshakeData != rhs._qrCodeHandshakeData {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Sharing_Nearby_PairedKeyResultFrame: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".PairedKeyResultFrame"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}status\0\u{3}os_type\0")

  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) }()
      case 2: try { try decoder.decodeSingularEnumField(value: &self._osType) }()
      default: break
      }
    }
  }

  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 { if let v = self._osType {
      try visitor.visitSingularEnumField(value: v, fieldNumber: 2)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Sharing_Nearby_PairedKeyResultFrame, rhs: Sharing_Nearby_PairedKeyResultFrame) -> Bool {
    if lhs._status != rhs._status {return false}
    if lhs._osType != rhs._osType {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Sharing_Nearby_PairedKeyResultFrame.Status: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNKNOWN\0\u{1}SUCCESS\0\u{1}FAIL\0\u{1}UNABLE\0")
}

extension Sharing_Nearby_CertificateInfoFrame: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".CertificateInfoFrame"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}public_certificate\0")

  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.publicCertificate) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.publicCertificate.isEmpty {
      try visitor.visitRepeatedMessageField(value: self.publicCertificate, fieldNumber: 1)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Sharing_Nearby_CertificateInfoFrame, rhs: Sharing_Nearby_CertificateInfoFrame) -> Bool {
    if lhs.publicCertificate != rhs.publicCertificate {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Sharing_Nearby_PublicCertificate: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".PublicCertificate"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}secret_id\0\u{3}authenticity_key\0\u{3}public_key\0\u{3}start_time\0\u{3}end_time\0\u{3}encrypted_metadata_bytes\0\u{3}metadata_encryption_key_tag\0")

  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._secretID) }()
      case 2: try { try decoder.decodeSingularBytesField(value: &self._authenticityKey) }()
      case 3: try { try decoder.decodeSingularBytesField(value: &self._publicKey) }()
      case 4: try { try decoder.decodeSingularInt64Field(value: &self._startTime) }()
      case 5: try { try decoder.decodeSingularInt64Field(value: &self._endTime) }()
      case 6: try { try decoder.decodeSingularBytesField(value: &self._encryptedMetadataBytes) }()
      case 7: try { try decoder.decodeSingularBytesField(value: &self._metadataEncryptionKeyTag) }()
      default: break
      }
    }
  }

  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._secretID {
      try visitor.visitSingularBytesField(value: v, fieldNumber: 1)
    } }()
    try { if let v = self._authenticityKey {
      try visitor.visitSingularBytesField(value: v, fieldNumber: 2)
    } }()
    try { if let v = self._publicKey {
      try visitor.visitSingularBytesField(value: v, fieldNumber: 3)
    } }()
    try { if let v = self._startTime {
      try visitor.visitSingularInt64Field(value: v, fieldNumber: 4)
    } }()
    try { if let v = self._endTime {
      try visitor.visitSingularInt64Field(value: v, fieldNumber: 5)
    } }()
    try { if let v = self._encryptedMetadataBytes {
      try visitor.visitSingularBytesField(value: v, fieldNumber: 6)
    } }()
    try { if let v = self._metadataEncryptionKeyTag {
      try visitor.visitSingularBytesField(value: v, fieldNumber: 7)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Sharing_Nearby_PublicCertificate, rhs: Sharing_Nearby_PublicCertificate) -> Bool {
    if lhs._secretID != rhs._secretID {return false}
    if lhs._authenticityKey != rhs._authenticityKey {return false}
    if lhs._publicKey != rhs._publicKey {return false}
    if lhs._startTime != rhs._startTime {return false}
    if lhs._endTime != rhs._endTime {return false}
    if lhs._encryptedMetadataBytes != rhs._encryptedMetadataBytes {return false}
    if lhs._metadataEncryptionKeyTag != rhs._metadataEncryptionKeyTag {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Sharing_Nearby_WifiCredentials: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".WifiCredentials"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}password\0\u{3}hidden_ssid\0")

  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._password) }()
      case 2: try { try decoder.decodeSingularBoolField(value: &self._hiddenSsid) }()
      default: break
      }
    }
  }

  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._password {
      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
    } }()
    try { if let v = self._hiddenSsid {
      try visitor.visitSingularBoolField(value: v, fieldNumber: 2)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Sharing_Nearby_WifiCredentials, rhs: Sharing_Nearby_WifiCredentials) -> Bool {
    if lhs._password != rhs._password {return false}
    if lhs._hiddenSsid != rhs._hiddenSsid {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Sharing_Nearby_StreamDetails: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".StreamDetails"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}input_stream_parcel_file_descriptor_bytes\0")

  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._inputStreamParcelFileDescriptorBytes) }()
      default: break
      }
    }
  }

  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._inputStreamParcelFileDescriptorBytes {
      try visitor.visitSingularBytesField(value: v, fieldNumber: 1)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Sharing_Nearby_StreamDetails, rhs: Sharing_Nearby_StreamDetails) -> Bool {
    if lhs._inputStreamParcelFileDescriptorBytes != rhs._inputStreamParcelFileDescriptorBytes {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}