# 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 agent_messages_pb2 as agent__messages__pb2
from . import control_messages_pb2 as control__messages__pb2
from .file_operations import transfer_pb2 as file__operations_dot_transfer__pb2
from .file_rpc import archive_pb2 as file__rpc_dot_archive__pb2
from .file_rpc import directory_pb2 as file__rpc_dot_directory__pb2
from .file_rpc import file_crud_pb2 as file__rpc_dot_file__crud__pb2
from .file_rpc import hls_pb2 as file__rpc_dot_hls__pb2
from .file_rpc import search_pb2 as file__rpc_dot_search__pb2
from .rpc_messages import agent_pb2 as rpc__messages_dot_agent__pb2
from .rpc_messages import device_pb2 as rpc__messages_dot_device__pb2
from .rpc_messages import extract_pb2 as rpc__messages_dot_extract__pb2
from .rpc_messages import health_pb2 as rpc__messages_dot_health__pb2
from .rpc_messages import history_pb2 as rpc__messages_dot_history__pb2
from .rpc_messages import lifecycle_pb2 as rpc__messages_dot_lifecycle__pb2
from .rpc_messages import push_pb2 as rpc__messages_dot_push__pb2
from .rpc_messages import session_pb2 as rpc__messages_dot_session__pb2
from .rpc_messages import skills_pb2 as rpc__messages_dot_skills__pb2
from .rpc_messages import terminal_pb2 as rpc__messages_dot_terminal__pb2
from . import service_pb2 as service__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 service_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 TerminalStreamingServiceStub(object):
    """============================================================================
    SERVICE DEFINITION
    ============================================================================

    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.ConnectTerminal = channel.stream_stream(
                '/terminal.TerminalStreamingService/ConnectTerminal',
                request_serializer=agent__messages__pb2.AgentMessage.SerializeToString,
                response_deserializer=control__messages__pb2.ControlMessage.FromString,
                _registered_method=True)
        self.GetChallenge = channel.unary_unary(
                '/terminal.TerminalStreamingService/GetChallenge',
                request_serializer=service__pb2.GetChallengeRequest.SerializeToString,
                response_deserializer=service__pb2.GetChallengeResponse.FromString,
                _registered_method=True)
        self.CreateSession = channel.unary_unary(
                '/terminal.TerminalStreamingService/CreateSession',
                request_serializer=rpc__messages_dot_session__pb2.CreateSessionRequest.SerializeToString,
                response_deserializer=rpc__messages_dot_session__pb2.CreateSessionResponse.FromString,
                _registered_method=True)
        self.CloseSession = channel.unary_unary(
                '/terminal.TerminalStreamingService/CloseSession',
                request_serializer=rpc__messages_dot_session__pb2.CloseSessionRequest.SerializeToString,
                response_deserializer=rpc__messages_dot_session__pb2.CloseSessionResponse.FromString,
                _registered_method=True)
        self.GetSessionStatus = channel.unary_unary(
                '/terminal.TerminalStreamingService/GetSessionStatus',
                request_serializer=rpc__messages_dot_session__pb2.GetSessionStatusRequest.SerializeToString,
                response_deserializer=rpc__messages_dot_session__pb2.GetSessionStatusResponse.FromString,
                _registered_method=True)
        self.ListSessions = channel.unary_unary(
                '/terminal.TerminalStreamingService/ListSessions',
                request_serializer=rpc__messages_dot_session__pb2.ListSessionsRequest.SerializeToString,
                response_deserializer=rpc__messages_dot_session__pb2.ListSessionsResponse.FromString,
                _registered_method=True)
        self.GetSessionByHostname = channel.unary_unary(
                '/terminal.TerminalStreamingService/GetSessionByHostname',
                request_serializer=rpc__messages_dot_session__pb2.GetSessionByHostnameRequest.SerializeToString,
                response_deserializer=rpc__messages_dot_session__pb2.GetSessionByHostnameResponse.FromString,
                _registered_method=True)
        self.SendInput = channel.unary_unary(
                '/terminal.TerminalStreamingService/SendInput',
                request_serializer=rpc__messages_dot_terminal__pb2.SendInputRequest.SerializeToString,
                response_deserializer=rpc__messages_dot_terminal__pb2.SendInputResponse.FromString,
                _registered_method=True)
        self.SendResize = channel.unary_unary(
                '/terminal.TerminalStreamingService/SendResize',
                request_serializer=rpc__messages_dot_terminal__pb2.SendResizeRequest.SerializeToString,
                response_deserializer=rpc__messages_dot_terminal__pb2.SendResizeResponse.FromString,
                _registered_method=True)
        self.SendSignal = channel.unary_unary(
                '/terminal.TerminalStreamingService/SendSignal',
                request_serializer=rpc__messages_dot_terminal__pb2.SendSignalRequest.SerializeToString,
                response_deserializer=rpc__messages_dot_terminal__pb2.SendSignalResponse.FromString,
                _registered_method=True)
        self.GetHistory = channel.unary_unary(
                '/terminal.TerminalStreamingService/GetHistory',
                request_serializer=rpc__messages_dot_history__pb2.GetHistoryRequest.SerializeToString,
                response_deserializer=rpc__messages_dot_history__pb2.GetHistoryResponse.FromString,
                _registered_method=True)
        self.GetOutput = channel.unary_unary(
                '/terminal.TerminalStreamingService/GetOutput',
                request_serializer=rpc__messages_dot_history__pb2.GetOutputRequest.SerializeToString,
                response_deserializer=rpc__messages_dot_history__pb2.GetOutputResponse.FromString,
                _registered_method=True)
        self.HealthCheck = channel.unary_unary(
                '/terminal.TerminalStreamingService/HealthCheck',
                request_serializer=rpc__messages_dot_health__pb2.HealthCheckRequest.SerializeToString,
                response_deserializer=rpc__messages_dot_health__pb2.HealthCheckResponse.FromString,
                _registered_method=True)
        self.RegisterDeviceToken = channel.unary_unary(
                '/terminal.TerminalStreamingService/RegisterDeviceToken',
                request_serializer=rpc__messages_dot_device__pb2.RegisterDeviceTokenRequest.SerializeToString,
                response_deserializer=rpc__messages_dot_device__pb2.RegisterDeviceTokenResponse.FromString,
                _registered_method=True)
        self.UnregisterDeviceToken = channel.unary_unary(
                '/terminal.TerminalStreamingService/UnregisterDeviceToken',
                request_serializer=rpc__messages_dot_device__pb2.UnregisterDeviceTokenRequest.SerializeToString,
                response_deserializer=rpc__messages_dot_device__pb2.UnregisterDeviceTokenResponse.FromString,
                _registered_method=True)
        self.EnterBackground = channel.unary_unary(
                '/terminal.TerminalStreamingService/EnterBackground',
                request_serializer=rpc__messages_dot_lifecycle__pb2.EnterBackgroundRequest.SerializeToString,
                response_deserializer=rpc__messages_dot_lifecycle__pb2.EnterBackgroundResponse.FromString,
                _registered_method=True)
        self.WakeFromBackground = channel.unary_unary(
                '/terminal.TerminalStreamingService/WakeFromBackground',
                request_serializer=rpc__messages_dot_lifecycle__pb2.WakeFromBackgroundRequest.SerializeToString,
                response_deserializer=rpc__messages_dot_lifecycle__pb2.WakeFromBackgroundResponse.FromString,
                _registered_method=True)
        self.QueueCommand = channel.unary_unary(
                '/terminal.TerminalStreamingService/QueueCommand',
                request_serializer=rpc__messages_dot_lifecycle__pb2.QueueCommandRequest.SerializeToString,
                response_deserializer=rpc__messages_dot_lifecycle__pb2.QueueCommandResponse.FromString,
                _registered_method=True)
        self.FileListDirectory = channel.unary_unary(
                '/terminal.TerminalStreamingService/FileListDirectory',
                request_serializer=file__rpc_dot_directory__pb2.FileListDirectoryRpcRequest.SerializeToString,
                response_deserializer=file__rpc_dot_directory__pb2.FileListDirectoryRpcResponse.FromString,
                _registered_method=True)
        self.FileRead = channel.unary_unary(
                '/terminal.TerminalStreamingService/FileRead',
                request_serializer=file__rpc_dot_file__crud__pb2.FileReadRpcRequest.SerializeToString,
                response_deserializer=file__rpc_dot_file__crud__pb2.FileReadRpcResponse.FromString,
                _registered_method=True)
        self.FileWrite = channel.unary_unary(
                '/terminal.TerminalStreamingService/FileWrite',
                request_serializer=file__rpc_dot_file__crud__pb2.FileWriteRpcRequest.SerializeToString,
                response_deserializer=file__rpc_dot_file__crud__pb2.FileWriteRpcResponse.FromString,
                _registered_method=True)
        self.FileCreateDirectory = channel.unary_unary(
                '/terminal.TerminalStreamingService/FileCreateDirectory',
                request_serializer=file__rpc_dot_file__crud__pb2.FileCreateDirectoryRpcRequest.SerializeToString,
                response_deserializer=file__rpc_dot_file__crud__pb2.FileCreateDirectoryRpcResponse.FromString,
                _registered_method=True)
        self.FileDelete = channel.unary_unary(
                '/terminal.TerminalStreamingService/FileDelete',
                request_serializer=file__rpc_dot_file__crud__pb2.FileDeleteRpcRequest.SerializeToString,
                response_deserializer=file__rpc_dot_file__crud__pb2.FileDeleteRpcResponse.FromString,
                _registered_method=True)
        self.FileMove = channel.unary_unary(
                '/terminal.TerminalStreamingService/FileMove',
                request_serializer=file__rpc_dot_file__crud__pb2.FileMoveRpcRequest.SerializeToString,
                response_deserializer=file__rpc_dot_file__crud__pb2.FileMoveRpcResponse.FromString,
                _registered_method=True)
        self.FileCopy = channel.unary_unary(
                '/terminal.TerminalStreamingService/FileCopy',
                request_serializer=file__rpc_dot_file__crud__pb2.FileCopyRpcRequest.SerializeToString,
                response_deserializer=file__rpc_dot_file__crud__pb2.FileCopyRpcResponse.FromString,
                _registered_method=True)
        self.FileGetInfo = channel.unary_unary(
                '/terminal.TerminalStreamingService/FileGetInfo',
                request_serializer=file__rpc_dot_file__crud__pb2.FileGetInfoRpcRequest.SerializeToString,
                response_deserializer=file__rpc_dot_file__crud__pb2.FileGetInfoRpcResponse.FromString,
                _registered_method=True)
        self.FileCreateArchive = channel.unary_unary(
                '/terminal.TerminalStreamingService/FileCreateArchive',
                request_serializer=file__rpc_dot_archive__pb2.FileCreateArchiveRpcRequest.SerializeToString,
                response_deserializer=file__rpc_dot_archive__pb2.FileCreateArchiveRpcResponse.FromString,
                _registered_method=True)
        self.FileSearch = channel.unary_unary(
                '/terminal.TerminalStreamingService/FileSearch',
                request_serializer=file__rpc_dot_search__pb2.FileSearchRpcRequest.SerializeToString,
                response_deserializer=file__rpc_dot_search__pb2.FileSearchRpcResponse.FromString,
                _registered_method=True)
        self.HlsGetPlaylist = channel.unary_unary(
                '/terminal.TerminalStreamingService/HlsGetPlaylist',
                request_serializer=file__rpc_dot_hls__pb2.HlsGetPlaylistRpcRequest.SerializeToString,
                response_deserializer=file__rpc_dot_hls__pb2.HlsGetPlaylistRpcResponse.FromString,
                _registered_method=True)
        self.HlsGetSegment = channel.unary_unary(
                '/terminal.TerminalStreamingService/HlsGetSegment',
                request_serializer=file__rpc_dot_hls__pb2.HlsGetSegmentRpcRequest.SerializeToString,
                response_deserializer=file__rpc_dot_hls__pb2.HlsGetSegmentRpcResponse.FromString,
                _registered_method=True)
        self.HlsStopSession = channel.unary_unary(
                '/terminal.TerminalStreamingService/HlsStopSession',
                request_serializer=file__rpc_dot_hls__pb2.HlsStopSessionRpcRequest.SerializeToString,
                response_deserializer=file__rpc_dot_hls__pb2.HlsStopSessionRpcResponse.FromString,
                _registered_method=True)
        self.InitiateStreamingRelay = channel.unary_unary(
                '/terminal.TerminalStreamingService/InitiateStreamingRelay',
                request_serializer=file__operations_dot_transfer__pb2.StreamingRelayRequest.SerializeToString,
                response_deserializer=file__operations_dot_transfer__pb2.StreamingRelayResponse.FromString,
                _registered_method=True)
        self.RelayChunk = channel.unary_unary(
                '/terminal.TerminalStreamingService/RelayChunk',
                request_serializer=file__operations_dot_transfer__pb2.StreamingRelayChunk.SerializeToString,
                response_deserializer=file__operations_dot_transfer__pb2.StreamingRelayAck.FromString,
                _registered_method=True)
        self.GetStreamingRelayStatus = channel.unary_unary(
                '/terminal.TerminalStreamingService/GetStreamingRelayStatus',
                request_serializer=file__operations_dot_transfer__pb2.StreamingRelayStatusRequest.SerializeToString,
                response_deserializer=file__operations_dot_transfer__pb2.StreamingRelayStatus.FromString,
                _registered_method=True)
        self.CancelStreamingRelay = channel.unary_unary(
                '/terminal.TerminalStreamingService/CancelStreamingRelay',
                request_serializer=file__operations_dot_transfer__pb2.StreamingRelayCancelRequest.SerializeToString,
                response_deserializer=file__operations_dot_transfer__pb2.StreamingRelayCancelResponse.FromString,
                _registered_method=True)
        self.SendPushNotification = channel.unary_unary(
                '/terminal.TerminalStreamingService/SendPushNotification',
                request_serializer=rpc__messages_dot_push__pb2.SendPushNotificationRequest.SerializeToString,
                response_deserializer=rpc__messages_dot_push__pb2.SendPushNotificationResponse.FromString,
                _registered_method=True)
        self.Extract = channel.unary_unary(
                '/terminal.TerminalStreamingService/Extract',
                request_serializer=rpc__messages_dot_extract__pb2.ExtractRequest.SerializeToString,
                response_deserializer=rpc__messages_dot_extract__pb2.ExtractResponse.FromString,
                _registered_method=True)
        self.RunAgent = channel.unary_unary(
                '/terminal.TerminalStreamingService/RunAgent',
                request_serializer=rpc__messages_dot_agent__pb2.RunAgentRequest.SerializeToString,
                response_deserializer=rpc__messages_dot_agent__pb2.RunAgentResponse.FromString,
                _registered_method=True)
        self.RunAgentStream = channel.unary_stream(
                '/terminal.TerminalStreamingService/RunAgentStream',
                request_serializer=rpc__messages_dot_agent__pb2.RunAgentRequest.SerializeToString,
                response_deserializer=rpc__messages_dot_agent__pb2.RunAgentStreamResponse.FromString,
                _registered_method=True)
        self.CancelAgent = channel.unary_unary(
                '/terminal.TerminalStreamingService/CancelAgent',
                request_serializer=rpc__messages_dot_agent__pb2.CancelAgentRequest.SerializeToString,
                response_deserializer=rpc__messages_dot_agent__pb2.CancelAgentResponse.FromString,
                _registered_method=True)
        self.SkillList = channel.unary_unary(
                '/terminal.TerminalStreamingService/SkillList',
                request_serializer=rpc__messages_dot_skills__pb2.SkillListRequest.SerializeToString,
                response_deserializer=rpc__messages_dot_skills__pb2.SkillListResponse.FromString,
                _registered_method=True)
        self.SkillShow = channel.unary_unary(
                '/terminal.TerminalStreamingService/SkillShow',
                request_serializer=rpc__messages_dot_skills__pb2.SkillShowRequest.SerializeToString,
                response_deserializer=rpc__messages_dot_skills__pb2.SkillShowResponse.FromString,
                _registered_method=True)
        self.SkillRun = channel.unary_unary(
                '/terminal.TerminalStreamingService/SkillRun',
                request_serializer=rpc__messages_dot_skills__pb2.SkillRunRequest.SerializeToString,
                response_deserializer=rpc__messages_dot_skills__pb2.SkillRunResponse.FromString,
                _registered_method=True)


class TerminalStreamingServiceServicer(object):
    """============================================================================
    SERVICE DEFINITION
    ============================================================================

    """

    def ConnectTerminal(self, request_iterator, context):
        """PRIMARY: Bidirectional streaming for terminal I/O
        Agent opens stream → Django sends input → Agent sends output
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetChallenge(self, request, context):
        """MFA challenge nonce (v2.25.0)
        Called BEFORE ConnectTerminal when workspace requires Ed25519 signing.
        Returns a 32-byte nonce the agent must sign in RegisterRequest.session_signature.
        Also indicates which auth methods the workspace requires.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateSession(self, request, context):
        """Session management RPCs
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CloseSession(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetSessionStatus(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ListSessions(self, request, context):
        """v2.14.0
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetSessionByHostname(self, request, context):
        """v2.21.0
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SendInput(self, request, context):
        """Terminal control RPCs (for external clients like Django management commands)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SendResize(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SendSignal(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetHistory(self, request, context):
        """History & Output
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetOutput(self, request, context):
        """v2.20.0 - SDK execute() support
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def HealthCheck(self, request, context):
        """Health check
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RegisterDeviceToken(self, request, context):
        """Device token registration (for push notifications)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UnregisterDeviceToken(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def EnterBackground(self, request, context):
        """Session lifecycle (push-wake flow)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def WakeFromBackground(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def QueueCommand(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FileListDirectory(self, request, context):
        """File operations (routed through streaming to agent)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FileRead(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FileWrite(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FileCreateDirectory(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FileDelete(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FileMove(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FileCopy(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FileGetInfo(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FileCreateArchive(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FileSearch(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def HlsGetPlaylist(self, request, context):
        """HLS streaming (v2.11.0) - for adaptive video streaming
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def HlsGetSegment(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def HlsStopSession(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def InitiateStreamingRelay(self, request, context):
        """Streaming relay (for cross-device file transfer via HTTP -> gRPC)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RelayChunk(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetStreamingRelayStatus(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CancelStreamingRelay(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SendPushNotification(self, request, context):
        """Push notification (send desktop notification to agent)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Extract(self, request, context):
        """Structured data extraction (v2.12.0) - for SDK programmatic access
        Agent uses tools to gather data and returns JSON matching provided schema
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RunAgent(self, request, context):
        """Run AI agent (v2.13.0) - for SDK agent execution
        SDK sends prompt, Django relays to connected agent, returns result
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RunAgentStream(self, request, context):
        """Run AI agent with streaming (v2.22.0) - for SDK streaming agent execution
        SDK sends prompt, Django relays to agent with stream_events=true,
        streams AgentStreamEvent back to SDK, ends with final result
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CancelAgent(self, request, context):
        """Cancel running agent (v2.15.0) - for SDK agent cancellation
        SDK sends cancel request, Django relays to connected agent, returns confirmation
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SkillList(self, request, context):
        """============================================================================
        SKILLS (v2.23.0)
        Remote skill management and execution - SDK can list, inspect, and run skills
        ============================================================================

        List installed skills on connected machine
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SkillShow(self, request, context):
        """Get skill details (manifest, content, source path)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SkillRun(self, request, context):
        """Execute a skill with a prompt
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_TerminalStreamingServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'ConnectTerminal': grpc.stream_stream_rpc_method_handler(
                    servicer.ConnectTerminal,
                    request_deserializer=agent__messages__pb2.AgentMessage.FromString,
                    response_serializer=control__messages__pb2.ControlMessage.SerializeToString,
            ),
            'GetChallenge': grpc.unary_unary_rpc_method_handler(
                    servicer.GetChallenge,
                    request_deserializer=service__pb2.GetChallengeRequest.FromString,
                    response_serializer=service__pb2.GetChallengeResponse.SerializeToString,
            ),
            'CreateSession': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateSession,
                    request_deserializer=rpc__messages_dot_session__pb2.CreateSessionRequest.FromString,
                    response_serializer=rpc__messages_dot_session__pb2.CreateSessionResponse.SerializeToString,
            ),
            'CloseSession': grpc.unary_unary_rpc_method_handler(
                    servicer.CloseSession,
                    request_deserializer=rpc__messages_dot_session__pb2.CloseSessionRequest.FromString,
                    response_serializer=rpc__messages_dot_session__pb2.CloseSessionResponse.SerializeToString,
            ),
            'GetSessionStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.GetSessionStatus,
                    request_deserializer=rpc__messages_dot_session__pb2.GetSessionStatusRequest.FromString,
                    response_serializer=rpc__messages_dot_session__pb2.GetSessionStatusResponse.SerializeToString,
            ),
            'ListSessions': grpc.unary_unary_rpc_method_handler(
                    servicer.ListSessions,
                    request_deserializer=rpc__messages_dot_session__pb2.ListSessionsRequest.FromString,
                    response_serializer=rpc__messages_dot_session__pb2.ListSessionsResponse.SerializeToString,
            ),
            'GetSessionByHostname': grpc.unary_unary_rpc_method_handler(
                    servicer.GetSessionByHostname,
                    request_deserializer=rpc__messages_dot_session__pb2.GetSessionByHostnameRequest.FromString,
                    response_serializer=rpc__messages_dot_session__pb2.GetSessionByHostnameResponse.SerializeToString,
            ),
            'SendInput': grpc.unary_unary_rpc_method_handler(
                    servicer.SendInput,
                    request_deserializer=rpc__messages_dot_terminal__pb2.SendInputRequest.FromString,
                    response_serializer=rpc__messages_dot_terminal__pb2.SendInputResponse.SerializeToString,
            ),
            'SendResize': grpc.unary_unary_rpc_method_handler(
                    servicer.SendResize,
                    request_deserializer=rpc__messages_dot_terminal__pb2.SendResizeRequest.FromString,
                    response_serializer=rpc__messages_dot_terminal__pb2.SendResizeResponse.SerializeToString,
            ),
            'SendSignal': grpc.unary_unary_rpc_method_handler(
                    servicer.SendSignal,
                    request_deserializer=rpc__messages_dot_terminal__pb2.SendSignalRequest.FromString,
                    response_serializer=rpc__messages_dot_terminal__pb2.SendSignalResponse.SerializeToString,
            ),
            'GetHistory': grpc.unary_unary_rpc_method_handler(
                    servicer.GetHistory,
                    request_deserializer=rpc__messages_dot_history__pb2.GetHistoryRequest.FromString,
                    response_serializer=rpc__messages_dot_history__pb2.GetHistoryResponse.SerializeToString,
            ),
            'GetOutput': grpc.unary_unary_rpc_method_handler(
                    servicer.GetOutput,
                    request_deserializer=rpc__messages_dot_history__pb2.GetOutputRequest.FromString,
                    response_serializer=rpc__messages_dot_history__pb2.GetOutputResponse.SerializeToString,
            ),
            'HealthCheck': grpc.unary_unary_rpc_method_handler(
                    servicer.HealthCheck,
                    request_deserializer=rpc__messages_dot_health__pb2.HealthCheckRequest.FromString,
                    response_serializer=rpc__messages_dot_health__pb2.HealthCheckResponse.SerializeToString,
            ),
            'RegisterDeviceToken': grpc.unary_unary_rpc_method_handler(
                    servicer.RegisterDeviceToken,
                    request_deserializer=rpc__messages_dot_device__pb2.RegisterDeviceTokenRequest.FromString,
                    response_serializer=rpc__messages_dot_device__pb2.RegisterDeviceTokenResponse.SerializeToString,
            ),
            'UnregisterDeviceToken': grpc.unary_unary_rpc_method_handler(
                    servicer.UnregisterDeviceToken,
                    request_deserializer=rpc__messages_dot_device__pb2.UnregisterDeviceTokenRequest.FromString,
                    response_serializer=rpc__messages_dot_device__pb2.UnregisterDeviceTokenResponse.SerializeToString,
            ),
            'EnterBackground': grpc.unary_unary_rpc_method_handler(
                    servicer.EnterBackground,
                    request_deserializer=rpc__messages_dot_lifecycle__pb2.EnterBackgroundRequest.FromString,
                    response_serializer=rpc__messages_dot_lifecycle__pb2.EnterBackgroundResponse.SerializeToString,
            ),
            'WakeFromBackground': grpc.unary_unary_rpc_method_handler(
                    servicer.WakeFromBackground,
                    request_deserializer=rpc__messages_dot_lifecycle__pb2.WakeFromBackgroundRequest.FromString,
                    response_serializer=rpc__messages_dot_lifecycle__pb2.WakeFromBackgroundResponse.SerializeToString,
            ),
            'QueueCommand': grpc.unary_unary_rpc_method_handler(
                    servicer.QueueCommand,
                    request_deserializer=rpc__messages_dot_lifecycle__pb2.QueueCommandRequest.FromString,
                    response_serializer=rpc__messages_dot_lifecycle__pb2.QueueCommandResponse.SerializeToString,
            ),
            'FileListDirectory': grpc.unary_unary_rpc_method_handler(
                    servicer.FileListDirectory,
                    request_deserializer=file__rpc_dot_directory__pb2.FileListDirectoryRpcRequest.FromString,
                    response_serializer=file__rpc_dot_directory__pb2.FileListDirectoryRpcResponse.SerializeToString,
            ),
            'FileRead': grpc.unary_unary_rpc_method_handler(
                    servicer.FileRead,
                    request_deserializer=file__rpc_dot_file__crud__pb2.FileReadRpcRequest.FromString,
                    response_serializer=file__rpc_dot_file__crud__pb2.FileReadRpcResponse.SerializeToString,
            ),
            'FileWrite': grpc.unary_unary_rpc_method_handler(
                    servicer.FileWrite,
                    request_deserializer=file__rpc_dot_file__crud__pb2.FileWriteRpcRequest.FromString,
                    response_serializer=file__rpc_dot_file__crud__pb2.FileWriteRpcResponse.SerializeToString,
            ),
            'FileCreateDirectory': grpc.unary_unary_rpc_method_handler(
                    servicer.FileCreateDirectory,
                    request_deserializer=file__rpc_dot_file__crud__pb2.FileCreateDirectoryRpcRequest.FromString,
                    response_serializer=file__rpc_dot_file__crud__pb2.FileCreateDirectoryRpcResponse.SerializeToString,
            ),
            'FileDelete': grpc.unary_unary_rpc_method_handler(
                    servicer.FileDelete,
                    request_deserializer=file__rpc_dot_file__crud__pb2.FileDeleteRpcRequest.FromString,
                    response_serializer=file__rpc_dot_file__crud__pb2.FileDeleteRpcResponse.SerializeToString,
            ),
            'FileMove': grpc.unary_unary_rpc_method_handler(
                    servicer.FileMove,
                    request_deserializer=file__rpc_dot_file__crud__pb2.FileMoveRpcRequest.FromString,
                    response_serializer=file__rpc_dot_file__crud__pb2.FileMoveRpcResponse.SerializeToString,
            ),
            'FileCopy': grpc.unary_unary_rpc_method_handler(
                    servicer.FileCopy,
                    request_deserializer=file__rpc_dot_file__crud__pb2.FileCopyRpcRequest.FromString,
                    response_serializer=file__rpc_dot_file__crud__pb2.FileCopyRpcResponse.SerializeToString,
            ),
            'FileGetInfo': grpc.unary_unary_rpc_method_handler(
                    servicer.FileGetInfo,
                    request_deserializer=file__rpc_dot_file__crud__pb2.FileGetInfoRpcRequest.FromString,
                    response_serializer=file__rpc_dot_file__crud__pb2.FileGetInfoRpcResponse.SerializeToString,
            ),
            'FileCreateArchive': grpc.unary_unary_rpc_method_handler(
                    servicer.FileCreateArchive,
                    request_deserializer=file__rpc_dot_archive__pb2.FileCreateArchiveRpcRequest.FromString,
                    response_serializer=file__rpc_dot_archive__pb2.FileCreateArchiveRpcResponse.SerializeToString,
            ),
            'FileSearch': grpc.unary_unary_rpc_method_handler(
                    servicer.FileSearch,
                    request_deserializer=file__rpc_dot_search__pb2.FileSearchRpcRequest.FromString,
                    response_serializer=file__rpc_dot_search__pb2.FileSearchRpcResponse.SerializeToString,
            ),
            'HlsGetPlaylist': grpc.unary_unary_rpc_method_handler(
                    servicer.HlsGetPlaylist,
                    request_deserializer=file__rpc_dot_hls__pb2.HlsGetPlaylistRpcRequest.FromString,
                    response_serializer=file__rpc_dot_hls__pb2.HlsGetPlaylistRpcResponse.SerializeToString,
            ),
            'HlsGetSegment': grpc.unary_unary_rpc_method_handler(
                    servicer.HlsGetSegment,
                    request_deserializer=file__rpc_dot_hls__pb2.HlsGetSegmentRpcRequest.FromString,
                    response_serializer=file__rpc_dot_hls__pb2.HlsGetSegmentRpcResponse.SerializeToString,
            ),
            'HlsStopSession': grpc.unary_unary_rpc_method_handler(
                    servicer.HlsStopSession,
                    request_deserializer=file__rpc_dot_hls__pb2.HlsStopSessionRpcRequest.FromString,
                    response_serializer=file__rpc_dot_hls__pb2.HlsStopSessionRpcResponse.SerializeToString,
            ),
            'InitiateStreamingRelay': grpc.unary_unary_rpc_method_handler(
                    servicer.InitiateStreamingRelay,
                    request_deserializer=file__operations_dot_transfer__pb2.StreamingRelayRequest.FromString,
                    response_serializer=file__operations_dot_transfer__pb2.StreamingRelayResponse.SerializeToString,
            ),
            'RelayChunk': grpc.unary_unary_rpc_method_handler(
                    servicer.RelayChunk,
                    request_deserializer=file__operations_dot_transfer__pb2.StreamingRelayChunk.FromString,
                    response_serializer=file__operations_dot_transfer__pb2.StreamingRelayAck.SerializeToString,
            ),
            'GetStreamingRelayStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.GetStreamingRelayStatus,
                    request_deserializer=file__operations_dot_transfer__pb2.StreamingRelayStatusRequest.FromString,
                    response_serializer=file__operations_dot_transfer__pb2.StreamingRelayStatus.SerializeToString,
            ),
            'CancelStreamingRelay': grpc.unary_unary_rpc_method_handler(
                    servicer.CancelStreamingRelay,
                    request_deserializer=file__operations_dot_transfer__pb2.StreamingRelayCancelRequest.FromString,
                    response_serializer=file__operations_dot_transfer__pb2.StreamingRelayCancelResponse.SerializeToString,
            ),
            'SendPushNotification': grpc.unary_unary_rpc_method_handler(
                    servicer.SendPushNotification,
                    request_deserializer=rpc__messages_dot_push__pb2.SendPushNotificationRequest.FromString,
                    response_serializer=rpc__messages_dot_push__pb2.SendPushNotificationResponse.SerializeToString,
            ),
            'Extract': grpc.unary_unary_rpc_method_handler(
                    servicer.Extract,
                    request_deserializer=rpc__messages_dot_extract__pb2.ExtractRequest.FromString,
                    response_serializer=rpc__messages_dot_extract__pb2.ExtractResponse.SerializeToString,
            ),
            'RunAgent': grpc.unary_unary_rpc_method_handler(
                    servicer.RunAgent,
                    request_deserializer=rpc__messages_dot_agent__pb2.RunAgentRequest.FromString,
                    response_serializer=rpc__messages_dot_agent__pb2.RunAgentResponse.SerializeToString,
            ),
            'RunAgentStream': grpc.unary_stream_rpc_method_handler(
                    servicer.RunAgentStream,
                    request_deserializer=rpc__messages_dot_agent__pb2.RunAgentRequest.FromString,
                    response_serializer=rpc__messages_dot_agent__pb2.RunAgentStreamResponse.SerializeToString,
            ),
            'CancelAgent': grpc.unary_unary_rpc_method_handler(
                    servicer.CancelAgent,
                    request_deserializer=rpc__messages_dot_agent__pb2.CancelAgentRequest.FromString,
                    response_serializer=rpc__messages_dot_agent__pb2.CancelAgentResponse.SerializeToString,
            ),
            'SkillList': grpc.unary_unary_rpc_method_handler(
                    servicer.SkillList,
                    request_deserializer=rpc__messages_dot_skills__pb2.SkillListRequest.FromString,
                    response_serializer=rpc__messages_dot_skills__pb2.SkillListResponse.SerializeToString,
            ),
            'SkillShow': grpc.unary_unary_rpc_method_handler(
                    servicer.SkillShow,
                    request_deserializer=rpc__messages_dot_skills__pb2.SkillShowRequest.FromString,
                    response_serializer=rpc__messages_dot_skills__pb2.SkillShowResponse.SerializeToString,
            ),
            'SkillRun': grpc.unary_unary_rpc_method_handler(
                    servicer.SkillRun,
                    request_deserializer=rpc__messages_dot_skills__pb2.SkillRunRequest.FromString,
                    response_serializer=rpc__messages_dot_skills__pb2.SkillRunResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'terminal.TerminalStreamingService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('terminal.TerminalStreamingService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class TerminalStreamingService(object):
    """============================================================================
    SERVICE DEFINITION
    ============================================================================

    """

    @staticmethod
    def ConnectTerminal(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_stream(
            request_iterator,
            target,
            '/terminal.TerminalStreamingService/ConnectTerminal',
            agent__messages__pb2.AgentMessage.SerializeToString,
            control__messages__pb2.ControlMessage.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetChallenge(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,
            '/terminal.TerminalStreamingService/GetChallenge',
            service__pb2.GetChallengeRequest.SerializeToString,
            service__pb2.GetChallengeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateSession(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,
            '/terminal.TerminalStreamingService/CreateSession',
            rpc__messages_dot_session__pb2.CreateSessionRequest.SerializeToString,
            rpc__messages_dot_session__pb2.CreateSessionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CloseSession(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,
            '/terminal.TerminalStreamingService/CloseSession',
            rpc__messages_dot_session__pb2.CloseSessionRequest.SerializeToString,
            rpc__messages_dot_session__pb2.CloseSessionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetSessionStatus(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,
            '/terminal.TerminalStreamingService/GetSessionStatus',
            rpc__messages_dot_session__pb2.GetSessionStatusRequest.SerializeToString,
            rpc__messages_dot_session__pb2.GetSessionStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListSessions(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,
            '/terminal.TerminalStreamingService/ListSessions',
            rpc__messages_dot_session__pb2.ListSessionsRequest.SerializeToString,
            rpc__messages_dot_session__pb2.ListSessionsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetSessionByHostname(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,
            '/terminal.TerminalStreamingService/GetSessionByHostname',
            rpc__messages_dot_session__pb2.GetSessionByHostnameRequest.SerializeToString,
            rpc__messages_dot_session__pb2.GetSessionByHostnameResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SendInput(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,
            '/terminal.TerminalStreamingService/SendInput',
            rpc__messages_dot_terminal__pb2.SendInputRequest.SerializeToString,
            rpc__messages_dot_terminal__pb2.SendInputResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SendResize(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,
            '/terminal.TerminalStreamingService/SendResize',
            rpc__messages_dot_terminal__pb2.SendResizeRequest.SerializeToString,
            rpc__messages_dot_terminal__pb2.SendResizeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SendSignal(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,
            '/terminal.TerminalStreamingService/SendSignal',
            rpc__messages_dot_terminal__pb2.SendSignalRequest.SerializeToString,
            rpc__messages_dot_terminal__pb2.SendSignalResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetHistory(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,
            '/terminal.TerminalStreamingService/GetHistory',
            rpc__messages_dot_history__pb2.GetHistoryRequest.SerializeToString,
            rpc__messages_dot_history__pb2.GetHistoryResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetOutput(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,
            '/terminal.TerminalStreamingService/GetOutput',
            rpc__messages_dot_history__pb2.GetOutputRequest.SerializeToString,
            rpc__messages_dot_history__pb2.GetOutputResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def HealthCheck(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,
            '/terminal.TerminalStreamingService/HealthCheck',
            rpc__messages_dot_health__pb2.HealthCheckRequest.SerializeToString,
            rpc__messages_dot_health__pb2.HealthCheckResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RegisterDeviceToken(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,
            '/terminal.TerminalStreamingService/RegisterDeviceToken',
            rpc__messages_dot_device__pb2.RegisterDeviceTokenRequest.SerializeToString,
            rpc__messages_dot_device__pb2.RegisterDeviceTokenResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UnregisterDeviceToken(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,
            '/terminal.TerminalStreamingService/UnregisterDeviceToken',
            rpc__messages_dot_device__pb2.UnregisterDeviceTokenRequest.SerializeToString,
            rpc__messages_dot_device__pb2.UnregisterDeviceTokenResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def EnterBackground(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,
            '/terminal.TerminalStreamingService/EnterBackground',
            rpc__messages_dot_lifecycle__pb2.EnterBackgroundRequest.SerializeToString,
            rpc__messages_dot_lifecycle__pb2.EnterBackgroundResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def WakeFromBackground(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,
            '/terminal.TerminalStreamingService/WakeFromBackground',
            rpc__messages_dot_lifecycle__pb2.WakeFromBackgroundRequest.SerializeToString,
            rpc__messages_dot_lifecycle__pb2.WakeFromBackgroundResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def QueueCommand(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,
            '/terminal.TerminalStreamingService/QueueCommand',
            rpc__messages_dot_lifecycle__pb2.QueueCommandRequest.SerializeToString,
            rpc__messages_dot_lifecycle__pb2.QueueCommandResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FileListDirectory(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,
            '/terminal.TerminalStreamingService/FileListDirectory',
            file__rpc_dot_directory__pb2.FileListDirectoryRpcRequest.SerializeToString,
            file__rpc_dot_directory__pb2.FileListDirectoryRpcResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FileRead(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,
            '/terminal.TerminalStreamingService/FileRead',
            file__rpc_dot_file__crud__pb2.FileReadRpcRequest.SerializeToString,
            file__rpc_dot_file__crud__pb2.FileReadRpcResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FileWrite(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,
            '/terminal.TerminalStreamingService/FileWrite',
            file__rpc_dot_file__crud__pb2.FileWriteRpcRequest.SerializeToString,
            file__rpc_dot_file__crud__pb2.FileWriteRpcResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FileCreateDirectory(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,
            '/terminal.TerminalStreamingService/FileCreateDirectory',
            file__rpc_dot_file__crud__pb2.FileCreateDirectoryRpcRequest.SerializeToString,
            file__rpc_dot_file__crud__pb2.FileCreateDirectoryRpcResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FileDelete(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,
            '/terminal.TerminalStreamingService/FileDelete',
            file__rpc_dot_file__crud__pb2.FileDeleteRpcRequest.SerializeToString,
            file__rpc_dot_file__crud__pb2.FileDeleteRpcResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FileMove(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,
            '/terminal.TerminalStreamingService/FileMove',
            file__rpc_dot_file__crud__pb2.FileMoveRpcRequest.SerializeToString,
            file__rpc_dot_file__crud__pb2.FileMoveRpcResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FileCopy(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,
            '/terminal.TerminalStreamingService/FileCopy',
            file__rpc_dot_file__crud__pb2.FileCopyRpcRequest.SerializeToString,
            file__rpc_dot_file__crud__pb2.FileCopyRpcResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FileGetInfo(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,
            '/terminal.TerminalStreamingService/FileGetInfo',
            file__rpc_dot_file__crud__pb2.FileGetInfoRpcRequest.SerializeToString,
            file__rpc_dot_file__crud__pb2.FileGetInfoRpcResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FileCreateArchive(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,
            '/terminal.TerminalStreamingService/FileCreateArchive',
            file__rpc_dot_archive__pb2.FileCreateArchiveRpcRequest.SerializeToString,
            file__rpc_dot_archive__pb2.FileCreateArchiveRpcResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FileSearch(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,
            '/terminal.TerminalStreamingService/FileSearch',
            file__rpc_dot_search__pb2.FileSearchRpcRequest.SerializeToString,
            file__rpc_dot_search__pb2.FileSearchRpcResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def HlsGetPlaylist(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,
            '/terminal.TerminalStreamingService/HlsGetPlaylist',
            file__rpc_dot_hls__pb2.HlsGetPlaylistRpcRequest.SerializeToString,
            file__rpc_dot_hls__pb2.HlsGetPlaylistRpcResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def HlsGetSegment(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,
            '/terminal.TerminalStreamingService/HlsGetSegment',
            file__rpc_dot_hls__pb2.HlsGetSegmentRpcRequest.SerializeToString,
            file__rpc_dot_hls__pb2.HlsGetSegmentRpcResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def HlsStopSession(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,
            '/terminal.TerminalStreamingService/HlsStopSession',
            file__rpc_dot_hls__pb2.HlsStopSessionRpcRequest.SerializeToString,
            file__rpc_dot_hls__pb2.HlsStopSessionRpcResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def InitiateStreamingRelay(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,
            '/terminal.TerminalStreamingService/InitiateStreamingRelay',
            file__operations_dot_transfer__pb2.StreamingRelayRequest.SerializeToString,
            file__operations_dot_transfer__pb2.StreamingRelayResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RelayChunk(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,
            '/terminal.TerminalStreamingService/RelayChunk',
            file__operations_dot_transfer__pb2.StreamingRelayChunk.SerializeToString,
            file__operations_dot_transfer__pb2.StreamingRelayAck.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetStreamingRelayStatus(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,
            '/terminal.TerminalStreamingService/GetStreamingRelayStatus',
            file__operations_dot_transfer__pb2.StreamingRelayStatusRequest.SerializeToString,
            file__operations_dot_transfer__pb2.StreamingRelayStatus.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CancelStreamingRelay(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,
            '/terminal.TerminalStreamingService/CancelStreamingRelay',
            file__operations_dot_transfer__pb2.StreamingRelayCancelRequest.SerializeToString,
            file__operations_dot_transfer__pb2.StreamingRelayCancelResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SendPushNotification(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,
            '/terminal.TerminalStreamingService/SendPushNotification',
            rpc__messages_dot_push__pb2.SendPushNotificationRequest.SerializeToString,
            rpc__messages_dot_push__pb2.SendPushNotificationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Extract(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,
            '/terminal.TerminalStreamingService/Extract',
            rpc__messages_dot_extract__pb2.ExtractRequest.SerializeToString,
            rpc__messages_dot_extract__pb2.ExtractResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RunAgent(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,
            '/terminal.TerminalStreamingService/RunAgent',
            rpc__messages_dot_agent__pb2.RunAgentRequest.SerializeToString,
            rpc__messages_dot_agent__pb2.RunAgentResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RunAgentStream(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,
            '/terminal.TerminalStreamingService/RunAgentStream',
            rpc__messages_dot_agent__pb2.RunAgentRequest.SerializeToString,
            rpc__messages_dot_agent__pb2.RunAgentStreamResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CancelAgent(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,
            '/terminal.TerminalStreamingService/CancelAgent',
            rpc__messages_dot_agent__pb2.CancelAgentRequest.SerializeToString,
            rpc__messages_dot_agent__pb2.CancelAgentResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SkillList(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,
            '/terminal.TerminalStreamingService/SkillList',
            rpc__messages_dot_skills__pb2.SkillListRequest.SerializeToString,
            rpc__messages_dot_skills__pb2.SkillListResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SkillShow(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,
            '/terminal.TerminalStreamingService/SkillShow',
            rpc__messages_dot_skills__pb2.SkillShowRequest.SerializeToString,
            rpc__messages_dot_skills__pb2.SkillShowResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SkillRun(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,
            '/terminal.TerminalStreamingService/SkillRun',
            rpc__messages_dot_skills__pb2.SkillRunRequest.SerializeToString,
            rpc__messages_dot_skills__pb2.SkillRunResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
