# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
"""Client and server classes corresponding to protobuf-defined services."""

import grpc
import warnings

from . import openshell_pb2 as openshell__pb2
from . import sandbox_pb2 as sandbox__pb2

GRPC_GENERATED_VERSION = "1.78.0"
GRPC_VERSION = grpc.__version__
_version_not_supported = False

try:
    from grpc._utilities import first_version_is_lower

    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
except ImportError:
    _version_not_supported = True

if _version_not_supported:
    raise RuntimeError(
        f"The grpc package installed is at version {GRPC_VERSION},"
        + " but the generated code in openshell_pb2_grpc.py depends on"
        + f" grpcio>={GRPC_GENERATED_VERSION}."
        + f" Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}"
        + f" or downgrade your generated code using grpcio-tools<={GRPC_VERSION}."
    )


class OpenShellStub(object):
    """OpenShell service provides sandbox, provider, and runtime management capabilities."""

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.Health = channel.unary_unary(
            "/openshell.v1.OpenShell/Health",
            request_serializer=openshell__pb2.HealthRequest.SerializeToString,
            response_deserializer=openshell__pb2.HealthResponse.FromString,
            _registered_method=True,
        )
        self.CreateSandbox = channel.unary_unary(
            "/openshell.v1.OpenShell/CreateSandbox",
            request_serializer=openshell__pb2.CreateSandboxRequest.SerializeToString,
            response_deserializer=openshell__pb2.SandboxResponse.FromString,
            _registered_method=True,
        )
        self.GetSandbox = channel.unary_unary(
            "/openshell.v1.OpenShell/GetSandbox",
            request_serializer=openshell__pb2.GetSandboxRequest.SerializeToString,
            response_deserializer=openshell__pb2.SandboxResponse.FromString,
            _registered_method=True,
        )
        self.ListSandboxes = channel.unary_unary(
            "/openshell.v1.OpenShell/ListSandboxes",
            request_serializer=openshell__pb2.ListSandboxesRequest.SerializeToString,
            response_deserializer=openshell__pb2.ListSandboxesResponse.FromString,
            _registered_method=True,
        )
        self.DeleteSandbox = channel.unary_unary(
            "/openshell.v1.OpenShell/DeleteSandbox",
            request_serializer=openshell__pb2.DeleteSandboxRequest.SerializeToString,
            response_deserializer=openshell__pb2.DeleteSandboxResponse.FromString,
            _registered_method=True,
        )
        self.CreateSshSession = channel.unary_unary(
            "/openshell.v1.OpenShell/CreateSshSession",
            request_serializer=openshell__pb2.CreateSshSessionRequest.SerializeToString,
            response_deserializer=openshell__pb2.CreateSshSessionResponse.FromString,
            _registered_method=True,
        )
        self.RevokeSshSession = channel.unary_unary(
            "/openshell.v1.OpenShell/RevokeSshSession",
            request_serializer=openshell__pb2.RevokeSshSessionRequest.SerializeToString,
            response_deserializer=openshell__pb2.RevokeSshSessionResponse.FromString,
            _registered_method=True,
        )
        self.ExecSandbox = channel.unary_stream(
            "/openshell.v1.OpenShell/ExecSandbox",
            request_serializer=openshell__pb2.ExecSandboxRequest.SerializeToString,
            response_deserializer=openshell__pb2.ExecSandboxEvent.FromString,
            _registered_method=True,
        )
        self.CreateProvider = channel.unary_unary(
            "/openshell.v1.OpenShell/CreateProvider",
            request_serializer=openshell__pb2.CreateProviderRequest.SerializeToString,
            response_deserializer=openshell__pb2.ProviderResponse.FromString,
            _registered_method=True,
        )
        self.GetProvider = channel.unary_unary(
            "/openshell.v1.OpenShell/GetProvider",
            request_serializer=openshell__pb2.GetProviderRequest.SerializeToString,
            response_deserializer=openshell__pb2.ProviderResponse.FromString,
            _registered_method=True,
        )
        self.ListProviders = channel.unary_unary(
            "/openshell.v1.OpenShell/ListProviders",
            request_serializer=openshell__pb2.ListProvidersRequest.SerializeToString,
            response_deserializer=openshell__pb2.ListProvidersResponse.FromString,
            _registered_method=True,
        )
        self.UpdateProvider = channel.unary_unary(
            "/openshell.v1.OpenShell/UpdateProvider",
            request_serializer=openshell__pb2.UpdateProviderRequest.SerializeToString,
            response_deserializer=openshell__pb2.ProviderResponse.FromString,
            _registered_method=True,
        )
        self.DeleteProvider = channel.unary_unary(
            "/openshell.v1.OpenShell/DeleteProvider",
            request_serializer=openshell__pb2.DeleteProviderRequest.SerializeToString,
            response_deserializer=openshell__pb2.DeleteProviderResponse.FromString,
            _registered_method=True,
        )
        self.GetSandboxConfig = channel.unary_unary(
            "/openshell.v1.OpenShell/GetSandboxConfig",
            request_serializer=sandbox__pb2.GetSandboxConfigRequest.SerializeToString,
            response_deserializer=sandbox__pb2.GetSandboxConfigResponse.FromString,
            _registered_method=True,
        )
        self.GetGatewayConfig = channel.unary_unary(
            "/openshell.v1.OpenShell/GetGatewayConfig",
            request_serializer=sandbox__pb2.GetGatewayConfigRequest.SerializeToString,
            response_deserializer=sandbox__pb2.GetGatewayConfigResponse.FromString,
            _registered_method=True,
        )
        self.UpdateConfig = channel.unary_unary(
            "/openshell.v1.OpenShell/UpdateConfig",
            request_serializer=openshell__pb2.UpdateConfigRequest.SerializeToString,
            response_deserializer=openshell__pb2.UpdateConfigResponse.FromString,
            _registered_method=True,
        )
        self.GetSandboxPolicyStatus = channel.unary_unary(
            "/openshell.v1.OpenShell/GetSandboxPolicyStatus",
            request_serializer=openshell__pb2.GetSandboxPolicyStatusRequest.SerializeToString,
            response_deserializer=openshell__pb2.GetSandboxPolicyStatusResponse.FromString,
            _registered_method=True,
        )
        self.ListSandboxPolicies = channel.unary_unary(
            "/openshell.v1.OpenShell/ListSandboxPolicies",
            request_serializer=openshell__pb2.ListSandboxPoliciesRequest.SerializeToString,
            response_deserializer=openshell__pb2.ListSandboxPoliciesResponse.FromString,
            _registered_method=True,
        )
        self.ReportPolicyStatus = channel.unary_unary(
            "/openshell.v1.OpenShell/ReportPolicyStatus",
            request_serializer=openshell__pb2.ReportPolicyStatusRequest.SerializeToString,
            response_deserializer=openshell__pb2.ReportPolicyStatusResponse.FromString,
            _registered_method=True,
        )
        self.GetSandboxProviderEnvironment = channel.unary_unary(
            "/openshell.v1.OpenShell/GetSandboxProviderEnvironment",
            request_serializer=openshell__pb2.GetSandboxProviderEnvironmentRequest.SerializeToString,
            response_deserializer=openshell__pb2.GetSandboxProviderEnvironmentResponse.FromString,
            _registered_method=True,
        )
        self.GetSandboxLogs = channel.unary_unary(
            "/openshell.v1.OpenShell/GetSandboxLogs",
            request_serializer=openshell__pb2.GetSandboxLogsRequest.SerializeToString,
            response_deserializer=openshell__pb2.GetSandboxLogsResponse.FromString,
            _registered_method=True,
        )
        self.PushSandboxLogs = channel.stream_unary(
            "/openshell.v1.OpenShell/PushSandboxLogs",
            request_serializer=openshell__pb2.PushSandboxLogsRequest.SerializeToString,
            response_deserializer=openshell__pb2.PushSandboxLogsResponse.FromString,
            _registered_method=True,
        )
        self.WatchSandbox = channel.unary_stream(
            "/openshell.v1.OpenShell/WatchSandbox",
            request_serializer=openshell__pb2.WatchSandboxRequest.SerializeToString,
            response_deserializer=openshell__pb2.SandboxStreamEvent.FromString,
            _registered_method=True,
        )
        self.SubmitPolicyAnalysis = channel.unary_unary(
            "/openshell.v1.OpenShell/SubmitPolicyAnalysis",
            request_serializer=openshell__pb2.SubmitPolicyAnalysisRequest.SerializeToString,
            response_deserializer=openshell__pb2.SubmitPolicyAnalysisResponse.FromString,
            _registered_method=True,
        )
        self.GetDraftPolicy = channel.unary_unary(
            "/openshell.v1.OpenShell/GetDraftPolicy",
            request_serializer=openshell__pb2.GetDraftPolicyRequest.SerializeToString,
            response_deserializer=openshell__pb2.GetDraftPolicyResponse.FromString,
            _registered_method=True,
        )
        self.ApproveDraftChunk = channel.unary_unary(
            "/openshell.v1.OpenShell/ApproveDraftChunk",
            request_serializer=openshell__pb2.ApproveDraftChunkRequest.SerializeToString,
            response_deserializer=openshell__pb2.ApproveDraftChunkResponse.FromString,
            _registered_method=True,
        )
        self.RejectDraftChunk = channel.unary_unary(
            "/openshell.v1.OpenShell/RejectDraftChunk",
            request_serializer=openshell__pb2.RejectDraftChunkRequest.SerializeToString,
            response_deserializer=openshell__pb2.RejectDraftChunkResponse.FromString,
            _registered_method=True,
        )
        self.ApproveAllDraftChunks = channel.unary_unary(
            "/openshell.v1.OpenShell/ApproveAllDraftChunks",
            request_serializer=openshell__pb2.ApproveAllDraftChunksRequest.SerializeToString,
            response_deserializer=openshell__pb2.ApproveAllDraftChunksResponse.FromString,
            _registered_method=True,
        )
        self.EditDraftChunk = channel.unary_unary(
            "/openshell.v1.OpenShell/EditDraftChunk",
            request_serializer=openshell__pb2.EditDraftChunkRequest.SerializeToString,
            response_deserializer=openshell__pb2.EditDraftChunkResponse.FromString,
            _registered_method=True,
        )
        self.UndoDraftChunk = channel.unary_unary(
            "/openshell.v1.OpenShell/UndoDraftChunk",
            request_serializer=openshell__pb2.UndoDraftChunkRequest.SerializeToString,
            response_deserializer=openshell__pb2.UndoDraftChunkResponse.FromString,
            _registered_method=True,
        )
        self.ClearDraftChunks = channel.unary_unary(
            "/openshell.v1.OpenShell/ClearDraftChunks",
            request_serializer=openshell__pb2.ClearDraftChunksRequest.SerializeToString,
            response_deserializer=openshell__pb2.ClearDraftChunksResponse.FromString,
            _registered_method=True,
        )
        self.GetDraftHistory = channel.unary_unary(
            "/openshell.v1.OpenShell/GetDraftHistory",
            request_serializer=openshell__pb2.GetDraftHistoryRequest.SerializeToString,
            response_deserializer=openshell__pb2.GetDraftHistoryResponse.FromString,
            _registered_method=True,
        )


class OpenShellServicer(object):
    """OpenShell service provides sandbox, provider, and runtime management capabilities."""

    def Health(self, request, context):
        """Check the health of the service."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def CreateSandbox(self, request, context):
        """Create a new sandbox."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetSandbox(self, request, context):
        """Fetch a sandbox by name."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListSandboxes(self, request, context):
        """List sandboxes."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def DeleteSandbox(self, request, context):
        """Delete a sandbox by name."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def CreateSshSession(self, request, context):
        """Create a short-lived SSH session for a sandbox."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def RevokeSshSession(self, request, context):
        """Revoke a previously issued SSH session."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ExecSandbox(self, request, context):
        """Execute a command in a ready sandbox and stream output."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def CreateProvider(self, request, context):
        """Create a provider."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetProvider(self, request, context):
        """Fetch a provider by name."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListProviders(self, request, context):
        """List providers."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def UpdateProvider(self, request, context):
        """Update an existing provider by name."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def DeleteProvider(self, request, context):
        """Delete a provider by name."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetSandboxConfig(self, request, context):
        """Get sandbox settings by id (called by sandbox entrypoint and poll loop)."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetGatewayConfig(self, request, context):
        """Get gateway-global settings."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def UpdateConfig(self, request, context):
        """Update settings or policy at sandbox or global scope."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetSandboxPolicyStatus(self, request, context):
        """Get the load status of a specific policy version."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListSandboxPolicies(self, request, context):
        """List policy history for a sandbox."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ReportPolicyStatus(self, request, context):
        """Report policy load result (called by sandbox after reload attempt)."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetSandboxProviderEnvironment(self, request, context):
        """Get provider environment for a sandbox (called by sandbox supervisor at startup)."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetSandboxLogs(self, request, context):
        """Fetch recent sandbox logs (one-shot)."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def PushSandboxLogs(self, request_iterator, context):
        """Push sandbox supervisor logs to the server (client-streaming)."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def WatchSandbox(self, request, context):
        """Watch a sandbox and stream updates.

        This stream can include:
        - Sandbox status snapshots (phase/status)
        - OpenShell server process logs correlated by sandbox_id
        - Platform events correlated to the sandbox
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def SubmitPolicyAnalysis(self, request, context):
        """---------------------------------------------------------------------------
        Draft policy recommendation RPCs
        ---------------------------------------------------------------------------

        Submit denial analysis results from sandbox (summaries + proposed chunks).
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetDraftPolicy(self, request, context):
        """Get draft policy recommendations for a sandbox."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ApproveDraftChunk(self, request, context):
        """Approve a single draft policy chunk (merges into active policy)."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def RejectDraftChunk(self, request, context):
        """Reject a single draft policy chunk."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ApproveAllDraftChunks(self, request, context):
        """Approve all pending draft chunks (skips security-flagged unless forced)."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def EditDraftChunk(self, request, context):
        """Edit a pending draft chunk in-place (e.g. narrow allowed_ips)."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def UndoDraftChunk(self, request, context):
        """Reverse an approval (remove merged rule from active policy)."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ClearDraftChunks(self, request, context):
        """Clear all pending draft chunks for a sandbox."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetDraftHistory(self, request, context):
        """Get decision history for a sandbox's draft policy."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")


def add_OpenShellServicer_to_server(servicer, server):
    rpc_method_handlers = {
        "Health": grpc.unary_unary_rpc_method_handler(
            servicer.Health,
            request_deserializer=openshell__pb2.HealthRequest.FromString,
            response_serializer=openshell__pb2.HealthResponse.SerializeToString,
        ),
        "CreateSandbox": grpc.unary_unary_rpc_method_handler(
            servicer.CreateSandbox,
            request_deserializer=openshell__pb2.CreateSandboxRequest.FromString,
            response_serializer=openshell__pb2.SandboxResponse.SerializeToString,
        ),
        "GetSandbox": grpc.unary_unary_rpc_method_handler(
            servicer.GetSandbox,
            request_deserializer=openshell__pb2.GetSandboxRequest.FromString,
            response_serializer=openshell__pb2.SandboxResponse.SerializeToString,
        ),
        "ListSandboxes": grpc.unary_unary_rpc_method_handler(
            servicer.ListSandboxes,
            request_deserializer=openshell__pb2.ListSandboxesRequest.FromString,
            response_serializer=openshell__pb2.ListSandboxesResponse.SerializeToString,
        ),
        "DeleteSandbox": grpc.unary_unary_rpc_method_handler(
            servicer.DeleteSandbox,
            request_deserializer=openshell__pb2.DeleteSandboxRequest.FromString,
            response_serializer=openshell__pb2.DeleteSandboxResponse.SerializeToString,
        ),
        "CreateSshSession": grpc.unary_unary_rpc_method_handler(
            servicer.CreateSshSession,
            request_deserializer=openshell__pb2.CreateSshSessionRequest.FromString,
            response_serializer=openshell__pb2.CreateSshSessionResponse.SerializeToString,
        ),
        "RevokeSshSession": grpc.unary_unary_rpc_method_handler(
            servicer.RevokeSshSession,
            request_deserializer=openshell__pb2.RevokeSshSessionRequest.FromString,
            response_serializer=openshell__pb2.RevokeSshSessionResponse.SerializeToString,
        ),
        "ExecSandbox": grpc.unary_stream_rpc_method_handler(
            servicer.ExecSandbox,
            request_deserializer=openshell__pb2.ExecSandboxRequest.FromString,
            response_serializer=openshell__pb2.ExecSandboxEvent.SerializeToString,
        ),
        "CreateProvider": grpc.unary_unary_rpc_method_handler(
            servicer.CreateProvider,
            request_deserializer=openshell__pb2.CreateProviderRequest.FromString,
            response_serializer=openshell__pb2.ProviderResponse.SerializeToString,
        ),
        "GetProvider": grpc.unary_unary_rpc_method_handler(
            servicer.GetProvider,
            request_deserializer=openshell__pb2.GetProviderRequest.FromString,
            response_serializer=openshell__pb2.ProviderResponse.SerializeToString,
        ),
        "ListProviders": grpc.unary_unary_rpc_method_handler(
            servicer.ListProviders,
            request_deserializer=openshell__pb2.ListProvidersRequest.FromString,
            response_serializer=openshell__pb2.ListProvidersResponse.SerializeToString,
        ),
        "UpdateProvider": grpc.unary_unary_rpc_method_handler(
            servicer.UpdateProvider,
            request_deserializer=openshell__pb2.UpdateProviderRequest.FromString,
            response_serializer=openshell__pb2.ProviderResponse.SerializeToString,
        ),
        "DeleteProvider": grpc.unary_unary_rpc_method_handler(
            servicer.DeleteProvider,
            request_deserializer=openshell__pb2.DeleteProviderRequest.FromString,
            response_serializer=openshell__pb2.DeleteProviderResponse.SerializeToString,
        ),
        "GetSandboxConfig": grpc.unary_unary_rpc_method_handler(
            servicer.GetSandboxConfig,
            request_deserializer=sandbox__pb2.GetSandboxConfigRequest.FromString,
            response_serializer=sandbox__pb2.GetSandboxConfigResponse.SerializeToString,
        ),
        "GetGatewayConfig": grpc.unary_unary_rpc_method_handler(
            servicer.GetGatewayConfig,
            request_deserializer=sandbox__pb2.GetGatewayConfigRequest.FromString,
            response_serializer=sandbox__pb2.GetGatewayConfigResponse.SerializeToString,
        ),
        "UpdateConfig": grpc.unary_unary_rpc_method_handler(
            servicer.UpdateConfig,
            request_deserializer=openshell__pb2.UpdateConfigRequest.FromString,
            response_serializer=openshell__pb2.UpdateConfigResponse.SerializeToString,
        ),
        "GetSandboxPolicyStatus": grpc.unary_unary_rpc_method_handler(
            servicer.GetSandboxPolicyStatus,
            request_deserializer=openshell__pb2.GetSandboxPolicyStatusRequest.FromString,
            response_serializer=openshell__pb2.GetSandboxPolicyStatusResponse.SerializeToString,
        ),
        "ListSandboxPolicies": grpc.unary_unary_rpc_method_handler(
            servicer.ListSandboxPolicies,
            request_deserializer=openshell__pb2.ListSandboxPoliciesRequest.FromString,
            response_serializer=openshell__pb2.ListSandboxPoliciesResponse.SerializeToString,
        ),
        "ReportPolicyStatus": grpc.unary_unary_rpc_method_handler(
            servicer.ReportPolicyStatus,
            request_deserializer=openshell__pb2.ReportPolicyStatusRequest.FromString,
            response_serializer=openshell__pb2.ReportPolicyStatusResponse.SerializeToString,
        ),
        "GetSandboxProviderEnvironment": grpc.unary_unary_rpc_method_handler(
            servicer.GetSandboxProviderEnvironment,
            request_deserializer=openshell__pb2.GetSandboxProviderEnvironmentRequest.FromString,
            response_serializer=openshell__pb2.GetSandboxProviderEnvironmentResponse.SerializeToString,
        ),
        "GetSandboxLogs": grpc.unary_unary_rpc_method_handler(
            servicer.GetSandboxLogs,
            request_deserializer=openshell__pb2.GetSandboxLogsRequest.FromString,
            response_serializer=openshell__pb2.GetSandboxLogsResponse.SerializeToString,
        ),
        "PushSandboxLogs": grpc.stream_unary_rpc_method_handler(
            servicer.PushSandboxLogs,
            request_deserializer=openshell__pb2.PushSandboxLogsRequest.FromString,
            response_serializer=openshell__pb2.PushSandboxLogsResponse.SerializeToString,
        ),
        "WatchSandbox": grpc.unary_stream_rpc_method_handler(
            servicer.WatchSandbox,
            request_deserializer=openshell__pb2.WatchSandboxRequest.FromString,
            response_serializer=openshell__pb2.SandboxStreamEvent.SerializeToString,
        ),
        "SubmitPolicyAnalysis": grpc.unary_unary_rpc_method_handler(
            servicer.SubmitPolicyAnalysis,
            request_deserializer=openshell__pb2.SubmitPolicyAnalysisRequest.FromString,
            response_serializer=openshell__pb2.SubmitPolicyAnalysisResponse.SerializeToString,
        ),
        "GetDraftPolicy": grpc.unary_unary_rpc_method_handler(
            servicer.GetDraftPolicy,
            request_deserializer=openshell__pb2.GetDraftPolicyRequest.FromString,
            response_serializer=openshell__pb2.GetDraftPolicyResponse.SerializeToString,
        ),
        "ApproveDraftChunk": grpc.unary_unary_rpc_method_handler(
            servicer.ApproveDraftChunk,
            request_deserializer=openshell__pb2.ApproveDraftChunkRequest.FromString,
            response_serializer=openshell__pb2.ApproveDraftChunkResponse.SerializeToString,
        ),
        "RejectDraftChunk": grpc.unary_unary_rpc_method_handler(
            servicer.RejectDraftChunk,
            request_deserializer=openshell__pb2.RejectDraftChunkRequest.FromString,
            response_serializer=openshell__pb2.RejectDraftChunkResponse.SerializeToString,
        ),
        "ApproveAllDraftChunks": grpc.unary_unary_rpc_method_handler(
            servicer.ApproveAllDraftChunks,
            request_deserializer=openshell__pb2.ApproveAllDraftChunksRequest.FromString,
            response_serializer=openshell__pb2.ApproveAllDraftChunksResponse.SerializeToString,
        ),
        "EditDraftChunk": grpc.unary_unary_rpc_method_handler(
            servicer.EditDraftChunk,
            request_deserializer=openshell__pb2.EditDraftChunkRequest.FromString,
            response_serializer=openshell__pb2.EditDraftChunkResponse.SerializeToString,
        ),
        "UndoDraftChunk": grpc.unary_unary_rpc_method_handler(
            servicer.UndoDraftChunk,
            request_deserializer=openshell__pb2.UndoDraftChunkRequest.FromString,
            response_serializer=openshell__pb2.UndoDraftChunkResponse.SerializeToString,
        ),
        "ClearDraftChunks": grpc.unary_unary_rpc_method_handler(
            servicer.ClearDraftChunks,
            request_deserializer=openshell__pb2.ClearDraftChunksRequest.FromString,
            response_serializer=openshell__pb2.ClearDraftChunksResponse.SerializeToString,
        ),
        "GetDraftHistory": grpc.unary_unary_rpc_method_handler(
            servicer.GetDraftHistory,
            request_deserializer=openshell__pb2.GetDraftHistoryRequest.FromString,
            response_serializer=openshell__pb2.GetDraftHistoryResponse.SerializeToString,
        ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
        "openshell.v1.OpenShell", rpc_method_handlers
    )
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers("openshell.v1.OpenShell", rpc_method_handlers)


# This class is part of an EXPERIMENTAL API.
class OpenShell(object):
    """OpenShell service provides sandbox, provider, and runtime management capabilities."""

    @staticmethod
    def Health(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/Health",
            openshell__pb2.HealthRequest.SerializeToString,
            openshell__pb2.HealthResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def CreateSandbox(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/CreateSandbox",
            openshell__pb2.CreateSandboxRequest.SerializeToString,
            openshell__pb2.SandboxResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetSandbox(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/GetSandbox",
            openshell__pb2.GetSandboxRequest.SerializeToString,
            openshell__pb2.SandboxResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def ListSandboxes(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/ListSandboxes",
            openshell__pb2.ListSandboxesRequest.SerializeToString,
            openshell__pb2.ListSandboxesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def DeleteSandbox(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/DeleteSandbox",
            openshell__pb2.DeleteSandboxRequest.SerializeToString,
            openshell__pb2.DeleteSandboxResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def CreateSshSession(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/CreateSshSession",
            openshell__pb2.CreateSshSessionRequest.SerializeToString,
            openshell__pb2.CreateSshSessionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def RevokeSshSession(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/RevokeSshSession",
            openshell__pb2.RevokeSshSessionRequest.SerializeToString,
            openshell__pb2.RevokeSshSessionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def ExecSandbox(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/openshell.v1.OpenShell/ExecSandbox",
            openshell__pb2.ExecSandboxRequest.SerializeToString,
            openshell__pb2.ExecSandboxEvent.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def CreateProvider(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/CreateProvider",
            openshell__pb2.CreateProviderRequest.SerializeToString,
            openshell__pb2.ProviderResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetProvider(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/GetProvider",
            openshell__pb2.GetProviderRequest.SerializeToString,
            openshell__pb2.ProviderResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def ListProviders(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/ListProviders",
            openshell__pb2.ListProvidersRequest.SerializeToString,
            openshell__pb2.ListProvidersResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def UpdateProvider(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/UpdateProvider",
            openshell__pb2.UpdateProviderRequest.SerializeToString,
            openshell__pb2.ProviderResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def DeleteProvider(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/DeleteProvider",
            openshell__pb2.DeleteProviderRequest.SerializeToString,
            openshell__pb2.DeleteProviderResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetSandboxConfig(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/GetSandboxConfig",
            sandbox__pb2.GetSandboxConfigRequest.SerializeToString,
            sandbox__pb2.GetSandboxConfigResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetGatewayConfig(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/GetGatewayConfig",
            sandbox__pb2.GetGatewayConfigRequest.SerializeToString,
            sandbox__pb2.GetGatewayConfigResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def UpdateConfig(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/UpdateConfig",
            openshell__pb2.UpdateConfigRequest.SerializeToString,
            openshell__pb2.UpdateConfigResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetSandboxPolicyStatus(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/GetSandboxPolicyStatus",
            openshell__pb2.GetSandboxPolicyStatusRequest.SerializeToString,
            openshell__pb2.GetSandboxPolicyStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def ListSandboxPolicies(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/ListSandboxPolicies",
            openshell__pb2.ListSandboxPoliciesRequest.SerializeToString,
            openshell__pb2.ListSandboxPoliciesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def ReportPolicyStatus(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/ReportPolicyStatus",
            openshell__pb2.ReportPolicyStatusRequest.SerializeToString,
            openshell__pb2.ReportPolicyStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetSandboxProviderEnvironment(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/GetSandboxProviderEnvironment",
            openshell__pb2.GetSandboxProviderEnvironmentRequest.SerializeToString,
            openshell__pb2.GetSandboxProviderEnvironmentResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetSandboxLogs(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/GetSandboxLogs",
            openshell__pb2.GetSandboxLogsRequest.SerializeToString,
            openshell__pb2.GetSandboxLogsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def PushSandboxLogs(
        request_iterator,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.stream_unary(
            request_iterator,
            target,
            "/openshell.v1.OpenShell/PushSandboxLogs",
            openshell__pb2.PushSandboxLogsRequest.SerializeToString,
            openshell__pb2.PushSandboxLogsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def WatchSandbox(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/openshell.v1.OpenShell/WatchSandbox",
            openshell__pb2.WatchSandboxRequest.SerializeToString,
            openshell__pb2.SandboxStreamEvent.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def SubmitPolicyAnalysis(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/SubmitPolicyAnalysis",
            openshell__pb2.SubmitPolicyAnalysisRequest.SerializeToString,
            openshell__pb2.SubmitPolicyAnalysisResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetDraftPolicy(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/GetDraftPolicy",
            openshell__pb2.GetDraftPolicyRequest.SerializeToString,
            openshell__pb2.GetDraftPolicyResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def ApproveDraftChunk(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/ApproveDraftChunk",
            openshell__pb2.ApproveDraftChunkRequest.SerializeToString,
            openshell__pb2.ApproveDraftChunkResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def RejectDraftChunk(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/RejectDraftChunk",
            openshell__pb2.RejectDraftChunkRequest.SerializeToString,
            openshell__pb2.RejectDraftChunkResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def ApproveAllDraftChunks(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/ApproveAllDraftChunks",
            openshell__pb2.ApproveAllDraftChunksRequest.SerializeToString,
            openshell__pb2.ApproveAllDraftChunksResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def EditDraftChunk(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/EditDraftChunk",
            openshell__pb2.EditDraftChunkRequest.SerializeToString,
            openshell__pb2.EditDraftChunkResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def UndoDraftChunk(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/UndoDraftChunk",
            openshell__pb2.UndoDraftChunkRequest.SerializeToString,
            openshell__pb2.UndoDraftChunkResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def ClearDraftChunks(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/ClearDraftChunks",
            openshell__pb2.ClearDraftChunksRequest.SerializeToString,
            openshell__pb2.ClearDraftChunksResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )

    @staticmethod
    def GetDraftHistory(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/openshell.v1.OpenShell/GetDraftHistory",
            openshell__pb2.GetDraftHistoryRequest.SerializeToString,
            openshell__pb2.GetDraftHistoryResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True,
        )
