SandboxContext.pb.swift

//===----------------------------------------------------------------------===//
// Copyright © 2025-2026 Apple Inc. and the Containerization project authors.
//
// 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.
//===----------------------------------------------------------------------===//

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

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
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 nonisolated struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck {
  struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {}
  typealias Version = _2
}

/// Categories of statistics that can be requested.
public nonisolated enum Com_Apple_Containerization_Sandbox_V3_StatCategory: SwiftProtobuf.Enum, Swift.CaseIterable {
  public typealias RawValue = Int
  case unspecified // = 0
  case process // = 1
  case memory // = 2
  case cpu // = 3
  case blockIo // = 4
  case network // = 5
  case memoryEvents // = 6
  case UNRECOGNIZED(Int)

  public init() {
    self = .unspecified
  }

  public init?(rawValue: Int) {
    switch rawValue {
    case 0: self = .unspecified
    case 1: self = .process
    case 2: self = .memory
    case 3: self = .cpu
    case 4: self = .blockIo
    case 5: self = .network
    case 6: self = .memoryEvents
    default: self = .UNRECOGNIZED(rawValue)
    }
  }

  public var rawValue: Int {
    switch self {
    case .unspecified: return 0
    case .process: return 1
    case .memory: return 2
    case .cpu: return 3
    case .blockIo: return 4
    case .network: return 5
    case .memoryEvents: return 6
    case .UNRECOGNIZED(let i): return i
    }
  }

  // The compiler won't synthesize support with the UNRECOGNIZED case.
  public static let allCases: [Com_Apple_Containerization_Sandbox_V3_StatCategory] = [
    .unspecified,
    .process,
    .memory,
    .cpu,
    .blockIo,
    .network,
    .memoryEvents,
  ]

}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_Stdio: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var stdinPort: Int32 {
    get {_stdinPort ?? 0}
    set {_stdinPort = newValue}
  }
  /// Returns true if `stdinPort` has been explicitly set.
  public var hasStdinPort: Bool {self._stdinPort != nil}
  /// Clears the value of `stdinPort`. Subsequent reads from it will return its default value.
  public mutating func clearStdinPort() {self._stdinPort = nil}

  public var stdoutPort: Int32 {
    get {_stdoutPort ?? 0}
    set {_stdoutPort = newValue}
  }
  /// Returns true if `stdoutPort` has been explicitly set.
  public var hasStdoutPort: Bool {self._stdoutPort != nil}
  /// Clears the value of `stdoutPort`. Subsequent reads from it will return its default value.
  public mutating func clearStdoutPort() {self._stdoutPort = nil}

  public var stderrPort: Int32 {
    get {_stderrPort ?? 0}
    set {_stderrPort = newValue}
  }
  /// Returns true if `stderrPort` has been explicitly set.
  public var hasStderrPort: Bool {self._stderrPort != nil}
  /// Clears the value of `stderrPort`. Subsequent reads from it will return its default value.
  public mutating func clearStderrPort() {self._stderrPort = nil}

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}

  fileprivate var _stdinPort: Int32? = nil
  fileprivate var _stdoutPort: Int32? = nil
  fileprivate var _stderrPort: Int32? = nil
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var binaryPath: String = String()

  public var name: String = String()

  public var type: String = String()

  public var offset: String = String()

  public var magic: String = String()

  public var mask: String = String()

  public var flags: String = String()

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_SetupEmulatorResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_SetTimeRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var sec: Int64 = 0

  public var usec: Int32 = 0

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_SetTimeResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_SysctlRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var settings: Dictionary<String,String> = [:]

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_SysctlResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var id: String = String()

  public var vsockPort: UInt32 = 0

  public var guestPath: String = String()

  public var guestSocketPermissions: UInt32 {
    get {_guestSocketPermissions ?? 0}
    set {_guestSocketPermissions = newValue}
  }
  /// Returns true if `guestSocketPermissions` has been explicitly set.
  public var hasGuestSocketPermissions: Bool {self._guestSocketPermissions != nil}
  /// Clears the value of `guestSocketPermissions`. Subsequent reads from it will return its default value.
  public mutating func clearGuestSocketPermissions() {self._guestSocketPermissions = nil}

  public var action: Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest.Action = .into

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public nonisolated enum Action: SwiftProtobuf.Enum, Swift.CaseIterable {
    public typealias RawValue = Int
    case into // = 0
    case outOf // = 1
    case UNRECOGNIZED(Int)

    public init() {
      self = .into
    }

    public init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .into
      case 1: self = .outOf
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    public var rawValue: Int {
      switch self {
      case .into: return 0
      case .outOf: return 1
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    public static let allCases: [Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest.Action] = [
      .into,
      .outOf,
    ]

  }

  public init() {}

  fileprivate var _guestSocketPermissions: UInt32? = nil
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_ProxyVsockResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_StopVsockProxyRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var id: String = String()

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_StopVsockProxyResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_MountRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var type: String = String()

  public var source: String = String()

  public var destination: String = String()

  public var options: [String] = []

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_MountResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_UmountRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var path: String = String()

  public var flags: Int32 = 0

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_UmountResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_SetenvRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var key: String = String()

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

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}

  fileprivate var _value: String? = nil
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_SetenvResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_GetenvRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var key: String = String()

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_GetenvResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

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

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}

  fileprivate var _value: String? = nil
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var id: String = String()

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

  public var stdin: UInt32 {
    get {_stdin ?? 0}
    set {_stdin = newValue}
  }
  /// Returns true if `stdin` has been explicitly set.
  public var hasStdin: Bool {self._stdin != nil}
  /// Clears the value of `stdin`. Subsequent reads from it will return its default value.
  public mutating func clearStdin() {self._stdin = nil}

  public var stdout: UInt32 {
    get {_stdout ?? 0}
    set {_stdout = newValue}
  }
  /// Returns true if `stdout` has been explicitly set.
  public var hasStdout: Bool {self._stdout != nil}
  /// Clears the value of `stdout`. Subsequent reads from it will return its default value.
  public mutating func clearStdout() {self._stdout = nil}

  public var stderr: UInt32 {
    get {_stderr ?? 0}
    set {_stderr = newValue}
  }
  /// Returns true if `stderr` has been explicitly set.
  public var hasStderr: Bool {self._stderr != nil}
  /// Clears the value of `stderr`. Subsequent reads from it will return its default value.
  public mutating func clearStderr() {self._stderr = nil}

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

  public var configuration: Data = Data()

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

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}

  fileprivate var _containerID: String? = nil
  fileprivate var _stdin: UInt32? = nil
  fileprivate var _stdout: UInt32? = nil
  fileprivate var _stderr: UInt32? = nil
  fileprivate var _ociRuntimePath: String? = nil
  fileprivate var _options: Data? = nil
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_CreateProcessResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var id: String = String()

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

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}

  fileprivate var _containerID: String? = nil
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_WaitProcessResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var exitCode: Int32 = 0

  public var exitedAt: SwiftProtobuf.Google_Protobuf_Timestamp {
    get {_exitedAt ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
    set {_exitedAt = newValue}
  }
  /// Returns true if `exitedAt` has been explicitly set.
  public var hasExitedAt: Bool {self._exitedAt != nil}
  /// Clears the value of `exitedAt`. Subsequent reads from it will return its default value.
  public mutating func clearExitedAt() {self._exitedAt = nil}

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}

  fileprivate var _exitedAt: SwiftProtobuf.Google_Protobuf_Timestamp? = nil
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var id: String = String()

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

  public var rows: UInt32 = 0

  public var columns: UInt32 = 0

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}

  fileprivate var _containerID: String? = nil
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_ResizeProcessResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var id: String = String()

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

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}

  fileprivate var _containerID: String? = nil
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_DeleteProcessResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_StartProcessRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var id: String = String()

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

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}

  fileprivate var _containerID: String? = nil
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_StartProcessResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var pid: Int32 = 0

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_KillProcessRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var id: String = String()

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

  public var signal: Int32 = 0

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}

  fileprivate var _containerID: String? = nil
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_KillProcessResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var result: Int32 = 0

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var id: String = String()

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

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}

  fileprivate var _containerID: String? = nil
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_MkdirRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var path: String = String()

  public var all: Bool = false

  public var perms: UInt32 = 0

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_MkdirResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_WriteFileRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var path: String = String()

  public var data: Data = Data()

  public var mode: UInt32 = 0

  public var flags: Com_Apple_Containerization_Sandbox_V3_WriteFileRequest.WriteFileFlags {
    get {_flags ?? Com_Apple_Containerization_Sandbox_V3_WriteFileRequest.WriteFileFlags()}
    set {_flags = newValue}
  }
  /// Returns true if `flags` has been explicitly set.
  public var hasFlags: Bool {self._flags != nil}
  /// Clears the value of `flags`. Subsequent reads from it will return its default value.
  public mutating func clearFlags() {self._flags = nil}

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public nonisolated struct WriteFileFlags: Sendable {
    // SwiftProtobuf.Message conformance is added in an extension below. See the
    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
    // methods supported on all messages.

    public var createParentDirs: Bool = false

    public var append: Bool = false

    public var createIfMissing: Bool = false

    public var unknownFields = SwiftProtobuf.UnknownStorage()

    public init() {}
  }

  public init() {}

  fileprivate var _flags: Com_Apple_Containerization_Sandbox_V3_WriteFileRequest.WriteFileFlags? = nil
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_WriteFileResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_CopyRequest: 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.

  /// Direction of the copy operation.
  public var direction: Com_Apple_Containerization_Sandbox_V3_CopyRequest.Direction = .copyIn

  /// Path in the guest (destination for COPY_IN, source for COPY_OUT).
  public var path: String = String()

  /// File mode for single-file COPY_IN (defaults to 0644 if not set).
  public var mode: UInt32 = 0

  /// Create parent directories if they don't exist.
  public var createParents: Bool = false

  /// Vsock port the host is listening on for data transfer.
  public var vsockPort: UInt32 = 0

  /// For COPY_IN: indicates the data arriving on vsock is a tar+gzip archive.
  public var isArchive: Bool = false

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public nonisolated enum Direction: SwiftProtobuf.Enum, Swift.CaseIterable {
    public typealias RawValue = Int

    /// Copy from host into guest.
    case copyIn // = 0

    /// Copy from guest to host.
    case copyOut // = 1
    case UNRECOGNIZED(Int)

    public init() {
      self = .copyIn
    }

    public init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .copyIn
      case 1: self = .copyOut
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    public var rawValue: Int {
      switch self {
      case .copyIn: return 0
      case .copyOut: return 1
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    public static let allCases: [Com_Apple_Containerization_Sandbox_V3_CopyRequest.Direction] = [
      .copyIn,
      .copyOut,
    ]

  }

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_CopyResponse: 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.

  /// What this response represents.
  public var status: Com_Apple_Containerization_Sandbox_V3_CopyResponse.Status = .metadata

  /// For COPY_OUT METADATA: indicates the data on vsock will be a tar+gzip archive.
  public var isArchive: Bool = false

  /// For COPY_OUT METADATA: total size in bytes (0 if unknown, e.g. for archives).
  public var totalSize: UInt64 = 0

  /// Non-empty if an error occurred.
  public var error: String = String()

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public nonisolated enum Status: SwiftProtobuf.Enum, Swift.CaseIterable {
    public typealias RawValue = Int

    /// Transfer metadata (first message for COPY_OUT: is_archive, total_size).
    case metadata // = 0

    /// Data transfer completed successfully.
    case complete // = 1
    case UNRECOGNIZED(Int)

    public init() {
      self = .metadata
    }

    public init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .metadata
      case 1: self = .complete
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    public var rawValue: Int {
      switch self {
      case .metadata: return 0
      case .complete: return 1
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    public static let allCases: [Com_Apple_Containerization_Sandbox_V3_CopyResponse.Status] = [
      .metadata,
      .complete,
    ]

  }

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_StatRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var path: String = String()

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_Stat: 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.

  /// st_dev:     ID of device containing file
  public var dev: UInt64 = 0

  /// st_ino:     inode number
  public var ino: UInt64 = 0

  /// st_mode:    file type and mode (permissions)
  public var mode: UInt32 = 0

  /// st_nlink:   number of hard links
  public var nlink: UInt64 = 0

  /// st_uid:     user ID of owner
  public var uid: UInt32 = 0

  /// st_gid:     group ID of owner
  public var gid: UInt32 = 0

  /// st_rdev:    device ID (if special file)
  public var rdev: UInt64 = 0

  /// st_size:    total size in bytes
  public var size: Int64 = 0

  /// st_blksize: preferred block size for filesystem I/O
  public var blksize: Int64 = 0

  /// st_blocks:  number of 512-byte blocks allocated
  public var blocks: Int64 = 0

  /// st_atim: time of last access
  public var atime: SwiftProtobuf.Google_Protobuf_Timestamp {
    get {_atime ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
    set {_atime = newValue}
  }
  /// Returns true if `atime` has been explicitly set.
  public var hasAtime: Bool {self._atime != nil}
  /// Clears the value of `atime`. Subsequent reads from it will return its default value.
  public mutating func clearAtime() {self._atime = nil}

  /// st_mtim: time of last modification
  public var mtime: SwiftProtobuf.Google_Protobuf_Timestamp {
    get {_mtime ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
    set {_mtime = newValue}
  }
  /// Returns true if `mtime` has been explicitly set.
  public var hasMtime: Bool {self._mtime != nil}
  /// Clears the value of `mtime`. Subsequent reads from it will return its default value.
  public mutating func clearMtime() {self._mtime = nil}

  /// st_ctim: time of last status change
  public var ctime: SwiftProtobuf.Google_Protobuf_Timestamp {
    get {_ctime ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
    set {_ctime = newValue}
  }
  /// Returns true if `ctime` has been explicitly set.
  public var hasCtime: Bool {self._ctime != nil}
  /// Clears the value of `ctime`. Subsequent reads from it will return its default value.
  public mutating func clearCtime() {self._ctime = nil}

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}

  fileprivate var _atime: SwiftProtobuf.Google_Protobuf_Timestamp? = nil
  fileprivate var _mtime: SwiftProtobuf.Google_Protobuf_Timestamp? = nil
  fileprivate var _ctime: SwiftProtobuf.Google_Protobuf_Timestamp? = nil
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_StatResponse: @unchecked Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var stat: Com_Apple_Containerization_Sandbox_V3_Stat {
    get {_storage._stat ?? Com_Apple_Containerization_Sandbox_V3_Stat()}
    set {_uniqueStorage()._stat = newValue}
  }
  /// Returns true if `stat` has been explicitly set.
  public var hasStat: Bool {_storage._stat != nil}
  /// Clears the value of `stat`. Subsequent reads from it will return its default value.
  public mutating func clearStat() {_uniqueStorage()._stat = nil}

  /// Non-empty if stat failed.
  public var error: String {
    get {_storage._error}
    set {_uniqueStorage()._error = newValue}
  }

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}

  fileprivate var _storage = _StorageClass.defaultInstance
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_FiTrimParams: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var schedule: Com_Apple_Containerization_Sandbox_V3_FiTrimParams.OneOf_Schedule? = nil

  public var oneShot: Com_Apple_Containerization_Sandbox_V3_FiTrimParams.OneShot {
    get {
      if case .oneShot(let v)? = schedule {return v}
      return Com_Apple_Containerization_Sandbox_V3_FiTrimParams.OneShot()
    }
    set {schedule = .oneShot(newValue)}
  }

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public nonisolated enum OneOf_Schedule: Equatable, Sendable {
    case oneShot(Com_Apple_Containerization_Sandbox_V3_FiTrimParams.OneShot)

  }

  public nonisolated struct OneShot: Sendable {
    // SwiftProtobuf.Message conformance is added in an extension below. See the
    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
    // methods supported on all messages.

    public var unknownFields = SwiftProtobuf.UnknownStorage()

    public init() {}
  }

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_FiFreezeParams: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_FiThawParams: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_FiTrimResult: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var trimmedBytes: UInt64 = 0

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var path: String = String()

  public var operation: Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest.OneOf_Operation? = nil

  public var trim: Com_Apple_Containerization_Sandbox_V3_FiTrimParams {
    get {
      if case .trim(let v)? = operation {return v}
      return Com_Apple_Containerization_Sandbox_V3_FiTrimParams()
    }
    set {operation = .trim(newValue)}
  }

  public var freeze: Com_Apple_Containerization_Sandbox_V3_FiFreezeParams {
    get {
      if case .freeze(let v)? = operation {return v}
      return Com_Apple_Containerization_Sandbox_V3_FiFreezeParams()
    }
    set {operation = .freeze(newValue)}
  }

  public var thaw: Com_Apple_Containerization_Sandbox_V3_FiThawParams {
    get {
      if case .thaw(let v)? = operation {return v}
      return Com_Apple_Containerization_Sandbox_V3_FiThawParams()
    }
    set {operation = .thaw(newValue)}
  }

  /// Resolve path from this container's init process mount namespace.
  public var containerID: String {
    get {_containerID ?? String()}
    set {_containerID = newValue}
  }
  /// Returns true if `containerID` has been explicitly set.
  public var hasContainerID: Bool {self._containerID != nil}
  /// Clears the value of `containerID`. Subsequent reads from it will return its default value.
  public mutating func clearContainerID() {self._containerID = nil}

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public nonisolated enum OneOf_Operation: Equatable, Sendable {
    case trim(Com_Apple_Containerization_Sandbox_V3_FiTrimParams)
    case freeze(Com_Apple_Containerization_Sandbox_V3_FiFreezeParams)
    case thaw(Com_Apple_Containerization_Sandbox_V3_FiThawParams)

  }

  public init() {}

  fileprivate var _containerID: String? = nil
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_FilesystemOperationResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var result: Com_Apple_Containerization_Sandbox_V3_FilesystemOperationResponse.OneOf_Result? = nil

  public var trim: Com_Apple_Containerization_Sandbox_V3_FiTrimResult {
    get {
      if case .trim(let v)? = result {return v}
      return Com_Apple_Containerization_Sandbox_V3_FiTrimResult()
    }
    set {result = .trim(newValue)}
  }

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public nonisolated enum OneOf_Result: Equatable, Sendable {
    case trim(Com_Apple_Containerization_Sandbox_V3_FiTrimResult)

  }

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var interface: String = String()

  public var up: Bool = false

  public var mtu: UInt32 {
    get {_mtu ?? 0}
    set {_mtu = newValue}
  }
  /// Returns true if `mtu` has been explicitly set.
  public var hasMtu: Bool {self._mtu != nil}
  /// Clears the value of `mtu`. Subsequent reads from it will return its default value.
  public mutating func clearMtu() {self._mtu = nil}

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}

  fileprivate var _mtu: UInt32? = nil
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_IpLinkSetResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var interface: String = String()

  public var ipv4Address: String = String()

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

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}

  fileprivate var _ipv6Address: String? = nil
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_IpAddrAddResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var interface: String = String()

  public var dstIpv4Addr: String = String()

  public var srcIpv4Addr: String = String()

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

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

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}

  fileprivate var _dstIpv6Addr: String? = nil
  fileprivate var _srcIpv6Addr: String? = nil
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var interface: String = String()

  public var ipv4Gateway: String = String()

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

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}

  fileprivate var _ipv6Gateway: String? = nil
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var location: String = String()

  public var nameservers: [String] = []

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

  public var searchDomains: [String] = []

  public var options: [String] = []

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}

  fileprivate var _domain: String? = nil
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_ConfigureDnsResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var location: String = String()

  public var entries: [Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest.HostsEntry] = []

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

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public nonisolated struct HostsEntry: Sendable {
    // SwiftProtobuf.Message conformance is added in an extension below. See the
    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
    // methods supported on all messages.

    public var ipAddress: String = String()

    public var hostnames: [String] = []

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

    public var unknownFields = SwiftProtobuf.UnknownStorage()

    public init() {}

    fileprivate var _comment: String? = nil
  }

  public init() {}

  fileprivate var _comment: String? = nil
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_ConfigureHostsResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_SyncRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_SyncResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_KillRequest: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var pid: Int32 = 0

  public var signal: Int32 = 0

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_KillResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var result: Int32 = 0

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest: 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.

  /// Empty = all containers
  public var containerIds: [String] = []

  /// Empty = all categories
  public var categories: [Com_Apple_Containerization_Sandbox_V3_StatCategory] = []

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsResponse: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var containers: [Com_Apple_Containerization_Sandbox_V3_ContainerStats] = []

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_ContainerStats: @unchecked Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var containerID: String {
    get {_storage._containerID}
    set {_uniqueStorage()._containerID = newValue}
  }

  public var process: Com_Apple_Containerization_Sandbox_V3_ProcessStats {
    get {_storage._process ?? Com_Apple_Containerization_Sandbox_V3_ProcessStats()}
    set {_uniqueStorage()._process = newValue}
  }
  /// Returns true if `process` has been explicitly set.
  public var hasProcess: Bool {_storage._process != nil}
  /// Clears the value of `process`. Subsequent reads from it will return its default value.
  public mutating func clearProcess() {_uniqueStorage()._process = nil}

  public var memory: Com_Apple_Containerization_Sandbox_V3_MemoryStats {
    get {_storage._memory ?? Com_Apple_Containerization_Sandbox_V3_MemoryStats()}
    set {_uniqueStorage()._memory = newValue}
  }
  /// Returns true if `memory` has been explicitly set.
  public var hasMemory: Bool {_storage._memory != nil}
  /// Clears the value of `memory`. Subsequent reads from it will return its default value.
  public mutating func clearMemory() {_uniqueStorage()._memory = nil}

  public var cpu: Com_Apple_Containerization_Sandbox_V3_CPUStats {
    get {_storage._cpu ?? Com_Apple_Containerization_Sandbox_V3_CPUStats()}
    set {_uniqueStorage()._cpu = newValue}
  }
  /// Returns true if `cpu` has been explicitly set.
  public var hasCpu: Bool {_storage._cpu != nil}
  /// Clears the value of `cpu`. Subsequent reads from it will return its default value.
  public mutating func clearCpu() {_uniqueStorage()._cpu = nil}

  public var blockIo: Com_Apple_Containerization_Sandbox_V3_BlockIOStats {
    get {_storage._blockIo ?? Com_Apple_Containerization_Sandbox_V3_BlockIOStats()}
    set {_uniqueStorage()._blockIo = newValue}
  }
  /// Returns true if `blockIo` has been explicitly set.
  public var hasBlockIo: Bool {_storage._blockIo != nil}
  /// Clears the value of `blockIo`. Subsequent reads from it will return its default value.
  public mutating func clearBlockIo() {_uniqueStorage()._blockIo = nil}

  public var networks: [Com_Apple_Containerization_Sandbox_V3_NetworkStats] {
    get {_storage._networks}
    set {_uniqueStorage()._networks = newValue}
  }

  public var memoryEvents: Com_Apple_Containerization_Sandbox_V3_MemoryEventStats {
    get {_storage._memoryEvents ?? Com_Apple_Containerization_Sandbox_V3_MemoryEventStats()}
    set {_uniqueStorage()._memoryEvents = newValue}
  }
  /// Returns true if `memoryEvents` has been explicitly set.
  public var hasMemoryEvents: Bool {_storage._memoryEvents != nil}
  /// Clears the value of `memoryEvents`. Subsequent reads from it will return its default value.
  public mutating func clearMemoryEvents() {_uniqueStorage()._memoryEvents = nil}

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}

  fileprivate var _storage = _StorageClass.defaultInstance
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_ProcessStats: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var current: UInt64 = 0

  /// 0 or max value = unlimited
  public var limit: UInt64 = 0

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_MemoryStats: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var usageBytes: UInt64 = 0

  public var limitBytes: UInt64 = 0

  public var swapUsageBytes: UInt64 = 0

  public var swapLimitBytes: UInt64 = 0

  public var cacheBytes: UInt64 = 0

  public var kernelStackBytes: UInt64 = 0

  public var slabBytes: UInt64 = 0

  public var pageFaults: UInt64 = 0

  public var majorPageFaults: UInt64 = 0

  public var inactiveFile: UInt64 = 0

  public var anon: UInt64 = 0

  public var workingsetRefaultAnon: UInt64 = 0

  public var workingsetRefaultFile: UInt64 = 0

  public var pgstealKswapd: UInt64 = 0

  public var pgstealDirect: UInt64 = 0

  public var pgstealKhugepaged: UInt64 = 0

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_CPUStats: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var usageUsec: UInt64 = 0

  public var userUsec: UInt64 = 0

  public var systemUsec: UInt64 = 0

  public var throttlingPeriods: UInt64 = 0

  public var throttledPeriods: UInt64 = 0

  public var throttledTimeUsec: UInt64 = 0

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_BlockIOStats: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var devices: [Com_Apple_Containerization_Sandbox_V3_BlockIOEntry] = []

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_BlockIOEntry: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var major: UInt64 = 0

  public var minor: UInt64 = 0

  public var readBytes: UInt64 = 0

  public var writeBytes: UInt64 = 0

  public var readOperations: UInt64 = 0

  public var writeOperations: UInt64 = 0

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

public nonisolated struct Com_Apple_Containerization_Sandbox_V3_NetworkStats: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  public var interface: String = String()

  public var receivedPackets: UInt64 = 0

  public var transmittedPackets: UInt64 = 0

  public var receivedBytes: UInt64 = 0

  public var transmittedBytes: UInt64 = 0

  public var receivedErrors: UInt64 = 0

  public var transmittedErrors: UInt64 = 0

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

/// Memory event counters from cgroup2's memory.events file.
public nonisolated struct Com_Apple_Containerization_Sandbox_V3_MemoryEventStats: 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.

  /// Number of times the cgroup was reclaimed due to low memory.
  public var low: UInt64 = 0

  /// Number of times the cgroup exceeded its high memory limit.
  public var high: UInt64 = 0

  /// Number of times the cgroup hit its max memory limit.
  public var max: UInt64 = 0

  /// Number of times the cgroup triggered OOM.
  public var oom: UInt64 = 0

  /// Number of processes killed by OOM killer.
  public var oomKill: UInt64 = 0

  /// Number of times charge for memory failed because of limit.
  public var oomGroupKill: UInt64 = 0

  public var unknownFields = SwiftProtobuf.UnknownStorage()

  public init() {}
}

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

fileprivate nonisolated let _protobuf_package = "com.apple.containerization.sandbox.v3"

nonisolated extension Com_Apple_Containerization_Sandbox_V3_StatCategory: SwiftProtobuf._ProtoNameProviding {
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0STAT_CATEGORY_UNSPECIFIED\0\u{1}STAT_CATEGORY_PROCESS\0\u{1}STAT_CATEGORY_MEMORY\0\u{1}STAT_CATEGORY_CPU\0\u{1}STAT_CATEGORY_BLOCK_IO\0\u{1}STAT_CATEGORY_NETWORK\0\u{1}STAT_CATEGORY_MEMORY_EVENTS\0")
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_Stdio: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".Stdio"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}stdinPort\0\u{1}stdoutPort\0\u{1}stderrPort\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularInt32Field(value: &self._stdinPort) }()
      case 2: try { try decoder.decodeSingularInt32Field(value: &self._stdoutPort) }()
      case 3: try { try decoder.decodeSingularInt32Field(value: &self._stderrPort) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every if/case branch local when no optimizations
    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
    // https://github.com/apple/swift-protobuf/issues/1182
    try { if let v = self._stdinPort {
      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
    } }()
    try { if let v = self._stdoutPort {
      try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
    } }()
    try { if let v = self._stderrPort {
      try visitor.visitSingularInt32Field(value: v, fieldNumber: 3)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_Stdio, rhs: Com_Apple_Containerization_Sandbox_V3_Stdio) -> Bool {
    if lhs._stdinPort != rhs._stdinPort {return false}
    if lhs._stdoutPort != rhs._stdoutPort {return false}
    if lhs._stderrPort != rhs._stderrPort {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".SetupEmulatorRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}binary_path\0\u{1}name\0\u{1}type\0\u{1}offset\0\u{1}magic\0\u{1}mask\0\u{1}flags\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.binaryPath) }()
      case 2: try { try decoder.decodeSingularStringField(value: &self.name) }()
      case 3: try { try decoder.decodeSingularStringField(value: &self.type) }()
      case 4: try { try decoder.decodeSingularStringField(value: &self.offset) }()
      case 5: try { try decoder.decodeSingularStringField(value: &self.magic) }()
      case 6: try { try decoder.decodeSingularStringField(value: &self.mask) }()
      case 7: try { try decoder.decodeSingularStringField(value: &self.flags) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.binaryPath.isEmpty {
      try visitor.visitSingularStringField(value: self.binaryPath, fieldNumber: 1)
    }
    if !self.name.isEmpty {
      try visitor.visitSingularStringField(value: self.name, fieldNumber: 2)
    }
    if !self.type.isEmpty {
      try visitor.visitSingularStringField(value: self.type, fieldNumber: 3)
    }
    if !self.offset.isEmpty {
      try visitor.visitSingularStringField(value: self.offset, fieldNumber: 4)
    }
    if !self.magic.isEmpty {
      try visitor.visitSingularStringField(value: self.magic, fieldNumber: 5)
    }
    if !self.mask.isEmpty {
      try visitor.visitSingularStringField(value: self.mask, fieldNumber: 6)
    }
    if !self.flags.isEmpty {
      try visitor.visitSingularStringField(value: self.flags, fieldNumber: 7)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest, rhs: Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest) -> Bool {
    if lhs.binaryPath != rhs.binaryPath {return false}
    if lhs.name != rhs.name {return false}
    if lhs.type != rhs.type {return false}
    if lhs.offset != rhs.offset {return false}
    if lhs.magic != rhs.magic {return false}
    if lhs.mask != rhs.mask {return false}
    if lhs.flags != rhs.flags {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_SetupEmulatorResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".SetupEmulatorResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_SetTimeRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".SetTimeRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}sec\0\u{1}usec\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularInt64Field(value: &self.sec) }()
      case 2: try { try decoder.decodeSingularInt32Field(value: &self.usec) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.sec != 0 {
      try visitor.visitSingularInt64Field(value: self.sec, fieldNumber: 1)
    }
    if self.usec != 0 {
      try visitor.visitSingularInt32Field(value: self.usec, fieldNumber: 2)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_SetTimeRequest, rhs: Com_Apple_Containerization_Sandbox_V3_SetTimeRequest) -> Bool {
    if lhs.sec != rhs.sec {return false}
    if lhs.usec != rhs.usec {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_SetTimeResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".SetTimeResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_SysctlRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".SysctlRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}settings\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, value: &self.settings) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.settings.isEmpty {
      try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap<SwiftProtobuf.ProtobufString,SwiftProtobuf.ProtobufString>.self, value: self.settings, fieldNumber: 1)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_SysctlResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".SysctlResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".ProxyVsockRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}id\0\u{3}vsock_port\0\u{1}guestPath\0\u{1}guestSocketPermissions\0\u{1}action\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.id) }()
      case 2: try { try decoder.decodeSingularUInt32Field(value: &self.vsockPort) }()
      case 3: try { try decoder.decodeSingularStringField(value: &self.guestPath) }()
      case 4: try { try decoder.decodeSingularUInt32Field(value: &self._guestSocketPermissions) }()
      case 5: try { try decoder.decodeSingularEnumField(value: &self.action) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every if/case branch local when no optimizations
    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
    // https://github.com/apple/swift-protobuf/issues/1182
    if !self.id.isEmpty {
      try visitor.visitSingularStringField(value: self.id, fieldNumber: 1)
    }
    if self.vsockPort != 0 {
      try visitor.visitSingularUInt32Field(value: self.vsockPort, fieldNumber: 2)
    }
    if !self.guestPath.isEmpty {
      try visitor.visitSingularStringField(value: self.guestPath, fieldNumber: 3)
    }
    try { if let v = self._guestSocketPermissions {
      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 4)
    } }()
    if self.action != .into {
      try visitor.visitSingularEnumField(value: self.action, fieldNumber: 5)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest, rhs: Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest) -> Bool {
    if lhs.id != rhs.id {return false}
    if lhs.vsockPort != rhs.vsockPort {return false}
    if lhs.guestPath != rhs.guestPath {return false}
    if lhs._guestSocketPermissions != rhs._guestSocketPermissions {return false}
    if lhs.action != rhs.action {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest.Action: SwiftProtobuf._ProtoNameProviding {
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0INTO\0\u{1}OUT_OF\0")
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_ProxyVsockResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".ProxyVsockResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_StopVsockProxyRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".StopVsockProxyRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}id\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.id) }()
      default: break
      }
    }
  }

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

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_StopVsockProxyResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".StopVsockProxyResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_MountRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".MountRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}type\0\u{1}source\0\u{1}destination\0\u{1}options\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.type) }()
      case 2: try { try decoder.decodeSingularStringField(value: &self.source) }()
      case 3: try { try decoder.decodeSingularStringField(value: &self.destination) }()
      case 4: try { try decoder.decodeRepeatedStringField(value: &self.options) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.type.isEmpty {
      try visitor.visitSingularStringField(value: self.type, fieldNumber: 1)
    }
    if !self.source.isEmpty {
      try visitor.visitSingularStringField(value: self.source, fieldNumber: 2)
    }
    if !self.destination.isEmpty {
      try visitor.visitSingularStringField(value: self.destination, fieldNumber: 3)
    }
    if !self.options.isEmpty {
      try visitor.visitRepeatedStringField(value: self.options, fieldNumber: 4)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_MountRequest, rhs: Com_Apple_Containerization_Sandbox_V3_MountRequest) -> Bool {
    if lhs.type != rhs.type {return false}
    if lhs.source != rhs.source {return false}
    if lhs.destination != rhs.destination {return false}
    if lhs.options != rhs.options {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_MountResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".MountResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_UmountRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".UmountRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}path\0\u{1}flags\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.path) }()
      case 2: try { try decoder.decodeSingularInt32Field(value: &self.flags) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.path.isEmpty {
      try visitor.visitSingularStringField(value: self.path, fieldNumber: 1)
    }
    if self.flags != 0 {
      try visitor.visitSingularInt32Field(value: self.flags, fieldNumber: 2)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_UmountRequest, rhs: Com_Apple_Containerization_Sandbox_V3_UmountRequest) -> Bool {
    if lhs.path != rhs.path {return false}
    if lhs.flags != rhs.flags {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_UmountResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".UmountResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_SetenvRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".SetenvRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}key\0\u{1}value\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.key) }()
      case 2: try { try decoder.decodeSingularStringField(value: &self._value) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every if/case branch local when no optimizations
    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
    // https://github.com/apple/swift-protobuf/issues/1182
    if !self.key.isEmpty {
      try visitor.visitSingularStringField(value: self.key, fieldNumber: 1)
    }
    try { if let v = self._value {
      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_SetenvRequest, rhs: Com_Apple_Containerization_Sandbox_V3_SetenvRequest) -> Bool {
    if lhs.key != rhs.key {return false}
    if lhs._value != rhs._value {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_SetenvResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".SetenvResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_GetenvRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".GetenvRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}key\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.key) }()
      default: break
      }
    }
  }

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

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_GetenvResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".GetenvResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}value\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self._value) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every if/case branch local when no optimizations
    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
    // https://github.com/apple/swift-protobuf/issues/1182
    try { if let v = self._value {
      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".CreateProcessRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}id\0\u{1}containerID\0\u{1}stdin\0\u{1}stdout\0\u{1}stderr\0\u{1}ociRuntimePath\0\u{1}configuration\0\u{1}options\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.id) }()
      case 2: try { try decoder.decodeSingularStringField(value: &self._containerID) }()
      case 3: try { try decoder.decodeSingularUInt32Field(value: &self._stdin) }()
      case 4: try { try decoder.decodeSingularUInt32Field(value: &self._stdout) }()
      case 5: try { try decoder.decodeSingularUInt32Field(value: &self._stderr) }()
      case 6: try { try decoder.decodeSingularStringField(value: &self._ociRuntimePath) }()
      case 7: try { try decoder.decodeSingularBytesField(value: &self.configuration) }()
      case 8: try { try decoder.decodeSingularBytesField(value: &self._options) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every if/case branch local when no optimizations
    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
    // https://github.com/apple/swift-protobuf/issues/1182
    if !self.id.isEmpty {
      try visitor.visitSingularStringField(value: self.id, fieldNumber: 1)
    }
    try { if let v = self._containerID {
      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
    } }()
    try { if let v = self._stdin {
      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3)
    } }()
    try { if let v = self._stdout {
      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 4)
    } }()
    try { if let v = self._stderr {
      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 5)
    } }()
    try { if let v = self._ociRuntimePath {
      try visitor.visitSingularStringField(value: v, fieldNumber: 6)
    } }()
    if !self.configuration.isEmpty {
      try visitor.visitSingularBytesField(value: self.configuration, fieldNumber: 7)
    }
    try { if let v = self._options {
      try visitor.visitSingularBytesField(value: v, fieldNumber: 8)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest, rhs: Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest) -> Bool {
    if lhs.id != rhs.id {return false}
    if lhs._containerID != rhs._containerID {return false}
    if lhs._stdin != rhs._stdin {return false}
    if lhs._stdout != rhs._stdout {return false}
    if lhs._stderr != rhs._stderr {return false}
    if lhs._ociRuntimePath != rhs._ociRuntimePath {return false}
    if lhs.configuration != rhs.configuration {return false}
    if lhs._options != rhs._options {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_CreateProcessResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".CreateProcessResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".WaitProcessRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}id\0\u{1}containerID\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.id) }()
      case 2: try { try decoder.decodeSingularStringField(value: &self._containerID) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every if/case branch local when no optimizations
    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
    // https://github.com/apple/swift-protobuf/issues/1182
    if !self.id.isEmpty {
      try visitor.visitSingularStringField(value: self.id, fieldNumber: 1)
    }
    try { if let v = self._containerID {
      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest, rhs: Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest) -> Bool {
    if lhs.id != rhs.id {return false}
    if lhs._containerID != rhs._containerID {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_WaitProcessResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".WaitProcessResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}exitCode\0\u{3}exited_at\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularInt32Field(value: &self.exitCode) }()
      case 2: try { try decoder.decodeSingularMessageField(value: &self._exitedAt) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every if/case branch local when no optimizations
    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
    // https://github.com/apple/swift-protobuf/issues/1182
    if self.exitCode != 0 {
      try visitor.visitSingularInt32Field(value: self.exitCode, fieldNumber: 1)
    }
    try { if let v = self._exitedAt {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_WaitProcessResponse, rhs: Com_Apple_Containerization_Sandbox_V3_WaitProcessResponse) -> Bool {
    if lhs.exitCode != rhs.exitCode {return false}
    if lhs._exitedAt != rhs._exitedAt {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".ResizeProcessRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}id\0\u{1}containerID\0\u{1}rows\0\u{1}columns\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.id) }()
      case 2: try { try decoder.decodeSingularStringField(value: &self._containerID) }()
      case 3: try { try decoder.decodeSingularUInt32Field(value: &self.rows) }()
      case 4: try { try decoder.decodeSingularUInt32Field(value: &self.columns) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every if/case branch local when no optimizations
    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
    // https://github.com/apple/swift-protobuf/issues/1182
    if !self.id.isEmpty {
      try visitor.visitSingularStringField(value: self.id, fieldNumber: 1)
    }
    try { if let v = self._containerID {
      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
    } }()
    if self.rows != 0 {
      try visitor.visitSingularUInt32Field(value: self.rows, fieldNumber: 3)
    }
    if self.columns != 0 {
      try visitor.visitSingularUInt32Field(value: self.columns, fieldNumber: 4)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest, rhs: Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest) -> Bool {
    if lhs.id != rhs.id {return false}
    if lhs._containerID != rhs._containerID {return false}
    if lhs.rows != rhs.rows {return false}
    if lhs.columns != rhs.columns {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_ResizeProcessResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".ResizeProcessResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".DeleteProcessRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}id\0\u{1}containerID\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.id) }()
      case 2: try { try decoder.decodeSingularStringField(value: &self._containerID) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every if/case branch local when no optimizations
    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
    // https://github.com/apple/swift-protobuf/issues/1182
    if !self.id.isEmpty {
      try visitor.visitSingularStringField(value: self.id, fieldNumber: 1)
    }
    try { if let v = self._containerID {
      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest, rhs: Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest) -> Bool {
    if lhs.id != rhs.id {return false}
    if lhs._containerID != rhs._containerID {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_DeleteProcessResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".DeleteProcessResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_StartProcessRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".StartProcessRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}id\0\u{1}containerID\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.id) }()
      case 2: try { try decoder.decodeSingularStringField(value: &self._containerID) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every if/case branch local when no optimizations
    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
    // https://github.com/apple/swift-protobuf/issues/1182
    if !self.id.isEmpty {
      try visitor.visitSingularStringField(value: self.id, fieldNumber: 1)
    }
    try { if let v = self._containerID {
      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_StartProcessRequest, rhs: Com_Apple_Containerization_Sandbox_V3_StartProcessRequest) -> Bool {
    if lhs.id != rhs.id {return false}
    if lhs._containerID != rhs._containerID {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_StartProcessResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".StartProcessResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}pid\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularInt32Field(value: &self.pid) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.pid != 0 {
      try visitor.visitSingularInt32Field(value: self.pid, fieldNumber: 1)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_KillProcessRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".KillProcessRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}id\0\u{1}containerID\0\u{1}signal\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.id) }()
      case 2: try { try decoder.decodeSingularStringField(value: &self._containerID) }()
      case 3: try { try decoder.decodeSingularInt32Field(value: &self.signal) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every if/case branch local when no optimizations
    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
    // https://github.com/apple/swift-protobuf/issues/1182
    if !self.id.isEmpty {
      try visitor.visitSingularStringField(value: self.id, fieldNumber: 1)
    }
    try { if let v = self._containerID {
      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
    } }()
    if self.signal != 0 {
      try visitor.visitSingularInt32Field(value: self.signal, fieldNumber: 3)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_KillProcessRequest, rhs: Com_Apple_Containerization_Sandbox_V3_KillProcessRequest) -> Bool {
    if lhs.id != rhs.id {return false}
    if lhs._containerID != rhs._containerID {return false}
    if lhs.signal != rhs.signal {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_KillProcessResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".KillProcessResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}result\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularInt32Field(value: &self.result) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.result != 0 {
      try visitor.visitSingularInt32Field(value: self.result, fieldNumber: 1)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".CloseProcessStdinRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}id\0\u{1}containerID\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.id) }()
      case 2: try { try decoder.decodeSingularStringField(value: &self._containerID) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every if/case branch local when no optimizations
    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
    // https://github.com/apple/swift-protobuf/issues/1182
    if !self.id.isEmpty {
      try visitor.visitSingularStringField(value: self.id, fieldNumber: 1)
    }
    try { if let v = self._containerID {
      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest, rhs: Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest) -> Bool {
    if lhs.id != rhs.id {return false}
    if lhs._containerID != rhs._containerID {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".CloseProcessStdinResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_MkdirRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".MkdirRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}path\0\u{1}all\0\u{1}perms\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.path) }()
      case 2: try { try decoder.decodeSingularBoolField(value: &self.all) }()
      case 3: try { try decoder.decodeSingularUInt32Field(value: &self.perms) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.path.isEmpty {
      try visitor.visitSingularStringField(value: self.path, fieldNumber: 1)
    }
    if self.all != false {
      try visitor.visitSingularBoolField(value: self.all, fieldNumber: 2)
    }
    if self.perms != 0 {
      try visitor.visitSingularUInt32Field(value: self.perms, fieldNumber: 3)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_MkdirRequest, rhs: Com_Apple_Containerization_Sandbox_V3_MkdirRequest) -> Bool {
    if lhs.path != rhs.path {return false}
    if lhs.all != rhs.all {return false}
    if lhs.perms != rhs.perms {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_MkdirResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".MkdirResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_WriteFileRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".WriteFileRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}path\0\u{1}data\0\u{1}mode\0\u{1}flags\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.path) }()
      case 2: try { try decoder.decodeSingularBytesField(value: &self.data) }()
      case 3: try { try decoder.decodeSingularUInt32Field(value: &self.mode) }()
      case 4: try { try decoder.decodeSingularMessageField(value: &self._flags) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every if/case branch local when no optimizations
    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
    // https://github.com/apple/swift-protobuf/issues/1182
    if !self.path.isEmpty {
      try visitor.visitSingularStringField(value: self.path, fieldNumber: 1)
    }
    if !self.data.isEmpty {
      try visitor.visitSingularBytesField(value: self.data, fieldNumber: 2)
    }
    if self.mode != 0 {
      try visitor.visitSingularUInt32Field(value: self.mode, fieldNumber: 3)
    }
    try { if let v = self._flags {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_WriteFileRequest, rhs: Com_Apple_Containerization_Sandbox_V3_WriteFileRequest) -> Bool {
    if lhs.path != rhs.path {return false}
    if lhs.data != rhs.data {return false}
    if lhs.mode != rhs.mode {return false}
    if lhs._flags != rhs._flags {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_WriteFileRequest.WriteFileFlags: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = Com_Apple_Containerization_Sandbox_V3_WriteFileRequest.protoMessageName + ".WriteFileFlags"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}create_parent_dirs\0\u{1}append\0\u{3}create_if_missing\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularBoolField(value: &self.createParentDirs) }()
      case 2: try { try decoder.decodeSingularBoolField(value: &self.append) }()
      case 3: try { try decoder.decodeSingularBoolField(value: &self.createIfMissing) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.createParentDirs != false {
      try visitor.visitSingularBoolField(value: self.createParentDirs, fieldNumber: 1)
    }
    if self.append != false {
      try visitor.visitSingularBoolField(value: self.append, fieldNumber: 2)
    }
    if self.createIfMissing != false {
      try visitor.visitSingularBoolField(value: self.createIfMissing, fieldNumber: 3)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_WriteFileRequest.WriteFileFlags, rhs: Com_Apple_Containerization_Sandbox_V3_WriteFileRequest.WriteFileFlags) -> Bool {
    if lhs.createParentDirs != rhs.createParentDirs {return false}
    if lhs.append != rhs.append {return false}
    if lhs.createIfMissing != rhs.createIfMissing {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_WriteFileResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".WriteFileResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_CopyRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".CopyRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}direction\0\u{1}path\0\u{1}mode\0\u{3}create_parents\0\u{3}vsock_port\0\u{3}is_archive\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularEnumField(value: &self.direction) }()
      case 2: try { try decoder.decodeSingularStringField(value: &self.path) }()
      case 3: try { try decoder.decodeSingularUInt32Field(value: &self.mode) }()
      case 4: try { try decoder.decodeSingularBoolField(value: &self.createParents) }()
      case 5: try { try decoder.decodeSingularUInt32Field(value: &self.vsockPort) }()
      case 6: try { try decoder.decodeSingularBoolField(value: &self.isArchive) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.direction != .copyIn {
      try visitor.visitSingularEnumField(value: self.direction, fieldNumber: 1)
    }
    if !self.path.isEmpty {
      try visitor.visitSingularStringField(value: self.path, fieldNumber: 2)
    }
    if self.mode != 0 {
      try visitor.visitSingularUInt32Field(value: self.mode, fieldNumber: 3)
    }
    if self.createParents != false {
      try visitor.visitSingularBoolField(value: self.createParents, fieldNumber: 4)
    }
    if self.vsockPort != 0 {
      try visitor.visitSingularUInt32Field(value: self.vsockPort, fieldNumber: 5)
    }
    if self.isArchive != false {
      try visitor.visitSingularBoolField(value: self.isArchive, fieldNumber: 6)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_CopyRequest, rhs: Com_Apple_Containerization_Sandbox_V3_CopyRequest) -> Bool {
    if lhs.direction != rhs.direction {return false}
    if lhs.path != rhs.path {return false}
    if lhs.mode != rhs.mode {return false}
    if lhs.createParents != rhs.createParents {return false}
    if lhs.vsockPort != rhs.vsockPort {return false}
    if lhs.isArchive != rhs.isArchive {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_CopyRequest.Direction: SwiftProtobuf._ProtoNameProviding {
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0COPY_IN\0\u{1}COPY_OUT\0")
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_CopyResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".CopyResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}status\0\u{3}is_archive\0\u{3}total_size\0\u{1}error\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularEnumField(value: &self.status) }()
      case 2: try { try decoder.decodeSingularBoolField(value: &self.isArchive) }()
      case 3: try { try decoder.decodeSingularUInt64Field(value: &self.totalSize) }()
      case 4: try { try decoder.decodeSingularStringField(value: &self.error) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.status != .metadata {
      try visitor.visitSingularEnumField(value: self.status, fieldNumber: 1)
    }
    if self.isArchive != false {
      try visitor.visitSingularBoolField(value: self.isArchive, fieldNumber: 2)
    }
    if self.totalSize != 0 {
      try visitor.visitSingularUInt64Field(value: self.totalSize, fieldNumber: 3)
    }
    if !self.error.isEmpty {
      try visitor.visitSingularStringField(value: self.error, fieldNumber: 4)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_CopyResponse, rhs: Com_Apple_Containerization_Sandbox_V3_CopyResponse) -> Bool {
    if lhs.status != rhs.status {return false}
    if lhs.isArchive != rhs.isArchive {return false}
    if lhs.totalSize != rhs.totalSize {return false}
    if lhs.error != rhs.error {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_CopyResponse.Status: SwiftProtobuf._ProtoNameProviding {
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0METADATA\0\u{1}COMPLETE\0")
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_StatRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".StatRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}path\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.path) }()
      default: break
      }
    }
  }

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

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_Stat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".Stat"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}dev\0\u{1}ino\0\u{1}mode\0\u{1}nlink\0\u{1}uid\0\u{1}gid\0\u{1}rdev\0\u{1}size\0\u{1}blksize\0\u{1}blocks\0\u{1}atime\0\u{1}mtime\0\u{1}ctime\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularUInt64Field(value: &self.dev) }()
      case 2: try { try decoder.decodeSingularUInt64Field(value: &self.ino) }()
      case 3: try { try decoder.decodeSingularUInt32Field(value: &self.mode) }()
      case 4: try { try decoder.decodeSingularUInt64Field(value: &self.nlink) }()
      case 5: try { try decoder.decodeSingularUInt32Field(value: &self.uid) }()
      case 6: try { try decoder.decodeSingularUInt32Field(value: &self.gid) }()
      case 7: try { try decoder.decodeSingularUInt64Field(value: &self.rdev) }()
      case 8: try { try decoder.decodeSingularInt64Field(value: &self.size) }()
      case 9: try { try decoder.decodeSingularInt64Field(value: &self.blksize) }()
      case 10: try { try decoder.decodeSingularInt64Field(value: &self.blocks) }()
      case 11: try { try decoder.decodeSingularMessageField(value: &self._atime) }()
      case 12: try { try decoder.decodeSingularMessageField(value: &self._mtime) }()
      case 13: try { try decoder.decodeSingularMessageField(value: &self._ctime) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every if/case branch local when no optimizations
    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
    // https://github.com/apple/swift-protobuf/issues/1182
    if self.dev != 0 {
      try visitor.visitSingularUInt64Field(value: self.dev, fieldNumber: 1)
    }
    if self.ino != 0 {
      try visitor.visitSingularUInt64Field(value: self.ino, fieldNumber: 2)
    }
    if self.mode != 0 {
      try visitor.visitSingularUInt32Field(value: self.mode, fieldNumber: 3)
    }
    if self.nlink != 0 {
      try visitor.visitSingularUInt64Field(value: self.nlink, fieldNumber: 4)
    }
    if self.uid != 0 {
      try visitor.visitSingularUInt32Field(value: self.uid, fieldNumber: 5)
    }
    if self.gid != 0 {
      try visitor.visitSingularUInt32Field(value: self.gid, fieldNumber: 6)
    }
    if self.rdev != 0 {
      try visitor.visitSingularUInt64Field(value: self.rdev, fieldNumber: 7)
    }
    if self.size != 0 {
      try visitor.visitSingularInt64Field(value: self.size, fieldNumber: 8)
    }
    if self.blksize != 0 {
      try visitor.visitSingularInt64Field(value: self.blksize, fieldNumber: 9)
    }
    if self.blocks != 0 {
      try visitor.visitSingularInt64Field(value: self.blocks, fieldNumber: 10)
    }
    try { if let v = self._atime {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 11)
    } }()
    try { if let v = self._mtime {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 12)
    } }()
    try { if let v = self._ctime {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 13)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_Stat, rhs: Com_Apple_Containerization_Sandbox_V3_Stat) -> Bool {
    if lhs.dev != rhs.dev {return false}
    if lhs.ino != rhs.ino {return false}
    if lhs.mode != rhs.mode {return false}
    if lhs.nlink != rhs.nlink {return false}
    if lhs.uid != rhs.uid {return false}
    if lhs.gid != rhs.gid {return false}
    if lhs.rdev != rhs.rdev {return false}
    if lhs.size != rhs.size {return false}
    if lhs.blksize != rhs.blksize {return false}
    if lhs.blocks != rhs.blocks {return false}
    if lhs._atime != rhs._atime {return false}
    if lhs._mtime != rhs._mtime {return false}
    if lhs._ctime != rhs._ctime {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_StatResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".StatResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}stat\0\u{1}error\0")

  fileprivate class _StorageClass {
    var _stat: Com_Apple_Containerization_Sandbox_V3_Stat? = nil
    var _error: String = String()

      // 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) {
      _stat = source._stat
      _error = source._error
    }
  }

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

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    _ = _uniqueStorage()
    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
      while let fieldNumber = try decoder.nextFieldNumber() {
        // The use of inline closures is to circumvent an issue where the compiler
        // allocates stack space for every case branch when no optimizations are
        // enabled. https://github.com/apple/swift-protobuf/issues/1034
        switch fieldNumber {
        case 1: try { try decoder.decodeSingularMessageField(value: &_storage._stat) }()
        case 2: try { try decoder.decodeSingularStringField(value: &_storage._error) }()
        default: break
        }
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every if/case branch local when no optimizations
      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
      // https://github.com/apple/swift-protobuf/issues/1182
      try { if let v = _storage._stat {
        try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
      } }()
      if !_storage._error.isEmpty {
        try visitor.visitSingularStringField(value: _storage._error, fieldNumber: 2)
      }
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_StatResponse, rhs: Com_Apple_Containerization_Sandbox_V3_StatResponse) -> 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._stat != rhs_storage._stat {return false}
        if _storage._error != rhs_storage._error {return false}
        return true
      }
      if !storagesAreEqual {return false}
    }
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_FiTrimParams: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".FiTrimParams"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}one_shot\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try {
        var v: Com_Apple_Containerization_Sandbox_V3_FiTrimParams.OneShot?
        var hadOneofValue = false
        if let current = self.schedule {
          hadOneofValue = true
          if case .oneShot(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {
          if hadOneofValue {try decoder.handleConflictingOneOf()}
          self.schedule = .oneShot(v)
        }
      }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every if/case branch local when no optimizations
    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
    // https://github.com/apple/swift-protobuf/issues/1182
    try { if case .oneShot(let v)? = self.schedule {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_FiTrimParams.OneShot: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = Com_Apple_Containerization_Sandbox_V3_FiTrimParams.protoMessageName + ".OneShot"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_FiFreezeParams: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".FiFreezeParams"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_FiThawParams: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".FiThawParams"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_FiTrimResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".FiTrimResult"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}trimmed_bytes\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularUInt64Field(value: &self.trimmedBytes) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.trimmedBytes != 0 {
      try visitor.visitSingularUInt64Field(value: self.trimmedBytes, fieldNumber: 1)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".FilesystemOperationRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}path\0\u{1}trim\0\u{1}freeze\0\u{1}thaw\0\u{3}container_id\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.path) }()
      case 2: try {
        var v: Com_Apple_Containerization_Sandbox_V3_FiTrimParams?
        var hadOneofValue = false
        if let current = self.operation {
          hadOneofValue = true
          if case .trim(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {
          if hadOneofValue {try decoder.handleConflictingOneOf()}
          self.operation = .trim(v)
        }
      }()
      case 3: try {
        var v: Com_Apple_Containerization_Sandbox_V3_FiFreezeParams?
        var hadOneofValue = false
        if let current = self.operation {
          hadOneofValue = true
          if case .freeze(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {
          if hadOneofValue {try decoder.handleConflictingOneOf()}
          self.operation = .freeze(v)
        }
      }()
      case 4: try {
        var v: Com_Apple_Containerization_Sandbox_V3_FiThawParams?
        var hadOneofValue = false
        if let current = self.operation {
          hadOneofValue = true
          if case .thaw(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {
          if hadOneofValue {try decoder.handleConflictingOneOf()}
          self.operation = .thaw(v)
        }
      }()
      case 5: try { try decoder.decodeSingularStringField(value: &self._containerID) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every if/case branch local when no optimizations
    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
    // https://github.com/apple/swift-protobuf/issues/1182
    if !self.path.isEmpty {
      try visitor.visitSingularStringField(value: self.path, fieldNumber: 1)
    }
    switch self.operation {
    case .trim?: try {
      guard case .trim(let v)? = self.operation else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
    }()
    case .freeze?: try {
      guard case .freeze(let v)? = self.operation else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
    }()
    case .thaw?: try {
      guard case .thaw(let v)? = self.operation else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
    }()
    case nil: break
    }
    try { if let v = self._containerID {
      try visitor.visitSingularStringField(value: v, fieldNumber: 5)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest, rhs: Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest) -> Bool {
    if lhs.path != rhs.path {return false}
    if lhs.operation != rhs.operation {return false}
    if lhs._containerID != rhs._containerID {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_FilesystemOperationResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".FilesystemOperationResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}trim\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try {
        var v: Com_Apple_Containerization_Sandbox_V3_FiTrimResult?
        var hadOneofValue = false
        if let current = self.result {
          hadOneofValue = true
          if case .trim(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {
          if hadOneofValue {try decoder.handleConflictingOneOf()}
          self.result = .trim(v)
        }
      }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every if/case branch local when no optimizations
    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
    // https://github.com/apple/swift-protobuf/issues/1182
    try { if case .trim(let v)? = self.result {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".IpLinkSetRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}interface\0\u{1}up\0\u{1}mtu\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.interface) }()
      case 2: try { try decoder.decodeSingularBoolField(value: &self.up) }()
      case 3: try { try decoder.decodeSingularUInt32Field(value: &self._mtu) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every if/case branch local when no optimizations
    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
    // https://github.com/apple/swift-protobuf/issues/1182
    if !self.interface.isEmpty {
      try visitor.visitSingularStringField(value: self.interface, fieldNumber: 1)
    }
    if self.up != false {
      try visitor.visitSingularBoolField(value: self.up, fieldNumber: 2)
    }
    try { if let v = self._mtu {
      try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest, rhs: Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest) -> Bool {
    if lhs.interface != rhs.interface {return false}
    if lhs.up != rhs.up {return false}
    if lhs._mtu != rhs._mtu {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_IpLinkSetResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".IpLinkSetResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".IpAddrAddRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}interface\0\u{1}ipv4Address\0\u{1}ipv6Address\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.interface) }()
      case 2: try { try decoder.decodeSingularStringField(value: &self.ipv4Address) }()
      case 3: try { try decoder.decodeSingularStringField(value: &self._ipv6Address) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every if/case branch local when no optimizations
    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
    // https://github.com/apple/swift-protobuf/issues/1182
    if !self.interface.isEmpty {
      try visitor.visitSingularStringField(value: self.interface, fieldNumber: 1)
    }
    if !self.ipv4Address.isEmpty {
      try visitor.visitSingularStringField(value: self.ipv4Address, fieldNumber: 2)
    }
    try { if let v = self._ipv6Address {
      try visitor.visitSingularStringField(value: v, fieldNumber: 3)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest, rhs: Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest) -> Bool {
    if lhs.interface != rhs.interface {return false}
    if lhs.ipv4Address != rhs.ipv4Address {return false}
    if lhs._ipv6Address != rhs._ipv6Address {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_IpAddrAddResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".IpAddrAddResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".IpRouteAddLinkRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}interface\0\u{1}dstIpv4Addr\0\u{1}srcIpv4Addr\0\u{1}dstIpv6Addr\0\u{1}srcIpv6Addr\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.interface) }()
      case 2: try { try decoder.decodeSingularStringField(value: &self.dstIpv4Addr) }()
      case 3: try { try decoder.decodeSingularStringField(value: &self.srcIpv4Addr) }()
      case 4: try { try decoder.decodeSingularStringField(value: &self._dstIpv6Addr) }()
      case 5: try { try decoder.decodeSingularStringField(value: &self._srcIpv6Addr) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every if/case branch local when no optimizations
    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
    // https://github.com/apple/swift-protobuf/issues/1182
    if !self.interface.isEmpty {
      try visitor.visitSingularStringField(value: self.interface, fieldNumber: 1)
    }
    if !self.dstIpv4Addr.isEmpty {
      try visitor.visitSingularStringField(value: self.dstIpv4Addr, fieldNumber: 2)
    }
    if !self.srcIpv4Addr.isEmpty {
      try visitor.visitSingularStringField(value: self.srcIpv4Addr, fieldNumber: 3)
    }
    try { if let v = self._dstIpv6Addr {
      try visitor.visitSingularStringField(value: v, fieldNumber: 4)
    } }()
    try { if let v = self._srcIpv6Addr {
      try visitor.visitSingularStringField(value: v, fieldNumber: 5)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest, rhs: Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest) -> Bool {
    if lhs.interface != rhs.interface {return false}
    if lhs.dstIpv4Addr != rhs.dstIpv4Addr {return false}
    if lhs.srcIpv4Addr != rhs.srcIpv4Addr {return false}
    if lhs._dstIpv6Addr != rhs._dstIpv6Addr {return false}
    if lhs._srcIpv6Addr != rhs._srcIpv6Addr {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".IpRouteAddLinkResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".IpRouteAddDefaultRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}interface\0\u{1}ipv4Gateway\0\u{1}ipv6Gateway\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.interface) }()
      case 2: try { try decoder.decodeSingularStringField(value: &self.ipv4Gateway) }()
      case 3: try { try decoder.decodeSingularStringField(value: &self._ipv6Gateway) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every if/case branch local when no optimizations
    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
    // https://github.com/apple/swift-protobuf/issues/1182
    if !self.interface.isEmpty {
      try visitor.visitSingularStringField(value: self.interface, fieldNumber: 1)
    }
    if !self.ipv4Gateway.isEmpty {
      try visitor.visitSingularStringField(value: self.ipv4Gateway, fieldNumber: 2)
    }
    try { if let v = self._ipv6Gateway {
      try visitor.visitSingularStringField(value: v, fieldNumber: 3)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest, rhs: Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest) -> Bool {
    if lhs.interface != rhs.interface {return false}
    if lhs.ipv4Gateway != rhs.ipv4Gateway {return false}
    if lhs._ipv6Gateway != rhs._ipv6Gateway {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".IpRouteAddDefaultResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".ConfigureDnsRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}location\0\u{1}nameservers\0\u{1}domain\0\u{1}searchDomains\0\u{1}options\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.location) }()
      case 2: try { try decoder.decodeRepeatedStringField(value: &self.nameservers) }()
      case 3: try { try decoder.decodeSingularStringField(value: &self._domain) }()
      case 4: try { try decoder.decodeRepeatedStringField(value: &self.searchDomains) }()
      case 5: try { try decoder.decodeRepeatedStringField(value: &self.options) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every if/case branch local when no optimizations
    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
    // https://github.com/apple/swift-protobuf/issues/1182
    if !self.location.isEmpty {
      try visitor.visitSingularStringField(value: self.location, fieldNumber: 1)
    }
    if !self.nameservers.isEmpty {
      try visitor.visitRepeatedStringField(value: self.nameservers, fieldNumber: 2)
    }
    try { if let v = self._domain {
      try visitor.visitSingularStringField(value: v, fieldNumber: 3)
    } }()
    if !self.searchDomains.isEmpty {
      try visitor.visitRepeatedStringField(value: self.searchDomains, fieldNumber: 4)
    }
    if !self.options.isEmpty {
      try visitor.visitRepeatedStringField(value: self.options, fieldNumber: 5)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest, rhs: Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest) -> Bool {
    if lhs.location != rhs.location {return false}
    if lhs.nameservers != rhs.nameservers {return false}
    if lhs._domain != rhs._domain {return false}
    if lhs.searchDomains != rhs.searchDomains {return false}
    if lhs.options != rhs.options {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_ConfigureDnsResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".ConfigureDnsResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".ConfigureHostsRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}location\0\u{1}entries\0\u{1}comment\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.location) }()
      case 2: try { try decoder.decodeRepeatedMessageField(value: &self.entries) }()
      case 3: try { try decoder.decodeSingularStringField(value: &self._comment) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every if/case branch local when no optimizations
    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
    // https://github.com/apple/swift-protobuf/issues/1182
    if !self.location.isEmpty {
      try visitor.visitSingularStringField(value: self.location, fieldNumber: 1)
    }
    if !self.entries.isEmpty {
      try visitor.visitRepeatedMessageField(value: self.entries, fieldNumber: 2)
    }
    try { if let v = self._comment {
      try visitor.visitSingularStringField(value: v, fieldNumber: 3)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest, rhs: Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest) -> Bool {
    if lhs.location != rhs.location {return false}
    if lhs.entries != rhs.entries {return false}
    if lhs._comment != rhs._comment {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest.HostsEntry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest.protoMessageName + ".HostsEntry"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ipAddress\0\u{1}hostnames\0\u{1}comment\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.ipAddress) }()
      case 2: try { try decoder.decodeRepeatedStringField(value: &self.hostnames) }()
      case 3: try { try decoder.decodeSingularStringField(value: &self._comment) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every if/case branch local when no optimizations
    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
    // https://github.com/apple/swift-protobuf/issues/1182
    if !self.ipAddress.isEmpty {
      try visitor.visitSingularStringField(value: self.ipAddress, fieldNumber: 1)
    }
    if !self.hostnames.isEmpty {
      try visitor.visitRepeatedStringField(value: self.hostnames, fieldNumber: 2)
    }
    try { if let v = self._comment {
      try visitor.visitSingularStringField(value: v, fieldNumber: 3)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest.HostsEntry, rhs: Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest.HostsEntry) -> Bool {
    if lhs.ipAddress != rhs.ipAddress {return false}
    if lhs.hostnames != rhs.hostnames {return false}
    if lhs._comment != rhs._comment {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_ConfigureHostsResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".ConfigureHostsResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_SyncRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".SyncRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_SyncResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".SyncResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_KillRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".KillRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}pid\0\u{2}\u{2}signal\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularInt32Field(value: &self.pid) }()
      case 3: try { try decoder.decodeSingularInt32Field(value: &self.signal) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.pid != 0 {
      try visitor.visitSingularInt32Field(value: self.pid, fieldNumber: 1)
    }
    if self.signal != 0 {
      try visitor.visitSingularInt32Field(value: self.signal, fieldNumber: 3)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_KillRequest, rhs: Com_Apple_Containerization_Sandbox_V3_KillRequest) -> Bool {
    if lhs.pid != rhs.pid {return false}
    if lhs.signal != rhs.signal {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_KillResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".KillResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}result\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularInt32Field(value: &self.result) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.result != 0 {
      try visitor.visitSingularInt32Field(value: self.result, fieldNumber: 1)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".ContainerStatisticsRequest"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}container_ids\0\u{1}categories\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeRepeatedStringField(value: &self.containerIds) }()
      case 2: try { try decoder.decodeRepeatedEnumField(value: &self.categories) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.containerIds.isEmpty {
      try visitor.visitRepeatedStringField(value: self.containerIds, fieldNumber: 1)
    }
    if !self.categories.isEmpty {
      try visitor.visitPackedEnumField(value: self.categories, fieldNumber: 2)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest, rhs: Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest) -> Bool {
    if lhs.containerIds != rhs.containerIds {return false}
    if lhs.categories != rhs.categories {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".ContainerStatisticsResponse"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}containers\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeRepeatedMessageField(value: &self.containers) }()
      default: break
      }
    }
  }

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

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_ContainerStats: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".ContainerStats"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}container_id\0\u{1}process\0\u{1}memory\0\u{1}cpu\0\u{3}block_io\0\u{1}networks\0\u{3}memory_events\0")

  fileprivate class _StorageClass {
    var _containerID: String = String()
    var _process: Com_Apple_Containerization_Sandbox_V3_ProcessStats? = nil
    var _memory: Com_Apple_Containerization_Sandbox_V3_MemoryStats? = nil
    var _cpu: Com_Apple_Containerization_Sandbox_V3_CPUStats? = nil
    var _blockIo: Com_Apple_Containerization_Sandbox_V3_BlockIOStats? = nil
    var _networks: [Com_Apple_Containerization_Sandbox_V3_NetworkStats] = []
    var _memoryEvents: Com_Apple_Containerization_Sandbox_V3_MemoryEventStats? = 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) {
      _containerID = source._containerID
      _process = source._process
      _memory = source._memory
      _cpu = source._cpu
      _blockIo = source._blockIo
      _networks = source._networks
      _memoryEvents = source._memoryEvents
    }
  }

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

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    _ = _uniqueStorage()
    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
      while let fieldNumber = try decoder.nextFieldNumber() {
        // The use of inline closures is to circumvent an issue where the compiler
        // allocates stack space for every case branch when no optimizations are
        // enabled. https://github.com/apple/swift-protobuf/issues/1034
        switch fieldNumber {
        case 1: try { try decoder.decodeSingularStringField(value: &_storage._containerID) }()
        case 2: try { try decoder.decodeSingularMessageField(value: &_storage._process) }()
        case 3: try { try decoder.decodeSingularMessageField(value: &_storage._memory) }()
        case 4: try { try decoder.decodeSingularMessageField(value: &_storage._cpu) }()
        case 5: try { try decoder.decodeSingularMessageField(value: &_storage._blockIo) }()
        case 6: try { try decoder.decodeRepeatedMessageField(value: &_storage._networks) }()
        case 7: try { try decoder.decodeSingularMessageField(value: &_storage._memoryEvents) }()
        default: break
        }
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every if/case branch local when no optimizations
      // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
      // https://github.com/apple/swift-protobuf/issues/1182
      if !_storage._containerID.isEmpty {
        try visitor.visitSingularStringField(value: _storage._containerID, fieldNumber: 1)
      }
      try { if let v = _storage._process {
        try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
      } }()
      try { if let v = _storage._memory {
        try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
      } }()
      try { if let v = _storage._cpu {
        try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
      } }()
      try { if let v = _storage._blockIo {
        try visitor.visitSingularMessageField(value: v, fieldNumber: 5)
      } }()
      if !_storage._networks.isEmpty {
        try visitor.visitRepeatedMessageField(value: _storage._networks, fieldNumber: 6)
      }
      try { if let v = _storage._memoryEvents {
        try visitor.visitSingularMessageField(value: v, fieldNumber: 7)
      } }()
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_ContainerStats, rhs: Com_Apple_Containerization_Sandbox_V3_ContainerStats) -> 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._containerID != rhs_storage._containerID {return false}
        if _storage._process != rhs_storage._process {return false}
        if _storage._memory != rhs_storage._memory {return false}
        if _storage._cpu != rhs_storage._cpu {return false}
        if _storage._blockIo != rhs_storage._blockIo {return false}
        if _storage._networks != rhs_storage._networks {return false}
        if _storage._memoryEvents != rhs_storage._memoryEvents {return false}
        return true
      }
      if !storagesAreEqual {return false}
    }
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_ProcessStats: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".ProcessStats"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}current\0\u{1}limit\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularUInt64Field(value: &self.current) }()
      case 2: try { try decoder.decodeSingularUInt64Field(value: &self.limit) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.current != 0 {
      try visitor.visitSingularUInt64Field(value: self.current, fieldNumber: 1)
    }
    if self.limit != 0 {
      try visitor.visitSingularUInt64Field(value: self.limit, fieldNumber: 2)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_ProcessStats, rhs: Com_Apple_Containerization_Sandbox_V3_ProcessStats) -> Bool {
    if lhs.current != rhs.current {return false}
    if lhs.limit != rhs.limit {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_MemoryStats: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".MemoryStats"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}usage_bytes\0\u{3}limit_bytes\0\u{3}swap_usage_bytes\0\u{3}swap_limit_bytes\0\u{3}cache_bytes\0\u{3}kernel_stack_bytes\0\u{3}slab_bytes\0\u{3}page_faults\0\u{3}major_page_faults\0\u{3}inactive_file\0\u{1}anon\0\u{3}workingset_refault_anon\0\u{3}workingset_refault_file\0\u{3}pgsteal_kswapd\0\u{3}pgsteal_direct\0\u{3}pgsteal_khugepaged\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularUInt64Field(value: &self.usageBytes) }()
      case 2: try { try decoder.decodeSingularUInt64Field(value: &self.limitBytes) }()
      case 3: try { try decoder.decodeSingularUInt64Field(value: &self.swapUsageBytes) }()
      case 4: try { try decoder.decodeSingularUInt64Field(value: &self.swapLimitBytes) }()
      case 5: try { try decoder.decodeSingularUInt64Field(value: &self.cacheBytes) }()
      case 6: try { try decoder.decodeSingularUInt64Field(value: &self.kernelStackBytes) }()
      case 7: try { try decoder.decodeSingularUInt64Field(value: &self.slabBytes) }()
      case 8: try { try decoder.decodeSingularUInt64Field(value: &self.pageFaults) }()
      case 9: try { try decoder.decodeSingularUInt64Field(value: &self.majorPageFaults) }()
      case 10: try { try decoder.decodeSingularUInt64Field(value: &self.inactiveFile) }()
      case 11: try { try decoder.decodeSingularUInt64Field(value: &self.anon) }()
      case 12: try { try decoder.decodeSingularUInt64Field(value: &self.workingsetRefaultAnon) }()
      case 13: try { try decoder.decodeSingularUInt64Field(value: &self.workingsetRefaultFile) }()
      case 14: try { try decoder.decodeSingularUInt64Field(value: &self.pgstealKswapd) }()
      case 15: try { try decoder.decodeSingularUInt64Field(value: &self.pgstealDirect) }()
      case 16: try { try decoder.decodeSingularUInt64Field(value: &self.pgstealKhugepaged) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.usageBytes != 0 {
      try visitor.visitSingularUInt64Field(value: self.usageBytes, fieldNumber: 1)
    }
    if self.limitBytes != 0 {
      try visitor.visitSingularUInt64Field(value: self.limitBytes, fieldNumber: 2)
    }
    if self.swapUsageBytes != 0 {
      try visitor.visitSingularUInt64Field(value: self.swapUsageBytes, fieldNumber: 3)
    }
    if self.swapLimitBytes != 0 {
      try visitor.visitSingularUInt64Field(value: self.swapLimitBytes, fieldNumber: 4)
    }
    if self.cacheBytes != 0 {
      try visitor.visitSingularUInt64Field(value: self.cacheBytes, fieldNumber: 5)
    }
    if self.kernelStackBytes != 0 {
      try visitor.visitSingularUInt64Field(value: self.kernelStackBytes, fieldNumber: 6)
    }
    if self.slabBytes != 0 {
      try visitor.visitSingularUInt64Field(value: self.slabBytes, fieldNumber: 7)
    }
    if self.pageFaults != 0 {
      try visitor.visitSingularUInt64Field(value: self.pageFaults, fieldNumber: 8)
    }
    if self.majorPageFaults != 0 {
      try visitor.visitSingularUInt64Field(value: self.majorPageFaults, fieldNumber: 9)
    }
    if self.inactiveFile != 0 {
      try visitor.visitSingularUInt64Field(value: self.inactiveFile, fieldNumber: 10)
    }
    if self.anon != 0 {
      try visitor.visitSingularUInt64Field(value: self.anon, fieldNumber: 11)
    }
    if self.workingsetRefaultAnon != 0 {
      try visitor.visitSingularUInt64Field(value: self.workingsetRefaultAnon, fieldNumber: 12)
    }
    if self.workingsetRefaultFile != 0 {
      try visitor.visitSingularUInt64Field(value: self.workingsetRefaultFile, fieldNumber: 13)
    }
    if self.pgstealKswapd != 0 {
      try visitor.visitSingularUInt64Field(value: self.pgstealKswapd, fieldNumber: 14)
    }
    if self.pgstealDirect != 0 {
      try visitor.visitSingularUInt64Field(value: self.pgstealDirect, fieldNumber: 15)
    }
    if self.pgstealKhugepaged != 0 {
      try visitor.visitSingularUInt64Field(value: self.pgstealKhugepaged, fieldNumber: 16)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_MemoryStats, rhs: Com_Apple_Containerization_Sandbox_V3_MemoryStats) -> Bool {
    if lhs.usageBytes != rhs.usageBytes {return false}
    if lhs.limitBytes != rhs.limitBytes {return false}
    if lhs.swapUsageBytes != rhs.swapUsageBytes {return false}
    if lhs.swapLimitBytes != rhs.swapLimitBytes {return false}
    if lhs.cacheBytes != rhs.cacheBytes {return false}
    if lhs.kernelStackBytes != rhs.kernelStackBytes {return false}
    if lhs.slabBytes != rhs.slabBytes {return false}
    if lhs.pageFaults != rhs.pageFaults {return false}
    if lhs.majorPageFaults != rhs.majorPageFaults {return false}
    if lhs.inactiveFile != rhs.inactiveFile {return false}
    if lhs.anon != rhs.anon {return false}
    if lhs.workingsetRefaultAnon != rhs.workingsetRefaultAnon {return false}
    if lhs.workingsetRefaultFile != rhs.workingsetRefaultFile {return false}
    if lhs.pgstealKswapd != rhs.pgstealKswapd {return false}
    if lhs.pgstealDirect != rhs.pgstealDirect {return false}
    if lhs.pgstealKhugepaged != rhs.pgstealKhugepaged {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_CPUStats: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".CPUStats"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}usage_usec\0\u{3}user_usec\0\u{3}system_usec\0\u{3}throttling_periods\0\u{3}throttled_periods\0\u{3}throttled_time_usec\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularUInt64Field(value: &self.usageUsec) }()
      case 2: try { try decoder.decodeSingularUInt64Field(value: &self.userUsec) }()
      case 3: try { try decoder.decodeSingularUInt64Field(value: &self.systemUsec) }()
      case 4: try { try decoder.decodeSingularUInt64Field(value: &self.throttlingPeriods) }()
      case 5: try { try decoder.decodeSingularUInt64Field(value: &self.throttledPeriods) }()
      case 6: try { try decoder.decodeSingularUInt64Field(value: &self.throttledTimeUsec) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.usageUsec != 0 {
      try visitor.visitSingularUInt64Field(value: self.usageUsec, fieldNumber: 1)
    }
    if self.userUsec != 0 {
      try visitor.visitSingularUInt64Field(value: self.userUsec, fieldNumber: 2)
    }
    if self.systemUsec != 0 {
      try visitor.visitSingularUInt64Field(value: self.systemUsec, fieldNumber: 3)
    }
    if self.throttlingPeriods != 0 {
      try visitor.visitSingularUInt64Field(value: self.throttlingPeriods, fieldNumber: 4)
    }
    if self.throttledPeriods != 0 {
      try visitor.visitSingularUInt64Field(value: self.throttledPeriods, fieldNumber: 5)
    }
    if self.throttledTimeUsec != 0 {
      try visitor.visitSingularUInt64Field(value: self.throttledTimeUsec, fieldNumber: 6)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_CPUStats, rhs: Com_Apple_Containerization_Sandbox_V3_CPUStats) -> Bool {
    if lhs.usageUsec != rhs.usageUsec {return false}
    if lhs.userUsec != rhs.userUsec {return false}
    if lhs.systemUsec != rhs.systemUsec {return false}
    if lhs.throttlingPeriods != rhs.throttlingPeriods {return false}
    if lhs.throttledPeriods != rhs.throttledPeriods {return false}
    if lhs.throttledTimeUsec != rhs.throttledTimeUsec {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_BlockIOStats: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".BlockIOStats"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}devices\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeRepeatedMessageField(value: &self.devices) }()
      default: break
      }
    }
  }

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

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

nonisolated extension Com_Apple_Containerization_Sandbox_V3_BlockIOEntry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".BlockIOEntry"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}major\0\u{1}minor\0\u{3}read_bytes\0\u{3}write_bytes\0\u{3}read_operations\0\u{3}write_operations\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularUInt64Field(value: &self.major) }()
      case 2: try { try decoder.decodeSingularUInt64Field(value: &self.minor) }()
      case 3: try { try decoder.decodeSingularUInt64Field(value: &self.readBytes) }()
      case 4: try { try decoder.decodeSingularUInt64Field(value: &self.writeBytes) }()
      case 5: try { try decoder.decodeSingularUInt64Field(value: &self.readOperations) }()
      case 6: try { try decoder.decodeSingularUInt64Field(value: &self.writeOperations) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.major != 0 {
      try visitor.visitSingularUInt64Field(value: self.major, fieldNumber: 1)
    }
    if self.minor != 0 {
      try visitor.visitSingularUInt64Field(value: self.minor, fieldNumber: 2)
    }
    if self.readBytes != 0 {
      try visitor.visitSingularUInt64Field(value: self.readBytes, fieldNumber: 3)
    }
    if self.writeBytes != 0 {
      try visitor.visitSingularUInt64Field(value: self.writeBytes, fieldNumber: 4)
    }
    if self.readOperations != 0 {
      try visitor.visitSingularUInt64Field(value: self.readOperations, fieldNumber: 5)
    }
    if self.writeOperations != 0 {
      try visitor.visitSingularUInt64Field(value: self.writeOperations, fieldNumber: 6)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_BlockIOEntry, rhs: Com_Apple_Containerization_Sandbox_V3_BlockIOEntry) -> Bool {
    if lhs.major != rhs.major {return false}
    if lhs.minor != rhs.minor {return false}
    if lhs.readBytes != rhs.readBytes {return false}
    if lhs.writeBytes != rhs.writeBytes {return false}
    if lhs.readOperations != rhs.readOperations {return false}
    if lhs.writeOperations != rhs.writeOperations {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_NetworkStats: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".NetworkStats"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}interface\0\u{1}receivedPackets\0\u{1}transmittedPackets\0\u{1}receivedBytes\0\u{1}transmittedBytes\0\u{1}receivedErrors\0\u{1}transmittedErrors\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.interface) }()
      case 2: try { try decoder.decodeSingularUInt64Field(value: &self.receivedPackets) }()
      case 3: try { try decoder.decodeSingularUInt64Field(value: &self.transmittedPackets) }()
      case 4: try { try decoder.decodeSingularUInt64Field(value: &self.receivedBytes) }()
      case 5: try { try decoder.decodeSingularUInt64Field(value: &self.transmittedBytes) }()
      case 6: try { try decoder.decodeSingularUInt64Field(value: &self.receivedErrors) }()
      case 7: try { try decoder.decodeSingularUInt64Field(value: &self.transmittedErrors) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.interface.isEmpty {
      try visitor.visitSingularStringField(value: self.interface, fieldNumber: 1)
    }
    if self.receivedPackets != 0 {
      try visitor.visitSingularUInt64Field(value: self.receivedPackets, fieldNumber: 2)
    }
    if self.transmittedPackets != 0 {
      try visitor.visitSingularUInt64Field(value: self.transmittedPackets, fieldNumber: 3)
    }
    if self.receivedBytes != 0 {
      try visitor.visitSingularUInt64Field(value: self.receivedBytes, fieldNumber: 4)
    }
    if self.transmittedBytes != 0 {
      try visitor.visitSingularUInt64Field(value: self.transmittedBytes, fieldNumber: 5)
    }
    if self.receivedErrors != 0 {
      try visitor.visitSingularUInt64Field(value: self.receivedErrors, fieldNumber: 6)
    }
    if self.transmittedErrors != 0 {
      try visitor.visitSingularUInt64Field(value: self.transmittedErrors, fieldNumber: 7)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_NetworkStats, rhs: Com_Apple_Containerization_Sandbox_V3_NetworkStats) -> Bool {
    if lhs.interface != rhs.interface {return false}
    if lhs.receivedPackets != rhs.receivedPackets {return false}
    if lhs.transmittedPackets != rhs.transmittedPackets {return false}
    if lhs.receivedBytes != rhs.receivedBytes {return false}
    if lhs.transmittedBytes != rhs.transmittedBytes {return false}
    if lhs.receivedErrors != rhs.receivedErrors {return false}
    if lhs.transmittedErrors != rhs.transmittedErrors {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

nonisolated extension Com_Apple_Containerization_Sandbox_V3_MemoryEventStats: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  public static let protoMessageName: String = _protobuf_package + ".MemoryEventStats"
  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}low\0\u{1}high\0\u{1}max\0\u{1}oom\0\u{3}oom_kill\0\u{3}oom_group_kill\0")

  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularUInt64Field(value: &self.low) }()
      case 2: try { try decoder.decodeSingularUInt64Field(value: &self.high) }()
      case 3: try { try decoder.decodeSingularUInt64Field(value: &self.max) }()
      case 4: try { try decoder.decodeSingularUInt64Field(value: &self.oom) }()
      case 5: try { try decoder.decodeSingularUInt64Field(value: &self.oomKill) }()
      case 6: try { try decoder.decodeSingularUInt64Field(value: &self.oomGroupKill) }()
      default: break
      }
    }
  }

  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.low != 0 {
      try visitor.visitSingularUInt64Field(value: self.low, fieldNumber: 1)
    }
    if self.high != 0 {
      try visitor.visitSingularUInt64Field(value: self.high, fieldNumber: 2)
    }
    if self.max != 0 {
      try visitor.visitSingularUInt64Field(value: self.max, fieldNumber: 3)
    }
    if self.oom != 0 {
      try visitor.visitSingularUInt64Field(value: self.oom, fieldNumber: 4)
    }
    if self.oomKill != 0 {
      try visitor.visitSingularUInt64Field(value: self.oomKill, fieldNumber: 5)
    }
    if self.oomGroupKill != 0 {
      try visitor.visitSingularUInt64Field(value: self.oomGroupKill, fieldNumber: 6)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  public static func ==(lhs: Com_Apple_Containerization_Sandbox_V3_MemoryEventStats, rhs: Com_Apple_Containerization_Sandbox_V3_MemoryEventStats) -> Bool {
    if lhs.low != rhs.low {return false}
    if lhs.high != rhs.high {return false}
    if lhs.max != rhs.max {return false}
    if lhs.oom != rhs.oom {return false}
    if lhs.oomKill != rhs.oomKill {return false}
    if lhs.oomGroupKill != rhs.oomGroupKill {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}