apple--containerization/Sources/Containerization/SandboxContext/SandboxContext.grpc.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 gRPC 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/grpc/grpc-swift

import GRPCCore
import GRPCProtobuf

// MARK: - com.apple.containerization.sandbox.v3.SandboxContext

/// Namespace containing generated types for the "com.apple.containerization.sandbox.v3.SandboxContext" service.
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
public enum Com_Apple_Containerization_Sandbox_V3_SandboxContext: Sendable {
    /// Service descriptor for the "com.apple.containerization.sandbox.v3.SandboxContext" service.
    public static let descriptor = GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext")
    /// Namespace for method metadata.
    public enum Method: Sendable {
        /// Namespace for "Mount" metadata.
        public enum Mount: Sendable {
            /// Request type for "Mount".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_MountRequest
            /// Response type for "Mount".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_MountResponse
            /// Descriptor for "Mount".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "Mount",
                type: .unary
            )
        }
        /// Namespace for "Umount" metadata.
        public enum Umount: Sendable {
            /// Request type for "Umount".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_UmountRequest
            /// Response type for "Umount".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_UmountResponse
            /// Descriptor for "Umount".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "Umount",
                type: .unary
            )
        }
        /// Namespace for "Setenv" metadata.
        public enum Setenv: Sendable {
            /// Request type for "Setenv".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_SetenvRequest
            /// Response type for "Setenv".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_SetenvResponse
            /// Descriptor for "Setenv".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "Setenv",
                type: .unary
            )
        }
        /// Namespace for "Getenv" metadata.
        public enum Getenv: Sendable {
            /// Request type for "Getenv".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_GetenvRequest
            /// Response type for "Getenv".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_GetenvResponse
            /// Descriptor for "Getenv".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "Getenv",
                type: .unary
            )
        }
        /// Namespace for "Mkdir" metadata.
        public enum Mkdir: Sendable {
            /// Request type for "Mkdir".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_MkdirRequest
            /// Response type for "Mkdir".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_MkdirResponse
            /// Descriptor for "Mkdir".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "Mkdir",
                type: .unary
            )
        }
        /// Namespace for "Sysctl" metadata.
        public enum Sysctl: Sendable {
            /// Request type for "Sysctl".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_SysctlRequest
            /// Response type for "Sysctl".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_SysctlResponse
            /// Descriptor for "Sysctl".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "Sysctl",
                type: .unary
            )
        }
        /// Namespace for "SetTime" metadata.
        public enum SetTime: Sendable {
            /// Request type for "SetTime".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_SetTimeRequest
            /// Response type for "SetTime".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_SetTimeResponse
            /// Descriptor for "SetTime".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "SetTime",
                type: .unary
            )
        }
        /// Namespace for "SetupEmulator" metadata.
        public enum SetupEmulator: Sendable {
            /// Request type for "SetupEmulator".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest
            /// Response type for "SetupEmulator".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_SetupEmulatorResponse
            /// Descriptor for "SetupEmulator".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "SetupEmulator",
                type: .unary
            )
        }
        /// Namespace for "WriteFile" metadata.
        public enum WriteFile: Sendable {
            /// Request type for "WriteFile".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_WriteFileRequest
            /// Response type for "WriteFile".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_WriteFileResponse
            /// Descriptor for "WriteFile".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "WriteFile",
                type: .unary
            )
        }
        /// Namespace for "Copy" metadata.
        public enum Copy: Sendable {
            /// Request type for "Copy".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_CopyRequest
            /// Response type for "Copy".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_CopyResponse
            /// Descriptor for "Copy".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "Copy",
                type: .serverStreaming
            )
        }
        /// Namespace for "Stat" metadata.
        public enum Stat: Sendable {
            /// Request type for "Stat".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_StatRequest
            /// Response type for "Stat".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_StatResponse
            /// Descriptor for "Stat".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "Stat",
                type: .unary
            )
        }
        /// Namespace for "FilesystemOperation" metadata.
        public enum FilesystemOperation: Sendable {
            /// Request type for "FilesystemOperation".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest
            /// Response type for "FilesystemOperation".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_FilesystemOperationResponse
            /// Descriptor for "FilesystemOperation".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "FilesystemOperation",
                type: .unary
            )
        }
        /// Namespace for "CreateProcess" metadata.
        public enum CreateProcess: Sendable {
            /// Request type for "CreateProcess".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest
            /// Response type for "CreateProcess".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_CreateProcessResponse
            /// Descriptor for "CreateProcess".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "CreateProcess",
                type: .unary
            )
        }
        /// Namespace for "DeleteProcess" metadata.
        public enum DeleteProcess: Sendable {
            /// Request type for "DeleteProcess".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest
            /// Response type for "DeleteProcess".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_DeleteProcessResponse
            /// Descriptor for "DeleteProcess".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "DeleteProcess",
                type: .unary
            )
        }
        /// Namespace for "StartProcess" metadata.
        public enum StartProcess: Sendable {
            /// Request type for "StartProcess".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_StartProcessRequest
            /// Response type for "StartProcess".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_StartProcessResponse
            /// Descriptor for "StartProcess".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "StartProcess",
                type: .unary
            )
        }
        /// Namespace for "KillProcess" metadata.
        public enum KillProcess: Sendable {
            /// Request type for "KillProcess".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_KillProcessRequest
            /// Response type for "KillProcess".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_KillProcessResponse
            /// Descriptor for "KillProcess".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "KillProcess",
                type: .unary
            )
        }
        /// Namespace for "WaitProcess" metadata.
        public enum WaitProcess: Sendable {
            /// Request type for "WaitProcess".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest
            /// Response type for "WaitProcess".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_WaitProcessResponse
            /// Descriptor for "WaitProcess".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "WaitProcess",
                type: .unary
            )
        }
        /// Namespace for "ResizeProcess" metadata.
        public enum ResizeProcess: Sendable {
            /// Request type for "ResizeProcess".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest
            /// Response type for "ResizeProcess".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_ResizeProcessResponse
            /// Descriptor for "ResizeProcess".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "ResizeProcess",
                type: .unary
            )
        }
        /// Namespace for "CloseProcessStdin" metadata.
        public enum CloseProcessStdin: Sendable {
            /// Request type for "CloseProcessStdin".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest
            /// Response type for "CloseProcessStdin".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinResponse
            /// Descriptor for "CloseProcessStdin".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "CloseProcessStdin",
                type: .unary
            )
        }
        /// Namespace for "ContainerStatistics" metadata.
        public enum ContainerStatistics: Sendable {
            /// Request type for "ContainerStatistics".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest
            /// Response type for "ContainerStatistics".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsResponse
            /// Descriptor for "ContainerStatistics".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "ContainerStatistics",
                type: .unary
            )
        }
        /// Namespace for "ProxyVsock" metadata.
        public enum ProxyVsock: Sendable {
            /// Request type for "ProxyVsock".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest
            /// Response type for "ProxyVsock".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_ProxyVsockResponse
            /// Descriptor for "ProxyVsock".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "ProxyVsock",
                type: .unary
            )
        }
        /// Namespace for "StopVsockProxy" metadata.
        public enum StopVsockProxy: Sendable {
            /// Request type for "StopVsockProxy".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_StopVsockProxyRequest
            /// Response type for "StopVsockProxy".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_StopVsockProxyResponse
            /// Descriptor for "StopVsockProxy".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "StopVsockProxy",
                type: .unary
            )
        }
        /// Namespace for "IpLinkSet" metadata.
        public enum IpLinkSet: Sendable {
            /// Request type for "IpLinkSet".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest
            /// Response type for "IpLinkSet".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_IpLinkSetResponse
            /// Descriptor for "IpLinkSet".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "IpLinkSet",
                type: .unary
            )
        }
        /// Namespace for "IpAddrAdd" metadata.
        public enum IpAddrAdd: Sendable {
            /// Request type for "IpAddrAdd".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest
            /// Response type for "IpAddrAdd".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_IpAddrAddResponse
            /// Descriptor for "IpAddrAdd".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "IpAddrAdd",
                type: .unary
            )
        }
        /// Namespace for "IpRouteAddLink" metadata.
        public enum IpRouteAddLink: Sendable {
            /// Request type for "IpRouteAddLink".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest
            /// Response type for "IpRouteAddLink".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkResponse
            /// Descriptor for "IpRouteAddLink".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "IpRouteAddLink",
                type: .unary
            )
        }
        /// Namespace for "IpRouteAddDefault" metadata.
        public enum IpRouteAddDefault: Sendable {
            /// Request type for "IpRouteAddDefault".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest
            /// Response type for "IpRouteAddDefault".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultResponse
            /// Descriptor for "IpRouteAddDefault".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "IpRouteAddDefault",
                type: .unary
            )
        }
        /// Namespace for "ConfigureDns" metadata.
        public enum ConfigureDns: Sendable {
            /// Request type for "ConfigureDns".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest
            /// Response type for "ConfigureDns".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_ConfigureDnsResponse
            /// Descriptor for "ConfigureDns".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "ConfigureDns",
                type: .unary
            )
        }
        /// Namespace for "ConfigureHosts" metadata.
        public enum ConfigureHosts: Sendable {
            /// Request type for "ConfigureHosts".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest
            /// Response type for "ConfigureHosts".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_ConfigureHostsResponse
            /// Descriptor for "ConfigureHosts".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "ConfigureHosts",
                type: .unary
            )
        }
        /// Namespace for "Sync" metadata.
        public enum Sync: Sendable {
            /// Request type for "Sync".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_SyncRequest
            /// Response type for "Sync".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_SyncResponse
            /// Descriptor for "Sync".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "Sync",
                type: .unary
            )
        }
        /// Namespace for "Kill" metadata.
        public enum Kill: Sendable {
            /// Request type for "Kill".
            public typealias Input = Com_Apple_Containerization_Sandbox_V3_KillRequest
            /// Response type for "Kill".
            public typealias Output = Com_Apple_Containerization_Sandbox_V3_KillResponse
            /// Descriptor for "Kill".
            public static let descriptor = GRPCCore.MethodDescriptor(
                service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext"),
                method: "Kill",
                type: .unary
            )
        }
        /// Descriptors for all methods in the "com.apple.containerization.sandbox.v3.SandboxContext" service.
        public static let descriptors: [GRPCCore.MethodDescriptor] = [
            Mount.descriptor,
            Umount.descriptor,
            Setenv.descriptor,
            Getenv.descriptor,
            Mkdir.descriptor,
            Sysctl.descriptor,
            SetTime.descriptor,
            SetupEmulator.descriptor,
            WriteFile.descriptor,
            Copy.descriptor,
            Stat.descriptor,
            FilesystemOperation.descriptor,
            CreateProcess.descriptor,
            DeleteProcess.descriptor,
            StartProcess.descriptor,
            KillProcess.descriptor,
            WaitProcess.descriptor,
            ResizeProcess.descriptor,
            CloseProcessStdin.descriptor,
            ContainerStatistics.descriptor,
            ProxyVsock.descriptor,
            StopVsockProxy.descriptor,
            IpLinkSet.descriptor,
            IpAddrAdd.descriptor,
            IpRouteAddLink.descriptor,
            IpRouteAddDefault.descriptor,
            ConfigureDns.descriptor,
            ConfigureHosts.descriptor,
            Sync.descriptor,
            Kill.descriptor
        ]
    }
}

@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension GRPCCore.ServiceDescriptor {
    /// Service descriptor for the "com.apple.containerization.sandbox.v3.SandboxContext" service.
    public static let com_apple_containerization_sandbox_v3_SandboxContext = GRPCCore.ServiceDescriptor(fullyQualifiedService: "com.apple.containerization.sandbox.v3.SandboxContext")
}

// MARK: com.apple.containerization.sandbox.v3.SandboxContext (server)

@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension Com_Apple_Containerization_Sandbox_V3_SandboxContext {
    /// Streaming variant of the service protocol for the "com.apple.containerization.sandbox.v3.SandboxContext" service.
    ///
    /// This protocol is the lowest-level of the service protocols generated for this service
    /// giving you the most flexibility over the implementation of your service. This comes at
    /// the cost of more verbose and less strict APIs. Each RPC requires you to implement it in
    /// terms of a request stream and response stream. Where only a single request or response
    /// message is expected, you are responsible for enforcing this invariant is maintained.
    ///
    /// Where possible, prefer using the stricter, less-verbose ``ServiceProtocol``
    /// or ``SimpleServiceProtocol`` instead.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Context for interacting with a container's runtime environment.
    public protocol StreamingServiceProtocol: GRPCCore.RegistrableRPCService {
        /// Handle the "Mount" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Mount a filesystem.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_MountRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_MountResponse` messages.
        func mount(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_MountRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_MountResponse>

        /// Handle the "Umount" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Unmount a filesystem.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_UmountRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_UmountResponse` messages.
        func umount(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_UmountRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_UmountResponse>

        /// Handle the "Setenv" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Set an environment variable on the init process.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_SetenvRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_SetenvResponse` messages.
        func setenv(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_SetenvRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_SetenvResponse>

        /// Handle the "Getenv" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Get an environment variable from the init process.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_GetenvRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_GetenvResponse` messages.
        func getenv(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_GetenvRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_GetenvResponse>

        /// Handle the "Mkdir" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Create a new directory inside the sandbox.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_MkdirRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_MkdirResponse` messages.
        func mkdir(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_MkdirRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_MkdirResponse>

        /// Handle the "Sysctl" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Set sysctls in the context of the sandbox.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_SysctlRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_SysctlResponse` messages.
        func sysctl(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_SysctlRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_SysctlResponse>

        /// Handle the "SetTime" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Set time in the guest.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_SetTimeRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_SetTimeResponse` messages.
        func setTime(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_SetTimeRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_SetTimeResponse>

        /// Handle the "SetupEmulator" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Set up an emulator in the guest for a specific binary format.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_SetupEmulatorResponse` messages.
        func setupEmulator(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_SetupEmulatorResponse>

        /// Handle the "WriteFile" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Write data to an existing or new file.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_WriteFileRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_WriteFileResponse` messages.
        func writeFile(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_WriteFileRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_WriteFileResponse>

        /// Handle the "Copy" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Copy a file or directory between the host and guest.
        /// > Data transfer happens over a dedicated vsock connection;
        /// > the gRPC stream is used only for control/metadata.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_CopyRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_CopyResponse` messages.
        func copy(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_CopyRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_CopyResponse>

        /// Handle the "Stat" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Stat a path in the guest filesystem.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_StatRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_StatResponse` messages.
        func stat(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_StatRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_StatResponse>

        /// Handle the "FilesystemOperation" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Perform a filesystem operation on a mounted filesystem.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_FilesystemOperationResponse` messages.
        func filesystemOperation(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_FilesystemOperationResponse>

        /// Handle the "CreateProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Create a new process inside the container.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_CreateProcessResponse` messages.
        func createProcess(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_CreateProcessResponse>

        /// Handle the "DeleteProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Delete an existing process inside the container.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_DeleteProcessResponse` messages.
        func deleteProcess(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_DeleteProcessResponse>

        /// Handle the "StartProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Start the provided process.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_StartProcessRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_StartProcessResponse` messages.
        func startProcess(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_StartProcessRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_StartProcessResponse>

        /// Handle the "KillProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Send a signal to the provided process.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_KillProcessRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_KillProcessResponse` messages.
        func killProcess(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_KillProcessRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_KillProcessResponse>

        /// Handle the "WaitProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Wait for a process to exit and return the exit code.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_WaitProcessResponse` messages.
        func waitProcess(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_WaitProcessResponse>

        /// Handle the "ResizeProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Resize the tty of a given process. This will error if the process does
        /// > not have a pty allocated.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_ResizeProcessResponse` messages.
        func resizeProcess(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_ResizeProcessResponse>

        /// Handle the "CloseProcessStdin" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Close IO for a given process.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinResponse` messages.
        func closeProcessStdin(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinResponse>

        /// Handle the "ContainerStatistics" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Get statistics for containers.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsResponse` messages.
        func containerStatistics(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsResponse>

        /// Handle the "ProxyVsock" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Proxy a vsock port to a unix domain socket in the guest, or vice versa.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_ProxyVsockResponse` messages.
        func proxyVsock(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_ProxyVsockResponse>

        /// Handle the "StopVsockProxy" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Stop a vsock proxy to a unix domain socket.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_StopVsockProxyRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_StopVsockProxyResponse` messages.
        func stopVsockProxy(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_StopVsockProxyRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_StopVsockProxyResponse>

        /// Handle the "IpLinkSet" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Set the link state of a network interface.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_IpLinkSetResponse` messages.
        func ipLinkSet(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_IpLinkSetResponse>

        /// Handle the "IpAddrAdd" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Add an IPv4 address to a network interface.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_IpAddrAddResponse` messages.
        func ipAddrAdd(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_IpAddrAddResponse>

        /// Handle the "IpRouteAddLink" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Add an IP route for a network interface.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkResponse` messages.
        func ipRouteAddLink(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkResponse>

        /// Handle the "IpRouteAddDefault" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Add an IP route for a network interface.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultResponse` messages.
        func ipRouteAddDefault(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultResponse>

        /// Handle the "ConfigureDns" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Configure DNS resolver.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_ConfigureDnsResponse` messages.
        func configureDns(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_ConfigureDnsResponse>

        /// Handle the "ConfigureHosts" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Configure /etc/hosts.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_ConfigureHostsResponse` messages.
        func configureHosts(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_ConfigureHostsResponse>

        /// Handle the "Sync" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Perform the sync syscall.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_SyncRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_SyncResponse` messages.
        func sync(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_SyncRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_SyncResponse>

        /// Handle the "Kill" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Send a signal to a process via the PID.
        ///
        /// - Parameters:
        ///   - request: A streaming request of `Com_Apple_Containerization_Sandbox_V3_KillRequest` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_KillResponse` messages.
        func kill(
            request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_KillRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_KillResponse>
    }

    /// Service protocol for the "com.apple.containerization.sandbox.v3.SandboxContext" service.
    ///
    /// This protocol is higher level than ``StreamingServiceProtocol`` but lower level than
    /// the ``SimpleServiceProtocol``, it provides access to request and response metadata and
    /// trailing response metadata. If you don't need these then consider using
    /// the ``SimpleServiceProtocol``. If you need fine grained control over your RPCs then
    /// use ``StreamingServiceProtocol``.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Context for interacting with a container's runtime environment.
    public protocol ServiceProtocol: Com_Apple_Containerization_Sandbox_V3_SandboxContext.StreamingServiceProtocol {
        /// Handle the "Mount" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Mount a filesystem.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_MountRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_MountResponse` message.
        func mount(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_MountRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_MountResponse>

        /// Handle the "Umount" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Unmount a filesystem.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_UmountRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_UmountResponse` message.
        func umount(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_UmountRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_UmountResponse>

        /// Handle the "Setenv" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Set an environment variable on the init process.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_SetenvRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_SetenvResponse` message.
        func setenv(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_SetenvRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_SetenvResponse>

        /// Handle the "Getenv" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Get an environment variable from the init process.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_GetenvRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_GetenvResponse` message.
        func getenv(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_GetenvRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_GetenvResponse>

        /// Handle the "Mkdir" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Create a new directory inside the sandbox.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_MkdirRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_MkdirResponse` message.
        func mkdir(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_MkdirRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_MkdirResponse>

        /// Handle the "Sysctl" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Set sysctls in the context of the sandbox.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_SysctlRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_SysctlResponse` message.
        func sysctl(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_SysctlRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_SysctlResponse>

        /// Handle the "SetTime" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Set time in the guest.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_SetTimeRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_SetTimeResponse` message.
        func setTime(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_SetTimeRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_SetTimeResponse>

        /// Handle the "SetupEmulator" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Set up an emulator in the guest for a specific binary format.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_SetupEmulatorResponse` message.
        func setupEmulator(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_SetupEmulatorResponse>

        /// Handle the "WriteFile" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Write data to an existing or new file.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_WriteFileRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_WriteFileResponse` message.
        func writeFile(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_WriteFileRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_WriteFileResponse>

        /// Handle the "Copy" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Copy a file or directory between the host and guest.
        /// > Data transfer happens over a dedicated vsock connection;
        /// > the gRPC stream is used only for control/metadata.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_CopyRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A streaming response of `Com_Apple_Containerization_Sandbox_V3_CopyResponse` messages.
        func copy(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_CopyRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_CopyResponse>

        /// Handle the "Stat" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Stat a path in the guest filesystem.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_StatRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_StatResponse` message.
        func stat(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_StatRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_StatResponse>

        /// Handle the "FilesystemOperation" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Perform a filesystem operation on a mounted filesystem.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_FilesystemOperationResponse` message.
        func filesystemOperation(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_FilesystemOperationResponse>

        /// Handle the "CreateProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Create a new process inside the container.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_CreateProcessResponse` message.
        func createProcess(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_CreateProcessResponse>

        /// Handle the "DeleteProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Delete an existing process inside the container.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_DeleteProcessResponse` message.
        func deleteProcess(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_DeleteProcessResponse>

        /// Handle the "StartProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Start the provided process.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_StartProcessRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_StartProcessResponse` message.
        func startProcess(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_StartProcessRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_StartProcessResponse>

        /// Handle the "KillProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Send a signal to the provided process.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_KillProcessRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_KillProcessResponse` message.
        func killProcess(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_KillProcessRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_KillProcessResponse>

        /// Handle the "WaitProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Wait for a process to exit and return the exit code.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_WaitProcessResponse` message.
        func waitProcess(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_WaitProcessResponse>

        /// Handle the "ResizeProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Resize the tty of a given process. This will error if the process does
        /// > not have a pty allocated.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_ResizeProcessResponse` message.
        func resizeProcess(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_ResizeProcessResponse>

        /// Handle the "CloseProcessStdin" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Close IO for a given process.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinResponse` message.
        func closeProcessStdin(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinResponse>

        /// Handle the "ContainerStatistics" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Get statistics for containers.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsResponse` message.
        func containerStatistics(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsResponse>

        /// Handle the "ProxyVsock" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Proxy a vsock port to a unix domain socket in the guest, or vice versa.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_ProxyVsockResponse` message.
        func proxyVsock(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_ProxyVsockResponse>

        /// Handle the "StopVsockProxy" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Stop a vsock proxy to a unix domain socket.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_StopVsockProxyRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_StopVsockProxyResponse` message.
        func stopVsockProxy(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_StopVsockProxyRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_StopVsockProxyResponse>

        /// Handle the "IpLinkSet" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Set the link state of a network interface.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_IpLinkSetResponse` message.
        func ipLinkSet(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_IpLinkSetResponse>

        /// Handle the "IpAddrAdd" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Add an IPv4 address to a network interface.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_IpAddrAddResponse` message.
        func ipAddrAdd(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_IpAddrAddResponse>

        /// Handle the "IpRouteAddLink" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Add an IP route for a network interface.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkResponse` message.
        func ipRouteAddLink(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkResponse>

        /// Handle the "IpRouteAddDefault" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Add an IP route for a network interface.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultResponse` message.
        func ipRouteAddDefault(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultResponse>

        /// Handle the "ConfigureDns" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Configure DNS resolver.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_ConfigureDnsResponse` message.
        func configureDns(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_ConfigureDnsResponse>

        /// Handle the "ConfigureHosts" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Configure /etc/hosts.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_ConfigureHostsResponse` message.
        func configureHosts(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_ConfigureHostsResponse>

        /// Handle the "Sync" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Perform the sync syscall.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_SyncRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_SyncResponse` message.
        func sync(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_SyncRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_SyncResponse>

        /// Handle the "Kill" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Send a signal to a process via the PID.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_KillRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A response containing a single `Com_Apple_Containerization_Sandbox_V3_KillResponse` message.
        func kill(
            request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_KillRequest>,
            context: GRPCCore.ServerContext
        ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_KillResponse>
    }

    /// Simple service protocol for the "com.apple.containerization.sandbox.v3.SandboxContext" service.
    ///
    /// This is the highest level protocol for the service. The API is the easiest to use but
    /// doesn't provide access to request or response metadata. If you need access to these
    /// then use ``ServiceProtocol`` instead.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Context for interacting with a container's runtime environment.
    public protocol SimpleServiceProtocol: Com_Apple_Containerization_Sandbox_V3_SandboxContext.ServiceProtocol {
        /// Handle the "Mount" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Mount a filesystem.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_MountRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_MountResponse` to respond with.
        func mount(
            request: Com_Apple_Containerization_Sandbox_V3_MountRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_MountResponse

        /// Handle the "Umount" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Unmount a filesystem.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_UmountRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_UmountResponse` to respond with.
        func umount(
            request: Com_Apple_Containerization_Sandbox_V3_UmountRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_UmountResponse

        /// Handle the "Setenv" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Set an environment variable on the init process.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_SetenvRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_SetenvResponse` to respond with.
        func setenv(
            request: Com_Apple_Containerization_Sandbox_V3_SetenvRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_SetenvResponse

        /// Handle the "Getenv" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Get an environment variable from the init process.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_GetenvRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_GetenvResponse` to respond with.
        func getenv(
            request: Com_Apple_Containerization_Sandbox_V3_GetenvRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_GetenvResponse

        /// Handle the "Mkdir" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Create a new directory inside the sandbox.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_MkdirRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_MkdirResponse` to respond with.
        func mkdir(
            request: Com_Apple_Containerization_Sandbox_V3_MkdirRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_MkdirResponse

        /// Handle the "Sysctl" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Set sysctls in the context of the sandbox.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_SysctlRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_SysctlResponse` to respond with.
        func sysctl(
            request: Com_Apple_Containerization_Sandbox_V3_SysctlRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_SysctlResponse

        /// Handle the "SetTime" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Set time in the guest.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_SetTimeRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_SetTimeResponse` to respond with.
        func setTime(
            request: Com_Apple_Containerization_Sandbox_V3_SetTimeRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_SetTimeResponse

        /// Handle the "SetupEmulator" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Set up an emulator in the guest for a specific binary format.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_SetupEmulatorResponse` to respond with.
        func setupEmulator(
            request: Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_SetupEmulatorResponse

        /// Handle the "WriteFile" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Write data to an existing or new file.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_WriteFileRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_WriteFileResponse` to respond with.
        func writeFile(
            request: Com_Apple_Containerization_Sandbox_V3_WriteFileRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_WriteFileResponse

        /// Handle the "Copy" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Copy a file or directory between the host and guest.
        /// > Data transfer happens over a dedicated vsock connection;
        /// > the gRPC stream is used only for control/metadata.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_CopyRequest` message.
        ///   - response: A response stream of `Com_Apple_Containerization_Sandbox_V3_CopyResponse` messages.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        func copy(
            request: Com_Apple_Containerization_Sandbox_V3_CopyRequest,
            response: GRPCCore.RPCWriter<Com_Apple_Containerization_Sandbox_V3_CopyResponse>,
            context: GRPCCore.ServerContext
        ) async throws

        /// Handle the "Stat" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Stat a path in the guest filesystem.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_StatRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_StatResponse` to respond with.
        func stat(
            request: Com_Apple_Containerization_Sandbox_V3_StatRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_StatResponse

        /// Handle the "FilesystemOperation" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Perform a filesystem operation on a mounted filesystem.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_FilesystemOperationResponse` to respond with.
        func filesystemOperation(
            request: Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_FilesystemOperationResponse

        /// Handle the "CreateProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Create a new process inside the container.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_CreateProcessResponse` to respond with.
        func createProcess(
            request: Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_CreateProcessResponse

        /// Handle the "DeleteProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Delete an existing process inside the container.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_DeleteProcessResponse` to respond with.
        func deleteProcess(
            request: Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_DeleteProcessResponse

        /// Handle the "StartProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Start the provided process.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_StartProcessRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_StartProcessResponse` to respond with.
        func startProcess(
            request: Com_Apple_Containerization_Sandbox_V3_StartProcessRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_StartProcessResponse

        /// Handle the "KillProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Send a signal to the provided process.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_KillProcessRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_KillProcessResponse` to respond with.
        func killProcess(
            request: Com_Apple_Containerization_Sandbox_V3_KillProcessRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_KillProcessResponse

        /// Handle the "WaitProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Wait for a process to exit and return the exit code.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_WaitProcessResponse` to respond with.
        func waitProcess(
            request: Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_WaitProcessResponse

        /// Handle the "ResizeProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Resize the tty of a given process. This will error if the process does
        /// > not have a pty allocated.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_ResizeProcessResponse` to respond with.
        func resizeProcess(
            request: Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_ResizeProcessResponse

        /// Handle the "CloseProcessStdin" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Close IO for a given process.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinResponse` to respond with.
        func closeProcessStdin(
            request: Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinResponse

        /// Handle the "ContainerStatistics" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Get statistics for containers.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsResponse` to respond with.
        func containerStatistics(
            request: Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsResponse

        /// Handle the "ProxyVsock" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Proxy a vsock port to a unix domain socket in the guest, or vice versa.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_ProxyVsockResponse` to respond with.
        func proxyVsock(
            request: Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_ProxyVsockResponse

        /// Handle the "StopVsockProxy" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Stop a vsock proxy to a unix domain socket.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_StopVsockProxyRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_StopVsockProxyResponse` to respond with.
        func stopVsockProxy(
            request: Com_Apple_Containerization_Sandbox_V3_StopVsockProxyRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_StopVsockProxyResponse

        /// Handle the "IpLinkSet" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Set the link state of a network interface.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_IpLinkSetResponse` to respond with.
        func ipLinkSet(
            request: Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_IpLinkSetResponse

        /// Handle the "IpAddrAdd" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Add an IPv4 address to a network interface.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_IpAddrAddResponse` to respond with.
        func ipAddrAdd(
            request: Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_IpAddrAddResponse

        /// Handle the "IpRouteAddLink" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Add an IP route for a network interface.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkResponse` to respond with.
        func ipRouteAddLink(
            request: Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkResponse

        /// Handle the "IpRouteAddDefault" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Add an IP route for a network interface.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultResponse` to respond with.
        func ipRouteAddDefault(
            request: Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultResponse

        /// Handle the "ConfigureDns" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Configure DNS resolver.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_ConfigureDnsResponse` to respond with.
        func configureDns(
            request: Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_ConfigureDnsResponse

        /// Handle the "ConfigureHosts" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Configure /etc/hosts.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_ConfigureHostsResponse` to respond with.
        func configureHosts(
            request: Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_ConfigureHostsResponse

        /// Handle the "Sync" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Perform the sync syscall.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_SyncRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_SyncResponse` to respond with.
        func sync(
            request: Com_Apple_Containerization_Sandbox_V3_SyncRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_SyncResponse

        /// Handle the "Kill" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Send a signal to a process via the PID.
        ///
        /// - Parameters:
        ///   - request: A `Com_Apple_Containerization_Sandbox_V3_KillRequest` message.
        ///   - context: Context providing information about the RPC.
        /// - Throws: Any error which occurred during the processing of the request. Thrown errors
        ///     of type `RPCError` are mapped to appropriate statuses. All other errors are converted
        ///     to an internal error.
        /// - Returns: A `Com_Apple_Containerization_Sandbox_V3_KillResponse` to respond with.
        func kill(
            request: Com_Apple_Containerization_Sandbox_V3_KillRequest,
            context: GRPCCore.ServerContext
        ) async throws -> Com_Apple_Containerization_Sandbox_V3_KillResponse
    }
}

// Default implementation of 'registerMethods(with:)'.
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension Com_Apple_Containerization_Sandbox_V3_SandboxContext.StreamingServiceProtocol {
    public func registerMethods<Transport>(with router: inout GRPCCore.RPCRouter<Transport>) where Transport: GRPCCore.ServerTransport {
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.Mount.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_MountRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_MountResponse>(),
            handler: { request, context in
                try await self.mount(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.Umount.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_UmountRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_UmountResponse>(),
            handler: { request, context in
                try await self.umount(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.Setenv.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_SetenvRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_SetenvResponse>(),
            handler: { request, context in
                try await self.setenv(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.Getenv.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_GetenvRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_GetenvResponse>(),
            handler: { request, context in
                try await self.getenv(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.Mkdir.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_MkdirRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_MkdirResponse>(),
            handler: { request, context in
                try await self.mkdir(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.Sysctl.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_SysctlRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_SysctlResponse>(),
            handler: { request, context in
                try await self.sysctl(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.SetTime.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_SetTimeRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_SetTimeResponse>(),
            handler: { request, context in
                try await self.setTime(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.SetupEmulator.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_SetupEmulatorResponse>(),
            handler: { request, context in
                try await self.setupEmulator(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.WriteFile.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_WriteFileRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_WriteFileResponse>(),
            handler: { request, context in
                try await self.writeFile(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.Copy.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_CopyRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_CopyResponse>(),
            handler: { request, context in
                try await self.copy(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.Stat.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_StatRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_StatResponse>(),
            handler: { request, context in
                try await self.stat(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.FilesystemOperation.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_FilesystemOperationResponse>(),
            handler: { request, context in
                try await self.filesystemOperation(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.CreateProcess.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_CreateProcessResponse>(),
            handler: { request, context in
                try await self.createProcess(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.DeleteProcess.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_DeleteProcessResponse>(),
            handler: { request, context in
                try await self.deleteProcess(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.StartProcess.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_StartProcessRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_StartProcessResponse>(),
            handler: { request, context in
                try await self.startProcess(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.KillProcess.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_KillProcessRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_KillProcessResponse>(),
            handler: { request, context in
                try await self.killProcess(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.WaitProcess.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_WaitProcessResponse>(),
            handler: { request, context in
                try await self.waitProcess(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.ResizeProcess.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_ResizeProcessResponse>(),
            handler: { request, context in
                try await self.resizeProcess(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.CloseProcessStdin.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinResponse>(),
            handler: { request, context in
                try await self.closeProcessStdin(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.ContainerStatistics.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsResponse>(),
            handler: { request, context in
                try await self.containerStatistics(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.ProxyVsock.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_ProxyVsockResponse>(),
            handler: { request, context in
                try await self.proxyVsock(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.StopVsockProxy.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_StopVsockProxyRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_StopVsockProxyResponse>(),
            handler: { request, context in
                try await self.stopVsockProxy(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.IpLinkSet.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_IpLinkSetResponse>(),
            handler: { request, context in
                try await self.ipLinkSet(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.IpAddrAdd.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_IpAddrAddResponse>(),
            handler: { request, context in
                try await self.ipAddrAdd(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.IpRouteAddLink.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkResponse>(),
            handler: { request, context in
                try await self.ipRouteAddLink(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.IpRouteAddDefault.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultResponse>(),
            handler: { request, context in
                try await self.ipRouteAddDefault(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.ConfigureDns.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_ConfigureDnsResponse>(),
            handler: { request, context in
                try await self.configureDns(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.ConfigureHosts.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_ConfigureHostsResponse>(),
            handler: { request, context in
                try await self.configureHosts(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.Sync.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_SyncRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_SyncResponse>(),
            handler: { request, context in
                try await self.sync(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.Kill.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_KillRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_KillResponse>(),
            handler: { request, context in
                try await self.kill(
                    request: request,
                    context: context
                )
            }
        )
    }
}

// Default implementation of streaming methods from 'StreamingServiceProtocol'.
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension Com_Apple_Containerization_Sandbox_V3_SandboxContext.ServiceProtocol {
    public func mount(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_MountRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_MountResponse> {
        let response = try await self.mount(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func umount(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_UmountRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_UmountResponse> {
        let response = try await self.umount(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func setenv(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_SetenvRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_SetenvResponse> {
        let response = try await self.setenv(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func getenv(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_GetenvRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_GetenvResponse> {
        let response = try await self.getenv(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func mkdir(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_MkdirRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_MkdirResponse> {
        let response = try await self.mkdir(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func sysctl(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_SysctlRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_SysctlResponse> {
        let response = try await self.sysctl(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func setTime(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_SetTimeRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_SetTimeResponse> {
        let response = try await self.setTime(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func setupEmulator(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_SetupEmulatorResponse> {
        let response = try await self.setupEmulator(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func writeFile(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_WriteFileRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_WriteFileResponse> {
        let response = try await self.writeFile(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func copy(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_CopyRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_CopyResponse> {
        let response = try await self.copy(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return response
    }

    public func stat(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_StatRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_StatResponse> {
        let response = try await self.stat(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func filesystemOperation(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_FilesystemOperationResponse> {
        let response = try await self.filesystemOperation(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func createProcess(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_CreateProcessResponse> {
        let response = try await self.createProcess(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func deleteProcess(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_DeleteProcessResponse> {
        let response = try await self.deleteProcess(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func startProcess(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_StartProcessRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_StartProcessResponse> {
        let response = try await self.startProcess(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func killProcess(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_KillProcessRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_KillProcessResponse> {
        let response = try await self.killProcess(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func waitProcess(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_WaitProcessResponse> {
        let response = try await self.waitProcess(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func resizeProcess(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_ResizeProcessResponse> {
        let response = try await self.resizeProcess(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func closeProcessStdin(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinResponse> {
        let response = try await self.closeProcessStdin(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func containerStatistics(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsResponse> {
        let response = try await self.containerStatistics(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func proxyVsock(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_ProxyVsockResponse> {
        let response = try await self.proxyVsock(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func stopVsockProxy(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_StopVsockProxyRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_StopVsockProxyResponse> {
        let response = try await self.stopVsockProxy(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func ipLinkSet(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_IpLinkSetResponse> {
        let response = try await self.ipLinkSet(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func ipAddrAdd(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_IpAddrAddResponse> {
        let response = try await self.ipAddrAdd(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func ipRouteAddLink(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkResponse> {
        let response = try await self.ipRouteAddLink(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func ipRouteAddDefault(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultResponse> {
        let response = try await self.ipRouteAddDefault(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func configureDns(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_ConfigureDnsResponse> {
        let response = try await self.configureDns(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func configureHosts(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_ConfigureHostsResponse> {
        let response = try await self.configureHosts(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func sync(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_SyncRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_SyncResponse> {
        let response = try await self.sync(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }

    public func kill(
        request: GRPCCore.StreamingServerRequest<Com_Apple_Containerization_Sandbox_V3_KillRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_KillResponse> {
        let response = try await self.kill(
            request: GRPCCore.ServerRequest(stream: request),
            context: context
        )
        return GRPCCore.StreamingServerResponse(single: response)
    }
}

// Default implementation of methods from 'ServiceProtocol'.
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension Com_Apple_Containerization_Sandbox_V3_SandboxContext.SimpleServiceProtocol {
    public func mount(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_MountRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_MountResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_MountResponse>(
            message: try await self.mount(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func umount(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_UmountRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_UmountResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_UmountResponse>(
            message: try await self.umount(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func setenv(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_SetenvRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_SetenvResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_SetenvResponse>(
            message: try await self.setenv(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func getenv(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_GetenvRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_GetenvResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_GetenvResponse>(
            message: try await self.getenv(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func mkdir(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_MkdirRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_MkdirResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_MkdirResponse>(
            message: try await self.mkdir(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func sysctl(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_SysctlRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_SysctlResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_SysctlResponse>(
            message: try await self.sysctl(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func setTime(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_SetTimeRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_SetTimeResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_SetTimeResponse>(
            message: try await self.setTime(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func setupEmulator(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_SetupEmulatorResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_SetupEmulatorResponse>(
            message: try await self.setupEmulator(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func writeFile(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_WriteFileRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_WriteFileResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_WriteFileResponse>(
            message: try await self.writeFile(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func copy(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_CopyRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_CopyResponse> {
        return GRPCCore.StreamingServerResponse<Com_Apple_Containerization_Sandbox_V3_CopyResponse>(
            metadata: [:],
            producer: { writer in
                try await self.copy(
                    request: request.message,
                    response: writer,
                    context: context
                )
                return [:]
            }
        )
    }

    public func stat(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_StatRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_StatResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_StatResponse>(
            message: try await self.stat(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func filesystemOperation(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_FilesystemOperationResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_FilesystemOperationResponse>(
            message: try await self.filesystemOperation(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func createProcess(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_CreateProcessResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_CreateProcessResponse>(
            message: try await self.createProcess(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func deleteProcess(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_DeleteProcessResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_DeleteProcessResponse>(
            message: try await self.deleteProcess(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func startProcess(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_StartProcessRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_StartProcessResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_StartProcessResponse>(
            message: try await self.startProcess(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func killProcess(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_KillProcessRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_KillProcessResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_KillProcessResponse>(
            message: try await self.killProcess(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func waitProcess(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_WaitProcessResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_WaitProcessResponse>(
            message: try await self.waitProcess(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func resizeProcess(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_ResizeProcessResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_ResizeProcessResponse>(
            message: try await self.resizeProcess(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func closeProcessStdin(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinResponse>(
            message: try await self.closeProcessStdin(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func containerStatistics(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsResponse>(
            message: try await self.containerStatistics(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func proxyVsock(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_ProxyVsockResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_ProxyVsockResponse>(
            message: try await self.proxyVsock(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func stopVsockProxy(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_StopVsockProxyRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_StopVsockProxyResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_StopVsockProxyResponse>(
            message: try await self.stopVsockProxy(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func ipLinkSet(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_IpLinkSetResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_IpLinkSetResponse>(
            message: try await self.ipLinkSet(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func ipAddrAdd(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_IpAddrAddResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_IpAddrAddResponse>(
            message: try await self.ipAddrAdd(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func ipRouteAddLink(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkResponse>(
            message: try await self.ipRouteAddLink(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func ipRouteAddDefault(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultResponse>(
            message: try await self.ipRouteAddDefault(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func configureDns(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_ConfigureDnsResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_ConfigureDnsResponse>(
            message: try await self.configureDns(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func configureHosts(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_ConfigureHostsResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_ConfigureHostsResponse>(
            message: try await self.configureHosts(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func sync(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_SyncRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_SyncResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_SyncResponse>(
            message: try await self.sync(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }

    public func kill(
        request: GRPCCore.ServerRequest<Com_Apple_Containerization_Sandbox_V3_KillRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_KillResponse> {
        return GRPCCore.ServerResponse<Com_Apple_Containerization_Sandbox_V3_KillResponse>(
            message: try await self.kill(
                request: request.message,
                context: context
            ),
            metadata: [:]
        )
    }
}

// MARK: com.apple.containerization.sandbox.v3.SandboxContext (client)

@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension Com_Apple_Containerization_Sandbox_V3_SandboxContext {
    /// Generated client protocol for the "com.apple.containerization.sandbox.v3.SandboxContext" service.
    ///
    /// You don't need to implement this protocol directly, use the generated
    /// implementation, ``Client``.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Context for interacting with a container's runtime environment.
    public protocol ClientProtocol: Sendable {
        /// Call the "Mount" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Mount a filesystem.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_MountRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_MountRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_MountResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func mount<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_MountRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_MountRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_MountResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_MountResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "Umount" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Unmount a filesystem.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_UmountRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_UmountRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_UmountResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func umount<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_UmountRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_UmountRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_UmountResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_UmountResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "Setenv" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Set an environment variable on the init process.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_SetenvRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_SetenvRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_SetenvResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func setenv<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_SetenvRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_SetenvRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_SetenvResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_SetenvResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "Getenv" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Get an environment variable from the init process.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_GetenvRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_GetenvRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_GetenvResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func getenv<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_GetenvRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_GetenvRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_GetenvResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_GetenvResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "Mkdir" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Create a new directory inside the sandbox.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_MkdirRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_MkdirRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_MkdirResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func mkdir<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_MkdirRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_MkdirRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_MkdirResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_MkdirResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "Sysctl" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Set sysctls in the context of the sandbox.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_SysctlRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_SysctlRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_SysctlResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func sysctl<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_SysctlRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_SysctlRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_SysctlResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_SysctlResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "SetTime" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Set time in the guest.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_SetTimeRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_SetTimeRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_SetTimeResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func setTime<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_SetTimeRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_SetTimeRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_SetTimeResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_SetTimeResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "SetupEmulator" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Set up an emulator in the guest for a specific binary format.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_SetupEmulatorResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func setupEmulator<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_SetupEmulatorResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_SetupEmulatorResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "WriteFile" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Write data to an existing or new file.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_WriteFileRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_WriteFileRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_WriteFileResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func writeFile<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_WriteFileRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_WriteFileRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_WriteFileResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_WriteFileResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "Copy" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Copy a file or directory between the host and guest.
        /// > Data transfer happens over a dedicated vsock connection;
        /// > the gRPC stream is used only for control/metadata.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_CopyRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_CopyRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_CopyResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func copy<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_CopyRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_CopyRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_CopyResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<Com_Apple_Containerization_Sandbox_V3_CopyResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "Stat" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Stat a path in the guest filesystem.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_StatRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_StatRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_StatResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func stat<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_StatRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_StatRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_StatResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_StatResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "FilesystemOperation" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Perform a filesystem operation on a mounted filesystem.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_FilesystemOperationResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func filesystemOperation<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_FilesystemOperationResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_FilesystemOperationResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "CreateProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Create a new process inside the container.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_CreateProcessResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func createProcess<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_CreateProcessResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_CreateProcessResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "DeleteProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Delete an existing process inside the container.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_DeleteProcessResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func deleteProcess<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_DeleteProcessResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_DeleteProcessResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "StartProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Start the provided process.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_StartProcessRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_StartProcessRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_StartProcessResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func startProcess<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_StartProcessRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_StartProcessRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_StartProcessResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_StartProcessResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "KillProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Send a signal to the provided process.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_KillProcessRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_KillProcessRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_KillProcessResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func killProcess<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_KillProcessRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_KillProcessRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_KillProcessResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_KillProcessResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "WaitProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Wait for a process to exit and return the exit code.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_WaitProcessResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func waitProcess<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_WaitProcessResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_WaitProcessResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "ResizeProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Resize the tty of a given process. This will error if the process does
        /// > not have a pty allocated.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_ResizeProcessResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func resizeProcess<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_ResizeProcessResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_ResizeProcessResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "CloseProcessStdin" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Close IO for a given process.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func closeProcessStdin<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "ContainerStatistics" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Get statistics for containers.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func containerStatistics<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "ProxyVsock" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Proxy a vsock port to a unix domain socket in the guest, or vice versa.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_ProxyVsockResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func proxyVsock<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_ProxyVsockResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_ProxyVsockResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "StopVsockProxy" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Stop a vsock proxy to a unix domain socket.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_StopVsockProxyRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_StopVsockProxyRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_StopVsockProxyResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func stopVsockProxy<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_StopVsockProxyRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_StopVsockProxyRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_StopVsockProxyResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_StopVsockProxyResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "IpLinkSet" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Set the link state of a network interface.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_IpLinkSetResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func ipLinkSet<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_IpLinkSetResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_IpLinkSetResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "IpAddrAdd" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Add an IPv4 address to a network interface.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_IpAddrAddResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func ipAddrAdd<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_IpAddrAddResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_IpAddrAddResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "IpRouteAddLink" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Add an IP route for a network interface.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func ipRouteAddLink<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "IpRouteAddDefault" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Add an IP route for a network interface.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func ipRouteAddDefault<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "ConfigureDns" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Configure DNS resolver.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_ConfigureDnsResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func configureDns<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_ConfigureDnsResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_ConfigureDnsResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "ConfigureHosts" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Configure /etc/hosts.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_ConfigureHostsResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func configureHosts<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_ConfigureHostsResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_ConfigureHostsResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "Sync" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Perform the sync syscall.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_SyncRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_SyncRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_SyncResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func sync<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_SyncRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_SyncRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_SyncResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_SyncResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable

        /// Call the "Kill" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Send a signal to a process via the PID.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_KillRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_KillRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_KillResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        func kill<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_KillRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_KillRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_KillResponse>,
            options: GRPCCore.CallOptions,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_KillResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable
    }

    /// Generated client for the "com.apple.containerization.sandbox.v3.SandboxContext" service.
    ///
    /// The ``Client`` provides an implementation of ``ClientProtocol`` which wraps
    /// a `GRPCCore.GRPCCClient`. The underlying `GRPCClient` provides the long-lived
    /// means of communication with the remote peer.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Context for interacting with a container's runtime environment.
    public struct Client<Transport>: ClientProtocol where Transport: GRPCCore.ClientTransport {
        private let client: GRPCCore.GRPCClient<Transport>

        /// Creates a new client wrapping the provided `GRPCCore.GRPCClient`.
        ///
        /// - Parameters:
        ///   - client: A `GRPCCore.GRPCClient` providing a communication channel to the service.
        public init(wrapping client: GRPCCore.GRPCClient<Transport>) {
            self.client = client
        }

        /// Call the "Mount" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Mount a filesystem.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_MountRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_MountRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_MountResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func mount<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_MountRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_MountRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_MountResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_MountResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.Mount.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "Umount" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Unmount a filesystem.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_UmountRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_UmountRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_UmountResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func umount<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_UmountRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_UmountRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_UmountResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_UmountResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.Umount.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "Setenv" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Set an environment variable on the init process.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_SetenvRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_SetenvRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_SetenvResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func setenv<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_SetenvRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_SetenvRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_SetenvResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_SetenvResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.Setenv.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "Getenv" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Get an environment variable from the init process.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_GetenvRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_GetenvRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_GetenvResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func getenv<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_GetenvRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_GetenvRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_GetenvResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_GetenvResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.Getenv.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "Mkdir" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Create a new directory inside the sandbox.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_MkdirRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_MkdirRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_MkdirResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func mkdir<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_MkdirRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_MkdirRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_MkdirResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_MkdirResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.Mkdir.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "Sysctl" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Set sysctls in the context of the sandbox.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_SysctlRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_SysctlRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_SysctlResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func sysctl<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_SysctlRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_SysctlRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_SysctlResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_SysctlResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.Sysctl.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "SetTime" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Set time in the guest.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_SetTimeRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_SetTimeRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_SetTimeResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func setTime<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_SetTimeRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_SetTimeRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_SetTimeResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_SetTimeResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.SetTime.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "SetupEmulator" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Set up an emulator in the guest for a specific binary format.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_SetupEmulatorResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func setupEmulator<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_SetupEmulatorResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_SetupEmulatorResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.SetupEmulator.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "WriteFile" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Write data to an existing or new file.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_WriteFileRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_WriteFileRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_WriteFileResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func writeFile<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_WriteFileRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_WriteFileRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_WriteFileResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_WriteFileResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.WriteFile.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "Copy" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Copy a file or directory between the host and guest.
        /// > Data transfer happens over a dedicated vsock connection;
        /// > the gRPC stream is used only for control/metadata.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_CopyRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_CopyRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_CopyResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func copy<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_CopyRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_CopyRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_CopyResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<Com_Apple_Containerization_Sandbox_V3_CopyResponse>) async throws -> Result
        ) async throws -> Result where Result: Sendable {
            try await self.client.serverStreaming(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.Copy.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "Stat" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Stat a path in the guest filesystem.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_StatRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_StatRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_StatResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func stat<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_StatRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_StatRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_StatResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_StatResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.Stat.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "FilesystemOperation" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Perform a filesystem operation on a mounted filesystem.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_FilesystemOperationResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func filesystemOperation<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_FilesystemOperationResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_FilesystemOperationResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.FilesystemOperation.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "CreateProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Create a new process inside the container.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_CreateProcessResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func createProcess<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_CreateProcessResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_CreateProcessResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.CreateProcess.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "DeleteProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Delete an existing process inside the container.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_DeleteProcessResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func deleteProcess<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_DeleteProcessResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_DeleteProcessResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.DeleteProcess.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "StartProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Start the provided process.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_StartProcessRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_StartProcessRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_StartProcessResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func startProcess<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_StartProcessRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_StartProcessRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_StartProcessResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_StartProcessResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.StartProcess.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "KillProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Send a signal to the provided process.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_KillProcessRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_KillProcessRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_KillProcessResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func killProcess<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_KillProcessRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_KillProcessRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_KillProcessResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_KillProcessResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.KillProcess.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "WaitProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Wait for a process to exit and return the exit code.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_WaitProcessResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func waitProcess<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_WaitProcessResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_WaitProcessResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.WaitProcess.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "ResizeProcess" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Resize the tty of a given process. This will error if the process does
        /// > not have a pty allocated.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_ResizeProcessResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func resizeProcess<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_ResizeProcessResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_ResizeProcessResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.ResizeProcess.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "CloseProcessStdin" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Close IO for a given process.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func closeProcessStdin<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.CloseProcessStdin.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "ContainerStatistics" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Get statistics for containers.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func containerStatistics<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.ContainerStatistics.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "ProxyVsock" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Proxy a vsock port to a unix domain socket in the guest, or vice versa.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_ProxyVsockResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func proxyVsock<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_ProxyVsockResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_ProxyVsockResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.ProxyVsock.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "StopVsockProxy" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Stop a vsock proxy to a unix domain socket.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_StopVsockProxyRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_StopVsockProxyRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_StopVsockProxyResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func stopVsockProxy<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_StopVsockProxyRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_StopVsockProxyRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_StopVsockProxyResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_StopVsockProxyResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.StopVsockProxy.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "IpLinkSet" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Set the link state of a network interface.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_IpLinkSetResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func ipLinkSet<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_IpLinkSetResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_IpLinkSetResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.IpLinkSet.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "IpAddrAdd" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Add an IPv4 address to a network interface.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_IpAddrAddResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func ipAddrAdd<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_IpAddrAddResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_IpAddrAddResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.IpAddrAdd.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "IpRouteAddLink" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Add an IP route for a network interface.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func ipRouteAddLink<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.IpRouteAddLink.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "IpRouteAddDefault" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Add an IP route for a network interface.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func ipRouteAddDefault<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.IpRouteAddDefault.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "ConfigureDns" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Configure DNS resolver.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_ConfigureDnsResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func configureDns<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_ConfigureDnsResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_ConfigureDnsResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.ConfigureDns.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "ConfigureHosts" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Configure /etc/hosts.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_ConfigureHostsResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func configureHosts<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_ConfigureHostsResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_ConfigureHostsResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.ConfigureHosts.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "Sync" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Perform the sync syscall.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_SyncRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_SyncRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_SyncResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func sync<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_SyncRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_SyncRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_SyncResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_SyncResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.Sync.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }

        /// Call the "Kill" method.
        ///
        /// > Source IDL Documentation:
        /// >
        /// > Send a signal to a process via the PID.
        ///
        /// - Parameters:
        ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_KillRequest` message.
        ///   - serializer: A serializer for `Com_Apple_Containerization_Sandbox_V3_KillRequest` messages.
        ///   - deserializer: A deserializer for `Com_Apple_Containerization_Sandbox_V3_KillResponse` messages.
        ///   - options: Options to apply to this RPC.
        ///   - handleResponse: A closure which handles the response, the result of which is
        ///       returned to the caller. Returning from the closure will cancel the RPC if it
        ///       hasn't already finished.
        /// - Returns: The result of `handleResponse`.
        public func kill<Result>(
            request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_KillRequest>,
            serializer: some GRPCCore.MessageSerializer<Com_Apple_Containerization_Sandbox_V3_KillRequest>,
            deserializer: some GRPCCore.MessageDeserializer<Com_Apple_Containerization_Sandbox_V3_KillResponse>,
            options: GRPCCore.CallOptions = .defaults,
            onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_KillResponse>) async throws -> Result = { response in
                try response.message
            }
        ) async throws -> Result where Result: Sendable {
            try await self.client.unary(
                request: request,
                descriptor: Com_Apple_Containerization_Sandbox_V3_SandboxContext.Method.Kill.descriptor,
                serializer: serializer,
                deserializer: deserializer,
                options: options,
                onResponse: handleResponse
            )
        }
    }
}

// Helpers providing default arguments to 'ClientProtocol' methods.
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension Com_Apple_Containerization_Sandbox_V3_SandboxContext.ClientProtocol {
    /// Call the "Mount" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Mount a filesystem.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_MountRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func mount<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_MountRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_MountResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.mount(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_MountRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_MountResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "Umount" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Unmount a filesystem.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_UmountRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func umount<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_UmountRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_UmountResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.umount(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_UmountRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_UmountResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "Setenv" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Set an environment variable on the init process.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_SetenvRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func setenv<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_SetenvRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_SetenvResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.setenv(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_SetenvRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_SetenvResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "Getenv" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Get an environment variable from the init process.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_GetenvRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func getenv<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_GetenvRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_GetenvResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.getenv(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_GetenvRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_GetenvResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "Mkdir" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Create a new directory inside the sandbox.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_MkdirRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func mkdir<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_MkdirRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_MkdirResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.mkdir(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_MkdirRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_MkdirResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "Sysctl" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Set sysctls in the context of the sandbox.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_SysctlRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func sysctl<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_SysctlRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_SysctlResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.sysctl(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_SysctlRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_SysctlResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "SetTime" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Set time in the guest.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_SetTimeRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func setTime<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_SetTimeRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_SetTimeResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.setTime(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_SetTimeRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_SetTimeResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "SetupEmulator" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Set up an emulator in the guest for a specific binary format.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func setupEmulator<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_SetupEmulatorResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.setupEmulator(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_SetupEmulatorResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "WriteFile" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Write data to an existing or new file.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_WriteFileRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func writeFile<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_WriteFileRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_WriteFileResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.writeFile(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_WriteFileRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_WriteFileResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "Copy" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Copy a file or directory between the host and guest.
    /// > Data transfer happens over a dedicated vsock connection;
    /// > the gRPC stream is used only for control/metadata.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_CopyRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func copy<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_CopyRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<Com_Apple_Containerization_Sandbox_V3_CopyResponse>) async throws -> Result
    ) async throws -> Result where Result: Sendable {
        try await self.copy(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_CopyRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_CopyResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "Stat" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Stat a path in the guest filesystem.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_StatRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func stat<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_StatRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_StatResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.stat(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_StatRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_StatResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "FilesystemOperation" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Perform a filesystem operation on a mounted filesystem.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func filesystemOperation<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_FilesystemOperationResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.filesystemOperation(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_FilesystemOperationResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "CreateProcess" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Create a new process inside the container.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func createProcess<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_CreateProcessResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.createProcess(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_CreateProcessResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "DeleteProcess" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Delete an existing process inside the container.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func deleteProcess<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_DeleteProcessResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.deleteProcess(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_DeleteProcessResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "StartProcess" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Start the provided process.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_StartProcessRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func startProcess<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_StartProcessRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_StartProcessResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.startProcess(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_StartProcessRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_StartProcessResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "KillProcess" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Send a signal to the provided process.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_KillProcessRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func killProcess<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_KillProcessRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_KillProcessResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.killProcess(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_KillProcessRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_KillProcessResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "WaitProcess" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Wait for a process to exit and return the exit code.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func waitProcess<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_WaitProcessResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.waitProcess(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_WaitProcessResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "ResizeProcess" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Resize the tty of a given process. This will error if the process does
    /// > not have a pty allocated.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func resizeProcess<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_ResizeProcessResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.resizeProcess(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_ResizeProcessResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "CloseProcessStdin" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Close IO for a given process.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func closeProcessStdin<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.closeProcessStdin(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "ContainerStatistics" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Get statistics for containers.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func containerStatistics<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.containerStatistics(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "ProxyVsock" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Proxy a vsock port to a unix domain socket in the guest, or vice versa.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func proxyVsock<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_ProxyVsockResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.proxyVsock(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_ProxyVsockResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "StopVsockProxy" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Stop a vsock proxy to a unix domain socket.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_StopVsockProxyRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func stopVsockProxy<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_StopVsockProxyRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_StopVsockProxyResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.stopVsockProxy(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_StopVsockProxyRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_StopVsockProxyResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "IpLinkSet" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Set the link state of a network interface.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func ipLinkSet<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_IpLinkSetResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.ipLinkSet(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_IpLinkSetResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "IpAddrAdd" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Add an IPv4 address to a network interface.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func ipAddrAdd<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_IpAddrAddResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.ipAddrAdd(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_IpAddrAddResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "IpRouteAddLink" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Add an IP route for a network interface.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func ipRouteAddLink<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.ipRouteAddLink(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "IpRouteAddDefault" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Add an IP route for a network interface.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func ipRouteAddDefault<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.ipRouteAddDefault(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "ConfigureDns" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Configure DNS resolver.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func configureDns<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_ConfigureDnsResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.configureDns(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_ConfigureDnsResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "ConfigureHosts" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Configure /etc/hosts.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func configureHosts<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_ConfigureHostsResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.configureHosts(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_ConfigureHostsResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "Sync" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Perform the sync syscall.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_SyncRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func sync<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_SyncRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_SyncResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.sync(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_SyncRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_SyncResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "Kill" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Send a signal to a process via the PID.
    ///
    /// - Parameters:
    ///   - request: A request containing a single `Com_Apple_Containerization_Sandbox_V3_KillRequest` message.
    ///   - options: Options to apply to this RPC.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func kill<Result>(
        request: GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_KillRequest>,
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_KillResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        try await self.kill(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Com_Apple_Containerization_Sandbox_V3_KillRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Com_Apple_Containerization_Sandbox_V3_KillResponse>(),
            options: options,
            onResponse: handleResponse
        )
    }
}

// Helpers providing sugared APIs for 'ClientProtocol' methods.
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension Com_Apple_Containerization_Sandbox_V3_SandboxContext.ClientProtocol {
    /// Call the "Mount" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Mount a filesystem.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func mount<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_MountRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_MountResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_MountRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.mount(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "Umount" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Unmount a filesystem.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func umount<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_UmountRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_UmountResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_UmountRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.umount(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "Setenv" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Set an environment variable on the init process.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func setenv<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_SetenvRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_SetenvResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_SetenvRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.setenv(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "Getenv" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Get an environment variable from the init process.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func getenv<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_GetenvRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_GetenvResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_GetenvRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.getenv(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "Mkdir" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Create a new directory inside the sandbox.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func mkdir<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_MkdirRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_MkdirResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_MkdirRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.mkdir(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "Sysctl" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Set sysctls in the context of the sandbox.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func sysctl<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_SysctlRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_SysctlResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_SysctlRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.sysctl(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "SetTime" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Set time in the guest.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func setTime<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_SetTimeRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_SetTimeResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_SetTimeRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.setTime(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "SetupEmulator" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Set up an emulator in the guest for a specific binary format.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func setupEmulator<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_SetupEmulatorResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_SetupEmulatorRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.setupEmulator(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "WriteFile" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Write data to an existing or new file.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func writeFile<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_WriteFileRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_WriteFileResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_WriteFileRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.writeFile(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "Copy" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Copy a file or directory between the host and guest.
    /// > Data transfer happens over a dedicated vsock connection;
    /// > the gRPC stream is used only for control/metadata.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func copy<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_CopyRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<Com_Apple_Containerization_Sandbox_V3_CopyResponse>) async throws -> Result
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_CopyRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.copy(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "Stat" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Stat a path in the guest filesystem.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func stat<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_StatRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_StatResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_StatRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.stat(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "FilesystemOperation" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Perform a filesystem operation on a mounted filesystem.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func filesystemOperation<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_FilesystemOperationResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_FilesystemOperationRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.filesystemOperation(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "CreateProcess" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Create a new process inside the container.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func createProcess<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_CreateProcessResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_CreateProcessRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.createProcess(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "DeleteProcess" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Delete an existing process inside the container.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func deleteProcess<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_DeleteProcessResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_DeleteProcessRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.deleteProcess(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "StartProcess" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Start the provided process.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func startProcess<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_StartProcessRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_StartProcessResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_StartProcessRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.startProcess(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "KillProcess" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Send a signal to the provided process.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func killProcess<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_KillProcessRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_KillProcessResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_KillProcessRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.killProcess(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "WaitProcess" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Wait for a process to exit and return the exit code.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func waitProcess<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_WaitProcessResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_WaitProcessRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.waitProcess(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "ResizeProcess" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Resize the tty of a given process. This will error if the process does
    /// > not have a pty allocated.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func resizeProcess<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_ResizeProcessResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_ResizeProcessRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.resizeProcess(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "CloseProcessStdin" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Close IO for a given process.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func closeProcessStdin<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_CloseProcessStdinRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.closeProcessStdin(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "ContainerStatistics" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Get statistics for containers.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func containerStatistics<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_ContainerStatisticsRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.containerStatistics(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "ProxyVsock" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Proxy a vsock port to a unix domain socket in the guest, or vice versa.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func proxyVsock<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_ProxyVsockResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_ProxyVsockRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.proxyVsock(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "StopVsockProxy" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Stop a vsock proxy to a unix domain socket.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func stopVsockProxy<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_StopVsockProxyRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_StopVsockProxyResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_StopVsockProxyRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.stopVsockProxy(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "IpLinkSet" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Set the link state of a network interface.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func ipLinkSet<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_IpLinkSetResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_IpLinkSetRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.ipLinkSet(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "IpAddrAdd" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Add an IPv4 address to a network interface.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func ipAddrAdd<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_IpAddrAddResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_IpAddrAddRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.ipAddrAdd(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "IpRouteAddLink" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Add an IP route for a network interface.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func ipRouteAddLink<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_IpRouteAddLinkRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.ipRouteAddLink(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "IpRouteAddDefault" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Add an IP route for a network interface.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func ipRouteAddDefault<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_IpRouteAddDefaultRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.ipRouteAddDefault(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "ConfigureDns" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Configure DNS resolver.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func configureDns<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_ConfigureDnsResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_ConfigureDnsRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.configureDns(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "ConfigureHosts" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Configure /etc/hosts.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func configureHosts<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_ConfigureHostsResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_ConfigureHostsRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.configureHosts(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "Sync" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Perform the sync syscall.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func sync<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_SyncRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_SyncResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_SyncRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.sync(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }

    /// Call the "Kill" method.
    ///
    /// > Source IDL Documentation:
    /// >
    /// > Send a signal to a process via the PID.
    ///
    /// - Parameters:
    ///   - message: request message to send.
    ///   - metadata: Additional metadata to send, defaults to empty.
    ///   - options: Options to apply to this RPC, defaults to `.defaults`.
    ///   - handleResponse: A closure which handles the response, the result of which is
    ///       returned to the caller. Returning from the closure will cancel the RPC if it
    ///       hasn't already finished.
    /// - Returns: The result of `handleResponse`.
    public func kill<Result>(
        _ message: Com_Apple_Containerization_Sandbox_V3_KillRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Com_Apple_Containerization_Sandbox_V3_KillResponse>) async throws -> Result = { response in
            try response.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest<Com_Apple_Containerization_Sandbox_V3_KillRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.kill(
            request: request,
            options: options,
            onResponse: handleResponse
        )
    }
}