"""
@generated by mypy-protobuf.  Do not edit manually!
isort:skip_file
"""
import sys

if sys.version_info >= (3, 10):
    import typing as typing_extensions
else:
    import typing_extensions
from builtins import (
    bool,
    bytes,
    int,
    str,
    type,
)
from collections.abc import (
    Iterable,
)
from ..commonpb.common_pb2 import (
    EnvVar,
    Process,
    Request,
    Response,
)
from google.protobuf.descriptor import (
    Descriptor,
    EnumDescriptor,
    FileDescriptor,
)
from google.protobuf.internal.containers import (
    RepeatedCompositeFieldContainer,
    RepeatedScalarFieldContainer,
)
from google.protobuf.internal.enum_type_wrapper import (
    _EnumTypeWrapper,
)
from google.protobuf.message import (
    Message,
)
from typing import (
    NewType,
)

DESCRIPTOR: FileDescriptor

class _RegistryType:
    ValueType = NewType("ValueType", int)
    V: typing_extensions.TypeAlias = ValueType

class _RegistryTypeEnumTypeWrapper(
    _EnumTypeWrapper[_RegistryType.ValueType], type
):  # noqa: F821
    DESCRIPTOR: EnumDescriptor
    Unknown: _RegistryType.ValueType  # 0
    Binary: _RegistryType.ValueType  # 1
    String: _RegistryType.ValueType  # 2
    DWORD: _RegistryType.ValueType  # 3
    QWORD: _RegistryType.ValueType  # 4

class RegistryType(_RegistryType, metaclass=_RegistryTypeEnumTypeWrapper):
    """Registry - Registry related messages"""

Unknown: RegistryType.ValueType  # 0
Binary: RegistryType.ValueType  # 1
String: RegistryType.ValueType  # 2
DWORD: RegistryType.ValueType  # 3
QWORD: RegistryType.ValueType  # 4

class _PivotType:
    ValueType = NewType("ValueType", int)
    V: typing_extensions.TypeAlias = ValueType

class _PivotTypeEnumTypeWrapper(
    _EnumTypeWrapper[_PivotType.ValueType], type
):  # noqa: F821
    DESCRIPTOR: EnumDescriptor
    TCP: _PivotType.ValueType  # 0
    UDP: _PivotType.ValueType  # 1
    NamedPipe: _PivotType.ValueType  # 2

class PivotType(_PivotType, metaclass=_PivotTypeEnumTypeWrapper):
    """*** Pivots ***"""

TCP: PivotType.ValueType  # 0
UDP: PivotType.ValueType  # 1
NamedPipe: PivotType.ValueType  # 2

class _PeerFailureType:
    ValueType = NewType("ValueType", int)
    V: typing_extensions.TypeAlias = ValueType

class _PeerFailureTypeEnumTypeWrapper(
    _EnumTypeWrapper[_PeerFailureType.ValueType], type
):  # noqa: F821
    DESCRIPTOR: EnumDescriptor
    SEND_FAILURE: _PeerFailureType.ValueType  # 0
    DISCONNECT: _PeerFailureType.ValueType  # 1

class PeerFailureType(_PeerFailureType, metaclass=_PeerFailureTypeEnumTypeWrapper): ...

SEND_FAILURE: PeerFailureType.ValueType  # 0
DISCONNECT: PeerFailureType.ValueType  # 1

class Envelope(Message):
    """

    >>> Reserved Numbers <<<

    For tunnel messages:
    uint64 TunnelID = 8 [jstype = JS_STRING]; // JS can't represent a uint64
    uint32 SessionID = 9;

    For request/response messages:
    Request Request = 9;
    Response Response = 9;

    - Request messages should be named with the suffix "Req"

    Envelope - Used to encode implant<->server messages since we
               cannot use gRPC due to the various transports used.
    """

    DESCRIPTOR: Descriptor

    ID_FIELD_NUMBER: int
    TYPE_FIELD_NUMBER: int
    DATA_FIELD_NUMBER: int
    UNKNOWNMESSAGETYPE_FIELD_NUMBER: int
    ID: int
    """Envelope ID used to track request/response"""
    Type: int
    """Message type"""
    Data: bytes
    """Actual message data"""
    UnknownMessageType: bool
    """Set if the implant did not understand the message"""
    def __init__(
        self,
        *,
        ID: int = ...,
        Type: int = ...,
        Data: bytes = ...,
        UnknownMessageType: bool = ...,
    ) -> None: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Data",
            b"Data",
            "ID",
            b"ID",
            "Type",
            b"Type",
            "UnknownMessageType",
            b"UnknownMessageType",
        ],
    ) -> None: ...

class BeaconTasks(Message):
    """BeaconTasks - DO NOT CONFUSE WITH clientpb.BeaconTasks"""

    DESCRIPTOR: Descriptor

    ID_FIELD_NUMBER: int
    TASKS_FIELD_NUMBER: int
    NEXTCHECKIN_FIELD_NUMBER: int
    ID: str
    @property
    def Tasks(self) -> RepeatedCompositeFieldContainer[Envelope]: ...
    NextCheckin: int
    def __init__(
        self,
        *,
        ID: str = ...,
        Tasks: Iterable[Envelope] | None = ...,
        NextCheckin: int = ...,
    ) -> None: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "ID", b"ID", "NextCheckin", b"NextCheckin", "Tasks", b"Tasks"
        ],
    ) -> None: ...

class Register(Message):
    """Register - First message the implant sends to the server"""

    DESCRIPTOR: Descriptor

    NAME_FIELD_NUMBER: int
    HOSTNAME_FIELD_NUMBER: int
    UUID_FIELD_NUMBER: int
    USERNAME_FIELD_NUMBER: int
    UID_FIELD_NUMBER: int
    GID_FIELD_NUMBER: int
    OS_FIELD_NUMBER: int
    ARCH_FIELD_NUMBER: int
    PID_FIELD_NUMBER: int
    FILENAME_FIELD_NUMBER: int
    ACTIVEC2_FIELD_NUMBER: int
    VERSION_FIELD_NUMBER: int
    RECONNECTINTERVAL_FIELD_NUMBER: int
    PROXYURL_FIELD_NUMBER: int
    CONFIGID_FIELD_NUMBER: int
    PEERID_FIELD_NUMBER: int
    LOCALE_FIELD_NUMBER: int
    Name: str
    Hostname: str
    Uuid: str
    Username: str
    Uid: str
    Gid: str
    Os: str
    Arch: str
    Pid: int
    Filename: str
    ActiveC2: str
    Version: str
    ReconnectInterval: int
    ProxyURL: str
    ConfigID: str
    PeerID: int
    Locale: str
    def __init__(
        self,
        *,
        Name: str = ...,
        Hostname: str = ...,
        Uuid: str = ...,
        Username: str = ...,
        Uid: str = ...,
        Gid: str = ...,
        Os: str = ...,
        Arch: str = ...,
        Pid: int = ...,
        Filename: str = ...,
        ActiveC2: str = ...,
        Version: str = ...,
        ReconnectInterval: int = ...,
        ProxyURL: str = ...,
        ConfigID: str = ...,
        PeerID: int = ...,
        Locale: str = ...,
    ) -> None: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "ActiveC2",
            b"ActiveC2",
            "Arch",
            b"Arch",
            "ConfigID",
            b"ConfigID",
            "Filename",
            b"Filename",
            "Gid",
            b"Gid",
            "Hostname",
            b"Hostname",
            "Locale",
            b"Locale",
            "Name",
            b"Name",
            "Os",
            b"Os",
            "PeerID",
            b"PeerID",
            "Pid",
            b"Pid",
            "ProxyURL",
            b"ProxyURL",
            "ReconnectInterval",
            b"ReconnectInterval",
            "Uid",
            b"Uid",
            "Username",
            b"Username",
            "Uuid",
            b"Uuid",
            "Version",
            b"Version",
        ],
    ) -> None: ...

class BeaconRegister(Message):
    DESCRIPTOR: Descriptor

    ID_FIELD_NUMBER: int
    INTERVAL_FIELD_NUMBER: int
    JITTER_FIELD_NUMBER: int
    REGISTER_FIELD_NUMBER: int
    NEXTCHECKIN_FIELD_NUMBER: int
    ID: str
    Interval: int
    Jitter: int
    @property
    def Register(self) -> Register: ...
    NextCheckin: int
    def __init__(
        self,
        *,
        ID: str = ...,
        Interval: int = ...,
        Jitter: int = ...,
        Register: Register | None = ...,
        NextCheckin: int = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Register", b"Register"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "ID",
            b"ID",
            "Interval",
            b"Interval",
            "Jitter",
            b"Jitter",
            "NextCheckin",
            b"NextCheckin",
            "Register",
            b"Register",
        ],
    ) -> None: ...

class SessionRegister(Message):
    DESCRIPTOR: Descriptor

    ID_FIELD_NUMBER: int
    REGISTER_FIELD_NUMBER: int
    ID: str
    @property
    def Register(self) -> Register: ...
    def __init__(
        self,
        *,
        ID: str = ...,
        Register: Register | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Register", b"Register"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal["ID", b"ID", "Register", b"Register"],
    ) -> None: ...

class OpenSession(Message):
    DESCRIPTOR: Descriptor

    C2S_FIELD_NUMBER: int
    DELAY_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    @property
    def C2s(self) -> RepeatedScalarFieldContainer[str]: ...
    Delay: int
    @property
    def Response(self) -> Response: ...
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        C2s: Iterable[str] | None = ...,
        Delay: int = ...,
        Response: Response | None = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self,
        field_name: typing_extensions.Literal[
            "Request", b"Request", "Response", b"Response"
        ],
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "C2s",
            b"C2s",
            "Delay",
            b"Delay",
            "Request",
            b"Request",
            "Response",
            b"Response",
        ],
    ) -> None: ...

class CloseSession(Message):
    DESCRIPTOR: Descriptor

    RESPONSE_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    @property
    def Response(self) -> Response:
        """No message content"""
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Response: Response | None = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self,
        field_name: typing_extensions.Literal[
            "Request", b"Request", "Response", b"Response"
        ],
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Request", b"Request", "Response", b"Response"
        ],
    ) -> None: ...

class Ping(Message):
    """Ping - Not ICMP, just sends a rount trip message to an implant to
    see if it's still responding.
    """

    DESCRIPTOR: Descriptor

    NONCE_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Nonce: int
    @property
    def Response(self) -> Response:
        """Ping is special"""
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Nonce: int = ...,
        Response: Response | None = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self,
        field_name: typing_extensions.Literal[
            "Request", b"Request", "Response", b"Response"
        ],
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Nonce", b"Nonce", "Request", b"Request", "Response", b"Response"
        ],
    ) -> None: ...

class KillReq(Message):
    """KillSessionReq - Request the implant to kill a session"""

    DESCRIPTOR: Descriptor

    FORCE_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Force: bool
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Force: bool = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal["Force", b"Force", "Request", b"Request"],
    ) -> None: ...

class PsReq(Message):
    """PsReq - Request the implant to list ses of a remote session."""

    DESCRIPTOR: Descriptor

    REQUEST_FIELD_NUMBER: int
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> None: ...

class Ps(Message):
    DESCRIPTOR: Descriptor

    PROCESSES_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    @property
    def Processes(self) -> RepeatedCompositeFieldContainer[Process]: ...
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Processes: Iterable[Process] | None = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Processes", b"Processes", "Response", b"Response"
        ],
    ) -> None: ...

class TerminateReq(Message):
    """TerminateReq - Request the implant terminate a remote processes"""

    DESCRIPTOR: Descriptor

    PID_FIELD_NUMBER: int
    FORCE_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Pid: int
    Force: bool
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Pid: int = ...,
        Force: bool = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Force", b"Force", "Pid", b"Pid", "Request", b"Request"
        ],
    ) -> None: ...

class Terminate(Message):
    DESCRIPTOR: Descriptor

    PID_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    Pid: int
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Pid: int = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal["Pid", b"Pid", "Response", b"Response"],
    ) -> None: ...

class IfconfigReq(Message):
    """IfconfigReq - Request the implant to list network interfaces"""

    DESCRIPTOR: Descriptor

    REQUEST_FIELD_NUMBER: int
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> None: ...

class Ifconfig(Message):
    DESCRIPTOR: Descriptor

    NETINTERFACES_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    @property
    def NetInterfaces(self) -> RepeatedCompositeFieldContainer[NetInterface]: ...
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        NetInterfaces: Iterable[NetInterface] | None = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "NetInterfaces", b"NetInterfaces", "Response", b"Response"
        ],
    ) -> None: ...

class NetInterface(Message):
    DESCRIPTOR: Descriptor

    INDEX_FIELD_NUMBER: int
    NAME_FIELD_NUMBER: int
    MAC_FIELD_NUMBER: int
    IPADDRESSES_FIELD_NUMBER: int
    Index: int
    Name: str
    MAC: str
    @property
    def IPAddresses(self) -> RepeatedScalarFieldContainer[str]: ...
    def __init__(
        self,
        *,
        Index: int = ...,
        Name: str = ...,
        MAC: str = ...,
        IPAddresses: Iterable[str] | None = ...,
    ) -> None: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "IPAddresses",
            b"IPAddresses",
            "Index",
            b"Index",
            "MAC",
            b"MAC",
            "Name",
            b"Name",
        ],
    ) -> None: ...

class LsReq(Message):
    DESCRIPTOR: Descriptor

    PATH_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Path: str
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Path: str = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal["Path", b"Path", "Request", b"Request"],
    ) -> None: ...

class Ls(Message):
    DESCRIPTOR: Descriptor

    PATH_FIELD_NUMBER: int
    EXISTS_FIELD_NUMBER: int
    FILES_FIELD_NUMBER: int
    TIMEZONE_FIELD_NUMBER: int
    TIMEZONEOFFSET_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    Path: str
    Exists: bool
    @property
    def Files(self) -> RepeatedCompositeFieldContainer[FileInfo]: ...
    timezone: str
    timezoneOffset: int
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Path: str = ...,
        Exists: bool = ...,
        Files: Iterable[FileInfo] | None = ...,
        timezone: str = ...,
        timezoneOffset: int = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Exists",
            b"Exists",
            "Files",
            b"Files",
            "Path",
            b"Path",
            "Response",
            b"Response",
            "timezone",
            b"timezone",
            "timezoneOffset",
            b"timezoneOffset",
        ],
    ) -> None: ...

class FileInfo(Message):
    DESCRIPTOR: Descriptor

    NAME_FIELD_NUMBER: int
    ISDIR_FIELD_NUMBER: int
    SIZE_FIELD_NUMBER: int
    MODTIME_FIELD_NUMBER: int
    MODE_FIELD_NUMBER: int
    LINK_FIELD_NUMBER: int
    Name: str
    IsDir: bool
    Size: int
    ModTime: int
    Mode: str
    Link: str
    def __init__(
        self,
        *,
        Name: str = ...,
        IsDir: bool = ...,
        Size: int = ...,
        ModTime: int = ...,
        Mode: str = ...,
        Link: str = ...,
    ) -> None: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "IsDir",
            b"IsDir",
            "Link",
            b"Link",
            "ModTime",
            b"ModTime",
            "Mode",
            b"Mode",
            "Name",
            b"Name",
            "Size",
            b"Size",
        ],
    ) -> None: ...

class CdReq(Message):
    DESCRIPTOR: Descriptor

    PATH_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Path: str
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Path: str = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal["Path", b"Path", "Request", b"Request"],
    ) -> None: ...

class PwdReq(Message):
    DESCRIPTOR: Descriptor

    REQUEST_FIELD_NUMBER: int
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> None: ...

class Pwd(Message):
    DESCRIPTOR: Descriptor

    PATH_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    Path: str
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Path: str = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal["Path", b"Path", "Response", b"Response"],
    ) -> None: ...

class RmReq(Message):
    DESCRIPTOR: Descriptor

    PATH_FIELD_NUMBER: int
    RECURSIVE_FIELD_NUMBER: int
    FORCE_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Path: str
    Recursive: bool
    Force: bool
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Path: str = ...,
        Recursive: bool = ...,
        Force: bool = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Force",
            b"Force",
            "Path",
            b"Path",
            "Recursive",
            b"Recursive",
            "Request",
            b"Request",
        ],
    ) -> None: ...

class Rm(Message):
    DESCRIPTOR: Descriptor

    PATH_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    Path: str
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Path: str = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal["Path", b"Path", "Response", b"Response"],
    ) -> None: ...

class MvReq(Message):
    DESCRIPTOR: Descriptor

    SRC_FIELD_NUMBER: int
    DST_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Src: str
    Dst: str
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Src: str = ...,
        Dst: str = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Dst", b"Dst", "Request", b"Request", "Src", b"Src"
        ],
    ) -> None: ...

class Mv(Message):
    DESCRIPTOR: Descriptor

    SRC_FIELD_NUMBER: int
    DST_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    Src: str
    Dst: str
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Src: str = ...,
        Dst: str = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Dst", b"Dst", "Response", b"Response", "Src", b"Src"
        ],
    ) -> None: ...

class MkdirReq(Message):
    DESCRIPTOR: Descriptor

    PATH_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Path: str
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Path: str = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal["Path", b"Path", "Request", b"Request"],
    ) -> None: ...

class Mkdir(Message):
    DESCRIPTOR: Descriptor

    PATH_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    Path: str
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Path: str = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal["Path", b"Path", "Response", b"Response"],
    ) -> None: ...

class DownloadReq(Message):
    DESCRIPTOR: Descriptor

    PATH_FIELD_NUMBER: int
    START_FIELD_NUMBER: int
    STOP_FIELD_NUMBER: int
    RECURSE_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Path: str
    Start: int
    Stop: int
    Recurse: bool
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Path: str = ...,
        Start: int = ...,
        Stop: int = ...,
        Recurse: bool = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Path",
            b"Path",
            "Recurse",
            b"Recurse",
            "Request",
            b"Request",
            "Start",
            b"Start",
            "Stop",
            b"Stop",
        ],
    ) -> None: ...

class Download(Message):
    DESCRIPTOR: Descriptor

    PATH_FIELD_NUMBER: int
    ENCODER_FIELD_NUMBER: int
    EXISTS_FIELD_NUMBER: int
    START_FIELD_NUMBER: int
    STOP_FIELD_NUMBER: int
    DATA_FIELD_NUMBER: int
    ISDIR_FIELD_NUMBER: int
    READFILES_FIELD_NUMBER: int
    UNREADABLEFILES_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    Path: str
    Encoder: str
    Exists: bool
    Start: int
    Stop: int
    Data: bytes
    IsDir: bool
    ReadFiles: int
    UnreadableFiles: int
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Path: str = ...,
        Encoder: str = ...,
        Exists: bool = ...,
        Start: int = ...,
        Stop: int = ...,
        Data: bytes = ...,
        IsDir: bool = ...,
        ReadFiles: int = ...,
        UnreadableFiles: int = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Data",
            b"Data",
            "Encoder",
            b"Encoder",
            "Exists",
            b"Exists",
            "IsDir",
            b"IsDir",
            "Path",
            b"Path",
            "ReadFiles",
            b"ReadFiles",
            "Response",
            b"Response",
            "Start",
            b"Start",
            "Stop",
            b"Stop",
            "UnreadableFiles",
            b"UnreadableFiles",
        ],
    ) -> None: ...

class UploadReq(Message):
    DESCRIPTOR: Descriptor

    PATH_FIELD_NUMBER: int
    ENCODER_FIELD_NUMBER: int
    DATA_FIELD_NUMBER: int
    ISIOC_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Path: str
    Encoder: str
    Data: bytes
    IsIOC: bool
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Path: str = ...,
        Encoder: str = ...,
        Data: bytes = ...,
        IsIOC: bool = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Data",
            b"Data",
            "Encoder",
            b"Encoder",
            "IsIOC",
            b"IsIOC",
            "Path",
            b"Path",
            "Request",
            b"Request",
        ],
    ) -> None: ...

class Upload(Message):
    DESCRIPTOR: Descriptor

    PATH_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    Path: str
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Path: str = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal["Path", b"Path", "Response", b"Response"],
    ) -> None: ...

class ProcessDumpReq(Message):
    DESCRIPTOR: Descriptor

    PID_FIELD_NUMBER: int
    TIMEOUT_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Pid: int
    Timeout: int
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Pid: int = ...,
        Timeout: int = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Pid", b"Pid", "Request", b"Request", "Timeout", b"Timeout"
        ],
    ) -> None: ...

class ProcessDump(Message):
    DESCRIPTOR: Descriptor

    DATA_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    Data: bytes
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Data: bytes = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal["Data", b"Data", "Response", b"Response"],
    ) -> None: ...

class RunAsReq(Message):
    DESCRIPTOR: Descriptor

    USERNAME_FIELD_NUMBER: int
    PROCESSNAME_FIELD_NUMBER: int
    ARGS_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Username: str
    ProcessName: str
    Args: str
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Username: str = ...,
        ProcessName: str = ...,
        Args: str = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Args",
            b"Args",
            "ProcessName",
            b"ProcessName",
            "Request",
            b"Request",
            "Username",
            b"Username",
        ],
    ) -> None: ...

class RunAs(Message):
    DESCRIPTOR: Descriptor

    OUTPUT_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    Output: str
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Output: str = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Output", b"Output", "Response", b"Response"
        ],
    ) -> None: ...

class ImpersonateReq(Message):
    DESCRIPTOR: Descriptor

    USERNAME_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Username: str
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Username: str = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Request", b"Request", "Username", b"Username"
        ],
    ) -> None: ...

class Impersonate(Message):
    DESCRIPTOR: Descriptor

    RESPONSE_FIELD_NUMBER: int
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> None: ...

class RevToSelfReq(Message):
    DESCRIPTOR: Descriptor

    REQUEST_FIELD_NUMBER: int
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> None: ...

class RevToSelf(Message):
    DESCRIPTOR: Descriptor

    RESPONSE_FIELD_NUMBER: int
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> None: ...

class CurrentTokenOwnerReq(Message):
    DESCRIPTOR: Descriptor

    REQUEST_FIELD_NUMBER: int
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> None: ...

class CurrentTokenOwner(Message):
    DESCRIPTOR: Descriptor

    OUTPUT_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    Output: str
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Output: str = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Output", b"Output", "Response", b"Response"
        ],
    ) -> None: ...

class InvokeGetSystemReq(Message):
    """InvokeGetSystemReq - Implant-side version of GetSystemReq, this message
    contains the .Data based on the client's req.Config
    """

    DESCRIPTOR: Descriptor

    DATA_FIELD_NUMBER: int
    HOSTINGPROCESS_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Data: bytes
    HostingProcess: str
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Data: bytes = ...,
        HostingProcess: str = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Data", b"Data", "HostingProcess", b"HostingProcess", "Request", b"Request"
        ],
    ) -> None: ...

class GetSystem(Message):
    """GetSystem - The result of a InvokeGetSystemReq attempt"""

    DESCRIPTOR: Descriptor

    RESPONSE_FIELD_NUMBER: int
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> None: ...

class MakeTokenReq(Message):
    DESCRIPTOR: Descriptor

    USERNAME_FIELD_NUMBER: int
    PASSWORD_FIELD_NUMBER: int
    DOMAIN_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Username: str
    Password: str
    Domain: str
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Username: str = ...,
        Password: str = ...,
        Domain: str = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Domain",
            b"Domain",
            "Password",
            b"Password",
            "Request",
            b"Request",
            "Username",
            b"Username",
        ],
    ) -> None: ...

class MakeToken(Message):
    DESCRIPTOR: Descriptor

    RESPONSE_FIELD_NUMBER: int
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> None: ...

class TaskReq(Message):
    DESCRIPTOR: Descriptor

    ENCODER_FIELD_NUMBER: int
    RWXPAGES_FIELD_NUMBER: int
    PID_FIELD_NUMBER: int
    DATA_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Encoder: str
    RWXPages: bool
    Pid: int
    Data: bytes
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Encoder: str = ...,
        RWXPages: bool = ...,
        Pid: int = ...,
        Data: bytes = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Data",
            b"Data",
            "Encoder",
            b"Encoder",
            "Pid",
            b"Pid",
            "RWXPages",
            b"RWXPages",
            "Request",
            b"Request",
        ],
    ) -> None: ...

class Task(Message):
    DESCRIPTOR: Descriptor

    RESPONSE_FIELD_NUMBER: int
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> None: ...

class ExecuteAssemblyReq(Message):
    DESCRIPTOR: Descriptor

    ASSEMBLY_FIELD_NUMBER: int
    ARGUMENTS_FIELD_NUMBER: int
    PROCESS_FIELD_NUMBER: int
    ISDLL_FIELD_NUMBER: int
    ARCH_FIELD_NUMBER: int
    CLASSNAME_FIELD_NUMBER: int
    METHOD_FIELD_NUMBER: int
    APPDOMAIN_FIELD_NUMBER: int
    PPID_FIELD_NUMBER: int
    PROCESSARGS_FIELD_NUMBER: int
    INPROCESS_FIELD_NUMBER: int
    RUNTIME_FIELD_NUMBER: int
    AMSIBYPASS_FIELD_NUMBER: int
    ETWBYPASS_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Assembly: bytes
    Arguments: str
    Process: str
    IsDLL: bool
    Arch: str
    ClassName: str
    Method: str
    AppDomain: str
    PPid: int
    @property
    def ProcessArgs(self) -> RepeatedScalarFieldContainer[str]: ...
    InProcess: bool
    """In process specific fields"""
    Runtime: str
    AmsiBypass: bool
    EtwBypass: bool
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Assembly: bytes = ...,
        Arguments: str = ...,
        Process: str = ...,
        IsDLL: bool = ...,
        Arch: str = ...,
        ClassName: str = ...,
        Method: str = ...,
        AppDomain: str = ...,
        PPid: int = ...,
        ProcessArgs: Iterable[str] | None = ...,
        InProcess: bool = ...,
        Runtime: str = ...,
        AmsiBypass: bool = ...,
        EtwBypass: bool = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "AmsiBypass",
            b"AmsiBypass",
            "AppDomain",
            b"AppDomain",
            "Arch",
            b"Arch",
            "Arguments",
            b"Arguments",
            "Assembly",
            b"Assembly",
            "ClassName",
            b"ClassName",
            "EtwBypass",
            b"EtwBypass",
            "InProcess",
            b"InProcess",
            "IsDLL",
            b"IsDLL",
            "Method",
            b"Method",
            "PPid",
            b"PPid",
            "Process",
            b"Process",
            "ProcessArgs",
            b"ProcessArgs",
            "Request",
            b"Request",
            "Runtime",
            b"Runtime",
        ],
    ) -> None: ...

class InvokeExecuteAssemblyReq(Message):
    DESCRIPTOR: Descriptor

    DATA_FIELD_NUMBER: int
    PROCESS_FIELD_NUMBER: int
    PPID_FIELD_NUMBER: int
    PROCESSARGS_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Data: bytes
    process: str
    PPid: int
    @property
    def ProcessArgs(self) -> RepeatedScalarFieldContainer[str]: ...
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Data: bytes = ...,
        process: str = ...,
        PPid: int = ...,
        ProcessArgs: Iterable[str] | None = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Data",
            b"Data",
            "PPid",
            b"PPid",
            "ProcessArgs",
            b"ProcessArgs",
            "Request",
            b"Request",
            "process",
            b"process",
        ],
    ) -> None: ...

class InvokeInProcExecuteAssemblyReq(Message):
    DESCRIPTOR: Descriptor

    DATA_FIELD_NUMBER: int
    ARGUMENTS_FIELD_NUMBER: int
    RUNTIME_FIELD_NUMBER: int
    AMSIBYPASS_FIELD_NUMBER: int
    ETWBYPASS_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Data: bytes
    @property
    def Arguments(self) -> RepeatedScalarFieldContainer[str]: ...
    Runtime: str
    AmsiBypass: bool
    EtwBypass: bool
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Data: bytes = ...,
        Arguments: Iterable[str] | None = ...,
        Runtime: str = ...,
        AmsiBypass: bool = ...,
        EtwBypass: bool = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "AmsiBypass",
            b"AmsiBypass",
            "Arguments",
            b"Arguments",
            "Data",
            b"Data",
            "EtwBypass",
            b"EtwBypass",
            "Request",
            b"Request",
            "Runtime",
            b"Runtime",
        ],
    ) -> None: ...

class ExecuteAssembly(Message):
    DESCRIPTOR: Descriptor

    OUTPUT_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    Output: bytes
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Output: bytes = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Output", b"Output", "Response", b"Response"
        ],
    ) -> None: ...

class InvokeMigrateReq(Message):
    DESCRIPTOR: Descriptor

    PID_FIELD_NUMBER: int
    DATA_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Pid: int
    Data: bytes
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Pid: int = ...,
        Data: bytes = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Data", b"Data", "Pid", b"Pid", "Request", b"Request"
        ],
    ) -> None: ...

class Migrate(Message):
    DESCRIPTOR: Descriptor

    SUCCESS_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    Success: bool
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Success: bool = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Response", b"Response", "Success", b"Success"
        ],
    ) -> None: ...

class ExecuteReq(Message):
    DESCRIPTOR: Descriptor

    PATH_FIELD_NUMBER: int
    ARGS_FIELD_NUMBER: int
    OUTPUT_FIELD_NUMBER: int
    STDOUT_FIELD_NUMBER: int
    STDERR_FIELD_NUMBER: int
    PPID_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Path: str
    @property
    def Args(self) -> RepeatedScalarFieldContainer[str]: ...
    Output: bool
    Stdout: str
    Stderr: str
    PPid: int
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Path: str = ...,
        Args: Iterable[str] | None = ...,
        Output: bool = ...,
        Stdout: str = ...,
        Stderr: str = ...,
        PPid: int = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Args",
            b"Args",
            "Output",
            b"Output",
            "PPid",
            b"PPid",
            "Path",
            b"Path",
            "Request",
            b"Request",
            "Stderr",
            b"Stderr",
            "Stdout",
            b"Stdout",
        ],
    ) -> None: ...

class ExecuteWindowsReq(Message):
    DESCRIPTOR: Descriptor

    PATH_FIELD_NUMBER: int
    ARGS_FIELD_NUMBER: int
    OUTPUT_FIELD_NUMBER: int
    STDOUT_FIELD_NUMBER: int
    STDERR_FIELD_NUMBER: int
    USETOKEN_FIELD_NUMBER: int
    PPID_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Path: str
    @property
    def Args(self) -> RepeatedScalarFieldContainer[str]: ...
    Output: bool
    Stdout: str
    Stderr: str
    UseToken: bool
    PPid: int
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Path: str = ...,
        Args: Iterable[str] | None = ...,
        Output: bool = ...,
        Stdout: str = ...,
        Stderr: str = ...,
        UseToken: bool = ...,
        PPid: int = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Args",
            b"Args",
            "Output",
            b"Output",
            "PPid",
            b"PPid",
            "Path",
            b"Path",
            "Request",
            b"Request",
            "Stderr",
            b"Stderr",
            "Stdout",
            b"Stdout",
            "UseToken",
            b"UseToken",
        ],
    ) -> None: ...

class Execute(Message):
    DESCRIPTOR: Descriptor

    STATUS_FIELD_NUMBER: int
    STDOUT_FIELD_NUMBER: int
    STDERR_FIELD_NUMBER: int
    PID_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    Status: int
    Stdout: bytes
    Stderr: bytes
    Pid: int
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Status: int = ...,
        Stdout: bytes = ...,
        Stderr: bytes = ...,
        Pid: int = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Pid",
            b"Pid",
            "Response",
            b"Response",
            "Status",
            b"Status",
            "Stderr",
            b"Stderr",
            "Stdout",
            b"Stdout",
        ],
    ) -> None: ...

class SideloadReq(Message):
    DESCRIPTOR: Descriptor

    DATA_FIELD_NUMBER: int
    PROCESSNAME_FIELD_NUMBER: int
    ARGS_FIELD_NUMBER: int
    ENTRYPOINT_FIELD_NUMBER: int
    KILL_FIELD_NUMBER: int
    ISDLL_FIELD_NUMBER: int
    ISUNICODE_FIELD_NUMBER: int
    PPID_FIELD_NUMBER: int
    PROCESSARGS_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Data: bytes
    ProcessName: str
    Args: str
    EntryPoint: str
    Kill: bool
    isDLL: bool
    isUnicode: bool
    PPid: int
    @property
    def ProcessArgs(self) -> RepeatedScalarFieldContainer[str]: ...
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Data: bytes = ...,
        ProcessName: str = ...,
        Args: str = ...,
        EntryPoint: str = ...,
        Kill: bool = ...,
        isDLL: bool = ...,
        isUnicode: bool = ...,
        PPid: int = ...,
        ProcessArgs: Iterable[str] | None = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Args",
            b"Args",
            "Data",
            b"Data",
            "EntryPoint",
            b"EntryPoint",
            "Kill",
            b"Kill",
            "PPid",
            b"PPid",
            "ProcessArgs",
            b"ProcessArgs",
            "ProcessName",
            b"ProcessName",
            "Request",
            b"Request",
            "isDLL",
            b"isDLL",
            "isUnicode",
            b"isUnicode",
        ],
    ) -> None: ...

class Sideload(Message):
    DESCRIPTOR: Descriptor

    RESULT_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    Result: str
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Result: str = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Response", b"Response", "Result", b"Result"
        ],
    ) -> None: ...

class InvokeSpawnDllReq(Message):
    DESCRIPTOR: Descriptor

    DATA_FIELD_NUMBER: int
    PROCESSNAME_FIELD_NUMBER: int
    ARGS_FIELD_NUMBER: int
    ENTRYPOINT_FIELD_NUMBER: int
    KILL_FIELD_NUMBER: int
    PPID_FIELD_NUMBER: int
    PROCESSARGS_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Data: bytes
    ProcessName: str
    Args: str
    EntryPoint: str
    Kill: bool
    PPid: int
    @property
    def ProcessArgs(self) -> RepeatedScalarFieldContainer[str]: ...
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Data: bytes = ...,
        ProcessName: str = ...,
        Args: str = ...,
        EntryPoint: str = ...,
        Kill: bool = ...,
        PPid: int = ...,
        ProcessArgs: Iterable[str] | None = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Args",
            b"Args",
            "Data",
            b"Data",
            "EntryPoint",
            b"EntryPoint",
            "Kill",
            b"Kill",
            "PPid",
            b"PPid",
            "ProcessArgs",
            b"ProcessArgs",
            "ProcessName",
            b"ProcessName",
            "Request",
            b"Request",
        ],
    ) -> None: ...

class SpawnDllReq(Message):
    DESCRIPTOR: Descriptor

    DATA_FIELD_NUMBER: int
    PROCESSNAME_FIELD_NUMBER: int
    OFFSET_FIELD_NUMBER: int
    ARGS_FIELD_NUMBER: int
    KILL_FIELD_NUMBER: int
    PPID_FIELD_NUMBER: int
    PROCESSARGS_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Data: bytes
    ProcessName: str
    Offset: int
    Args: str
    Kill: bool
    PPid: int
    @property
    def ProcessArgs(self) -> RepeatedScalarFieldContainer[str]: ...
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Data: bytes = ...,
        ProcessName: str = ...,
        Offset: int = ...,
        Args: str = ...,
        Kill: bool = ...,
        PPid: int = ...,
        ProcessArgs: Iterable[str] | None = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Args",
            b"Args",
            "Data",
            b"Data",
            "Kill",
            b"Kill",
            "Offset",
            b"Offset",
            "PPid",
            b"PPid",
            "ProcessArgs",
            b"ProcessArgs",
            "ProcessName",
            b"ProcessName",
            "Request",
            b"Request",
        ],
    ) -> None: ...

class SpawnDll(Message):
    DESCRIPTOR: Descriptor

    RESULT_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    Result: str
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Result: str = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Response", b"Response", "Result", b"Result"
        ],
    ) -> None: ...

class NetstatReq(Message):
    DESCRIPTOR: Descriptor

    TCP_FIELD_NUMBER: int
    UDP_FIELD_NUMBER: int
    IP4_FIELD_NUMBER: int
    IP6_FIELD_NUMBER: int
    LISTENING_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    TCP: bool
    UDP: bool
    IP4: bool
    IP6: bool
    Listening: bool
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        TCP: bool = ...,
        UDP: bool = ...,
        IP4: bool = ...,
        IP6: bool = ...,
        Listening: bool = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "IP4",
            b"IP4",
            "IP6",
            b"IP6",
            "Listening",
            b"Listening",
            "Request",
            b"Request",
            "TCP",
            b"TCP",
            "UDP",
            b"UDP",
        ],
    ) -> None: ...

class SockTabEntry(Message):
    DESCRIPTOR: Descriptor

    class SockAddr(Message):
        DESCRIPTOR: Descriptor

        IP_FIELD_NUMBER: int
        PORT_FIELD_NUMBER: int
        Ip: str
        Port: int
        def __init__(
            self,
            *,
            Ip: str = ...,
            Port: int = ...,
        ) -> None: ...
        def ClearField(
            self, field_name: typing_extensions.Literal["Ip", b"Ip", "Port", b"Port"]
        ) -> None: ...

    LOCALADDR_FIELD_NUMBER: int
    REMOTEADDR_FIELD_NUMBER: int
    SKSTATE_FIELD_NUMBER: int
    UID_FIELD_NUMBER: int
    PROCESS_FIELD_NUMBER: int
    PROTOCOL_FIELD_NUMBER: int
    @property
    def LocalAddr(self) -> SockTabEntry.SockAddr: ...
    @property
    def RemoteAddr(self) -> SockTabEntry.SockAddr: ...
    SkState: str
    UID: int
    @property
    def Process(self) -> Process: ...
    Protocol: str
    def __init__(
        self,
        *,
        LocalAddr: SockTabEntry.SockAddr | None = ...,
        RemoteAddr: SockTabEntry.SockAddr | None = ...,
        SkState: str = ...,
        UID: int = ...,
        Process: Process | None = ...,
        Protocol: str = ...,
    ) -> None: ...
    def HasField(
        self,
        field_name: typing_extensions.Literal[
            "LocalAddr",
            b"LocalAddr",
            "Process",
            b"Process",
            "RemoteAddr",
            b"RemoteAddr",
        ],
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "LocalAddr",
            b"LocalAddr",
            "Process",
            b"Process",
            "Protocol",
            b"Protocol",
            "RemoteAddr",
            b"RemoteAddr",
            "SkState",
            b"SkState",
            "UID",
            b"UID",
        ],
    ) -> None: ...

class Netstat(Message):
    DESCRIPTOR: Descriptor

    ENTRIES_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    @property
    def Entries(self) -> RepeatedCompositeFieldContainer[SockTabEntry]: ...
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Entries: Iterable[SockTabEntry] | None = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Entries", b"Entries", "Response", b"Response"
        ],
    ) -> None: ...

class EnvReq(Message):
    DESCRIPTOR: Descriptor

    NAME_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Name: str
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Name: str = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal["Name", b"Name", "Request", b"Request"],
    ) -> None: ...

class EnvInfo(Message):
    DESCRIPTOR: Descriptor

    VARIABLES_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    @property
    def Variables(self) -> RepeatedCompositeFieldContainer[EnvVar]: ...
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Variables: Iterable[EnvVar] | None = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Response", b"Response", "Variables", b"Variables"
        ],
    ) -> None: ...

class SetEnvReq(Message):
    DESCRIPTOR: Descriptor

    VARIABLE_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    @property
    def Variable(self) -> EnvVar: ...
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Variable: EnvVar | None = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self,
        field_name: typing_extensions.Literal[
            "Request", b"Request", "Variable", b"Variable"
        ],
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Request", b"Request", "Variable", b"Variable"
        ],
    ) -> None: ...

class SetEnv(Message):
    DESCRIPTOR: Descriptor

    RESPONSE_FIELD_NUMBER: int
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> None: ...

class UnsetEnvReq(Message):
    DESCRIPTOR: Descriptor

    NAME_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Name: str
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Name: str = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal["Name", b"Name", "Request", b"Request"],
    ) -> None: ...

class UnsetEnv(Message):
    DESCRIPTOR: Descriptor

    RESPONSE_FIELD_NUMBER: int
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> None: ...

class DNSSessionInit(Message):
    """DNS Specific messages"""

    DESCRIPTOR: Descriptor

    KEY_FIELD_NUMBER: int
    Key: bytes
    def __init__(
        self,
        *,
        Key: bytes = ...,
    ) -> None: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Key", b"Key"]
    ) -> None: ...

class DNSPoll(Message):
    DESCRIPTOR: Descriptor

    BLOCKS_FIELD_NUMBER: int
    @property
    def blocks(self) -> RepeatedCompositeFieldContainer[DNSBlockHeader]: ...
    def __init__(
        self,
        *,
        blocks: Iterable[DNSBlockHeader] | None = ...,
    ) -> None: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["blocks", b"blocks"]
    ) -> None: ...

class DNSBlockHeader(Message):
    DESCRIPTOR: Descriptor

    ID_FIELD_NUMBER: int
    SIZE_FIELD_NUMBER: int
    ID: str
    Size: int
    def __init__(
        self,
        *,
        ID: str = ...,
        Size: int = ...,
    ) -> None: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["ID", b"ID", "Size", b"Size"]
    ) -> None: ...

class HTTPSessionInit(Message):
    """HTTP Sepecific message"""

    DESCRIPTOR: Descriptor

    KEY_FIELD_NUMBER: int
    Key: bytes
    def __init__(
        self,
        *,
        Key: bytes = ...,
    ) -> None: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Key", b"Key"]
    ) -> None: ...

class ScreenshotReq(Message):
    """ScreenshotReq - Request the implant take a screenshot"""

    DESCRIPTOR: Descriptor

    REQUEST_FIELD_NUMBER: int
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> None: ...

class Screenshot(Message):
    DESCRIPTOR: Descriptor

    DATA_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    Data: bytes
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Data: bytes = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal["Data", b"Data", "Response", b"Response"],
    ) -> None: ...

class StartServiceReq(Message):
    DESCRIPTOR: Descriptor

    SERVICENAME_FIELD_NUMBER: int
    SERVICEDESCRIPTION_FIELD_NUMBER: int
    BINPATH_FIELD_NUMBER: int
    HOSTNAME_FIELD_NUMBER: int
    ARGUMENTS_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    ServiceName: str
    ServiceDescription: str
    BinPath: str
    Hostname: str
    Arguments: str
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        ServiceName: str = ...,
        ServiceDescription: str = ...,
        BinPath: str = ...,
        Hostname: str = ...,
        Arguments: str = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Arguments",
            b"Arguments",
            "BinPath",
            b"BinPath",
            "Hostname",
            b"Hostname",
            "Request",
            b"Request",
            "ServiceDescription",
            b"ServiceDescription",
            "ServiceName",
            b"ServiceName",
        ],
    ) -> None: ...

class ServiceInfo(Message):
    DESCRIPTOR: Descriptor

    RESPONSE_FIELD_NUMBER: int
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> None: ...

class ServiceInfoReq(Message):
    DESCRIPTOR: Descriptor

    SERVICENAME_FIELD_NUMBER: int
    HOSTNAME_FIELD_NUMBER: int
    ServiceName: str
    Hostname: str
    def __init__(
        self,
        *,
        ServiceName: str = ...,
        Hostname: str = ...,
    ) -> None: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Hostname", b"Hostname", "ServiceName", b"ServiceName"
        ],
    ) -> None: ...

class StopServiceReq(Message):
    DESCRIPTOR: Descriptor

    SERVICEINFO_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    @property
    def ServiceInfo(self) -> ServiceInfoReq: ...
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        ServiceInfo: ServiceInfoReq | None = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self,
        field_name: typing_extensions.Literal[
            "Request", b"Request", "ServiceInfo", b"ServiceInfo"
        ],
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Request", b"Request", "ServiceInfo", b"ServiceInfo"
        ],
    ) -> None: ...

class RemoveServiceReq(Message):
    DESCRIPTOR: Descriptor

    SERVICEINFO_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    @property
    def ServiceInfo(self) -> ServiceInfoReq: ...
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        ServiceInfo: ServiceInfoReq | None = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self,
        field_name: typing_extensions.Literal[
            "Request", b"Request", "ServiceInfo", b"ServiceInfo"
        ],
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Request", b"Request", "ServiceInfo", b"ServiceInfo"
        ],
    ) -> None: ...

class BackdoorReq(Message):
    DESCRIPTOR: Descriptor

    FILEPATH_FIELD_NUMBER: int
    PROFILENAME_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    FilePath: str
    ProfileName: str
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        FilePath: str = ...,
        ProfileName: str = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "FilePath",
            b"FilePath",
            "ProfileName",
            b"ProfileName",
            "Request",
            b"Request",
        ],
    ) -> None: ...

class Backdoor(Message):
    DESCRIPTOR: Descriptor

    RESPONSE_FIELD_NUMBER: int
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> None: ...

class RegistryReadReq(Message):
    DESCRIPTOR: Descriptor

    HIVE_FIELD_NUMBER: int
    PATH_FIELD_NUMBER: int
    KEY_FIELD_NUMBER: int
    HOSTNAME_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Hive: str
    Path: str
    Key: str
    Hostname: str
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Hive: str = ...,
        Path: str = ...,
        Key: str = ...,
        Hostname: str = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Hive",
            b"Hive",
            "Hostname",
            b"Hostname",
            "Key",
            b"Key",
            "Path",
            b"Path",
            "Request",
            b"Request",
        ],
    ) -> None: ...

class RegistryRead(Message):
    DESCRIPTOR: Descriptor

    VALUE_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    Value: str
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Value: str = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Response", b"Response", "Value", b"Value"
        ],
    ) -> None: ...

class RegistryWriteReq(Message):
    DESCRIPTOR: Descriptor

    HIVE_FIELD_NUMBER: int
    PATH_FIELD_NUMBER: int
    KEY_FIELD_NUMBER: int
    HOSTNAME_FIELD_NUMBER: int
    STRINGVALUE_FIELD_NUMBER: int
    BYTEVALUE_FIELD_NUMBER: int
    DWORDVALUE_FIELD_NUMBER: int
    QWORDVALUE_FIELD_NUMBER: int
    TYPE_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Hive: str
    Path: str
    Key: str
    Hostname: str
    StringValue: str
    ByteValue: bytes
    DWordValue: int
    QWordValue: int
    Type: int
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Hive: str = ...,
        Path: str = ...,
        Key: str = ...,
        Hostname: str = ...,
        StringValue: str = ...,
        ByteValue: bytes = ...,
        DWordValue: int = ...,
        QWordValue: int = ...,
        Type: int = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "ByteValue",
            b"ByteValue",
            "DWordValue",
            b"DWordValue",
            "Hive",
            b"Hive",
            "Hostname",
            b"Hostname",
            "Key",
            b"Key",
            "Path",
            b"Path",
            "QWordValue",
            b"QWordValue",
            "Request",
            b"Request",
            "StringValue",
            b"StringValue",
            "Type",
            b"Type",
        ],
    ) -> None: ...

class RegistryWrite(Message):
    DESCRIPTOR: Descriptor

    RESPONSE_FIELD_NUMBER: int
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> None: ...

class RegistryCreateKeyReq(Message):
    DESCRIPTOR: Descriptor

    HIVE_FIELD_NUMBER: int
    PATH_FIELD_NUMBER: int
    KEY_FIELD_NUMBER: int
    HOSTNAME_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Hive: str
    Path: str
    Key: str
    Hostname: str
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Hive: str = ...,
        Path: str = ...,
        Key: str = ...,
        Hostname: str = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Hive",
            b"Hive",
            "Hostname",
            b"Hostname",
            "Key",
            b"Key",
            "Path",
            b"Path",
            "Request",
            b"Request",
        ],
    ) -> None: ...

class RegistryCreateKey(Message):
    DESCRIPTOR: Descriptor

    RESPONSE_FIELD_NUMBER: int
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> None: ...

class RegistryDeleteKeyReq(Message):
    DESCRIPTOR: Descriptor

    HIVE_FIELD_NUMBER: int
    PATH_FIELD_NUMBER: int
    KEY_FIELD_NUMBER: int
    HOSTNAME_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Hive: str
    Path: str
    Key: str
    Hostname: str
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Hive: str = ...,
        Path: str = ...,
        Key: str = ...,
        Hostname: str = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Hive",
            b"Hive",
            "Hostname",
            b"Hostname",
            "Key",
            b"Key",
            "Path",
            b"Path",
            "Request",
            b"Request",
        ],
    ) -> None: ...

class RegistryDeleteKey(Message):
    DESCRIPTOR: Descriptor

    RESPONSE_FIELD_NUMBER: int
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> None: ...

class RegistrySubKeyListReq(Message):
    DESCRIPTOR: Descriptor

    HIVE_FIELD_NUMBER: int
    PATH_FIELD_NUMBER: int
    HOSTNAME_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Hive: str
    Path: str
    Hostname: str
    """Keep the same ID as the other registry operations"""
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Hive: str = ...,
        Path: str = ...,
        Hostname: str = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Hive",
            b"Hive",
            "Hostname",
            b"Hostname",
            "Path",
            b"Path",
            "Request",
            b"Request",
        ],
    ) -> None: ...

class RegistrySubKeyList(Message):
    DESCRIPTOR: Descriptor

    SUBKEYS_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    @property
    def Subkeys(self) -> RepeatedScalarFieldContainer[str]: ...
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Subkeys: Iterable[str] | None = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Response", b"Response", "Subkeys", b"Subkeys"
        ],
    ) -> None: ...

class RegistryListValuesReq(Message):
    DESCRIPTOR: Descriptor

    HIVE_FIELD_NUMBER: int
    PATH_FIELD_NUMBER: int
    HOSTNAME_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Hive: str
    Path: str
    Hostname: str
    """Keep the same ID as the other registry operations"""
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Hive: str = ...,
        Path: str = ...,
        Hostname: str = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Hive",
            b"Hive",
            "Hostname",
            b"Hostname",
            "Path",
            b"Path",
            "Request",
            b"Request",
        ],
    ) -> None: ...

class RegistryValuesList(Message):
    DESCRIPTOR: Descriptor

    VALUENAMES_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    @property
    def ValueNames(self) -> RepeatedScalarFieldContainer[str]: ...
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        ValueNames: Iterable[str] | None = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Response", b"Response", "ValueNames", b"ValueNames"
        ],
    ) -> None: ...

class Tunnel(Message):
    """Tunnel - Tunnel related messages"""

    DESCRIPTOR: Descriptor

    TUNNELID_FIELD_NUMBER: int
    SESSIONID_FIELD_NUMBER: int
    TunnelID: int
    SessionID: str
    def __init__(
        self,
        *,
        TunnelID: int = ...,
        SessionID: str = ...,
    ) -> None: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "SessionID", b"SessionID", "TunnelID", b"TunnelID"
        ],
    ) -> None: ...

class TunnelData(Message):
    DESCRIPTOR: Descriptor

    DATA_FIELD_NUMBER: int
    CLOSED_FIELD_NUMBER: int
    SEQUENCE_FIELD_NUMBER: int
    ACK_FIELD_NUMBER: int
    RESEND_FIELD_NUMBER: int
    CREATEREVERSE_FIELD_NUMBER: int
    RPORTFWD_FIELD_NUMBER: int
    TUNNELID_FIELD_NUMBER: int
    SESSIONID_FIELD_NUMBER: int
    Data: bytes
    Closed: bool
    Sequence: int
    Ack: int
    Resend: bool
    CreateReverse: bool
    @property
    def rportfwd(self) -> RPortfwd: ...
    TunnelID: int
    SessionID: str
    def __init__(
        self,
        *,
        Data: bytes = ...,
        Closed: bool = ...,
        Sequence: int = ...,
        Ack: int = ...,
        Resend: bool = ...,
        CreateReverse: bool = ...,
        rportfwd: RPortfwd | None = ...,
        TunnelID: int = ...,
        SessionID: str = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["rportfwd", b"rportfwd"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Ack",
            b"Ack",
            "Closed",
            b"Closed",
            "CreateReverse",
            b"CreateReverse",
            "Data",
            b"Data",
            "Resend",
            b"Resend",
            "Sequence",
            b"Sequence",
            "SessionID",
            b"SessionID",
            "TunnelID",
            b"TunnelID",
            "rportfwd",
            b"rportfwd",
        ],
    ) -> None: ...

class ShellReq(Message):
    """ShellReq - Request the implant open a realtime shell tunnel"""

    DESCRIPTOR: Descriptor

    PATH_FIELD_NUMBER: int
    ENABLEPTY_FIELD_NUMBER: int
    PID_FIELD_NUMBER: int
    TUNNELID_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Path: str
    EnablePTY: bool
    Pid: int
    TunnelID: int
    """Bind to this tunnel"""
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Path: str = ...,
        EnablePTY: bool = ...,
        Pid: int = ...,
        TunnelID: int = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "EnablePTY",
            b"EnablePTY",
            "Path",
            b"Path",
            "Pid",
            b"Pid",
            "Request",
            b"Request",
            "TunnelID",
            b"TunnelID",
        ],
    ) -> None: ...

class Shell(Message):
    """Shell - Request the implant open a realtime shell tunnel"""

    DESCRIPTOR: Descriptor

    PATH_FIELD_NUMBER: int
    ENABLEPTY_FIELD_NUMBER: int
    PID_FIELD_NUMBER: int
    TUNNELID_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    Path: str
    EnablePTY: bool
    Pid: int
    TunnelID: int
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Path: str = ...,
        EnablePTY: bool = ...,
        Pid: int = ...,
        TunnelID: int = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "EnablePTY",
            b"EnablePTY",
            "Path",
            b"Path",
            "Pid",
            b"Pid",
            "Response",
            b"Response",
            "TunnelID",
            b"TunnelID",
        ],
    ) -> None: ...

class PortfwdReq(Message):
    DESCRIPTOR: Descriptor

    PORT_FIELD_NUMBER: int
    PROTOCOL_FIELD_NUMBER: int
    HOST_FIELD_NUMBER: int
    TUNNELID_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Port: int
    Protocol: int
    Host: str
    TunnelID: int
    """Bind to this tunnel"""
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Port: int = ...,
        Protocol: int = ...,
        Host: str = ...,
        TunnelID: int = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Host",
            b"Host",
            "Port",
            b"Port",
            "Protocol",
            b"Protocol",
            "Request",
            b"Request",
            "TunnelID",
            b"TunnelID",
        ],
    ) -> None: ...

class Portfwd(Message):
    DESCRIPTOR: Descriptor

    PORT_FIELD_NUMBER: int
    PROTOCOL_FIELD_NUMBER: int
    HOST_FIELD_NUMBER: int
    TUNNELID_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    Port: int
    Protocol: int
    Host: str
    TunnelID: int
    """Bind to this tunnel"""
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Port: int = ...,
        Protocol: int = ...,
        Host: str = ...,
        TunnelID: int = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Host",
            b"Host",
            "Port",
            b"Port",
            "Protocol",
            b"Protocol",
            "Response",
            b"Response",
            "TunnelID",
            b"TunnelID",
        ],
    ) -> None: ...

class Socks(Message):
    """*** Socks ***"""

    DESCRIPTOR: Descriptor

    TUNNELID_FIELD_NUMBER: int
    SESSIONID_FIELD_NUMBER: int
    TunnelID: int
    SessionID: str
    def __init__(
        self,
        *,
        TunnelID: int = ...,
        SessionID: str = ...,
    ) -> None: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "SessionID", b"SessionID", "TunnelID", b"TunnelID"
        ],
    ) -> None: ...

class SocksData(Message):
    DESCRIPTOR: Descriptor

    DATA_FIELD_NUMBER: int
    CLOSECONN_FIELD_NUMBER: int
    USERNAME_FIELD_NUMBER: int
    PASSWORD_FIELD_NUMBER: int
    SEQUENCE_FIELD_NUMBER: int
    TUNNELID_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Data: bytes
    CloseConn: bool
    Username: str
    Password: str
    Sequence: int
    TunnelID: int
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Data: bytes = ...,
        CloseConn: bool = ...,
        Username: str = ...,
        Password: str = ...,
        Sequence: int = ...,
        TunnelID: int = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "CloseConn",
            b"CloseConn",
            "Data",
            b"Data",
            "Password",
            b"Password",
            "Request",
            b"Request",
            "Sequence",
            b"Sequence",
            "TunnelID",
            b"TunnelID",
            "Username",
            b"Username",
        ],
    ) -> None: ...

class PivotStartListenerReq(Message):
    DESCRIPTOR: Descriptor

    TYPE_FIELD_NUMBER: int
    BINDADDRESS_FIELD_NUMBER: int
    OPTIONS_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Type: PivotType.ValueType
    BindAddress: str
    @property
    def Options(self) -> RepeatedScalarFieldContainer[bool]: ...
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Type: PivotType.ValueType = ...,
        BindAddress: str = ...,
        Options: Iterable[bool] | None = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "BindAddress",
            b"BindAddress",
            "Options",
            b"Options",
            "Request",
            b"Request",
            "Type",
            b"Type",
        ],
    ) -> None: ...

class PivotStopListenerReq(Message):
    DESCRIPTOR: Descriptor

    ID_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    ID: int
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        ID: int = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["ID", b"ID", "Request", b"Request"]
    ) -> None: ...

class PivotListener(Message):
    DESCRIPTOR: Descriptor

    ID_FIELD_NUMBER: int
    TYPE_FIELD_NUMBER: int
    BINDADDRESS_FIELD_NUMBER: int
    PIVOTS_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    ID: int
    Type: PivotType.ValueType
    BindAddress: str
    @property
    def Pivots(self) -> RepeatedCompositeFieldContainer[NetConnPivot]: ...
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        ID: int = ...,
        Type: PivotType.ValueType = ...,
        BindAddress: str = ...,
        Pivots: Iterable[NetConnPivot] | None = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "BindAddress",
            b"BindAddress",
            "ID",
            b"ID",
            "Pivots",
            b"Pivots",
            "Response",
            b"Response",
            "Type",
            b"Type",
        ],
    ) -> None: ...

class PivotHello(Message):
    DESCRIPTOR: Descriptor

    PUBLICKEY_FIELD_NUMBER: int
    PEERID_FIELD_NUMBER: int
    PUBLICKEYSIGNATURE_FIELD_NUMBER: int
    SESSIONKEY_FIELD_NUMBER: int
    PublicKey: bytes
    PeerID: int
    PublicKeySignature: str
    SessionKey: bytes
    def __init__(
        self,
        *,
        PublicKey: bytes = ...,
        PeerID: int = ...,
        PublicKeySignature: str = ...,
        SessionKey: bytes = ...,
    ) -> None: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "PeerID",
            b"PeerID",
            "PublicKey",
            b"PublicKey",
            "PublicKeySignature",
            b"PublicKeySignature",
            "SessionKey",
            b"SessionKey",
        ],
    ) -> None: ...

class PivotServerKeyExchange(Message):
    DESCRIPTOR: Descriptor

    ORIGINID_FIELD_NUMBER: int
    SESSIONKEY_FIELD_NUMBER: int
    OriginID: int
    SessionKey: bytes
    def __init__(
        self,
        *,
        OriginID: int = ...,
        SessionKey: bytes = ...,
    ) -> None: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "OriginID", b"OriginID", "SessionKey", b"SessionKey"
        ],
    ) -> None: ...

class PivotPeer(Message):
    DESCRIPTOR: Descriptor

    PEERID_FIELD_NUMBER: int
    NAME_FIELD_NUMBER: int
    PeerID: int
    Name: str
    def __init__(
        self,
        *,
        PeerID: int = ...,
        Name: str = ...,
    ) -> None: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal["Name", b"Name", "PeerID", b"PeerID"],
    ) -> None: ...

class PivotPeerEnvelope(Message):
    DESCRIPTOR: Descriptor

    PEERS_FIELD_NUMBER: int
    TYPE_FIELD_NUMBER: int
    PIVOTSESSIONID_FIELD_NUMBER: int
    DATA_FIELD_NUMBER: int
    PEERFAILUREAT_FIELD_NUMBER: int
    @property
    def Peers(self) -> RepeatedCompositeFieldContainer[PivotPeer]: ...
    Type: int
    PivotSessionID: bytes
    Data: bytes
    PeerFailureAt: int
    def __init__(
        self,
        *,
        Peers: Iterable[PivotPeer] | None = ...,
        Type: int = ...,
        PivotSessionID: bytes = ...,
        Data: bytes = ...,
        PeerFailureAt: int = ...,
    ) -> None: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Data",
            b"Data",
            "PeerFailureAt",
            b"PeerFailureAt",
            "Peers",
            b"Peers",
            "PivotSessionID",
            b"PivotSessionID",
            "Type",
            b"Type",
        ],
    ) -> None: ...

class PivotPing(Message):
    DESCRIPTOR: Descriptor

    NONCE_FIELD_NUMBER: int
    Nonce: int
    def __init__(
        self,
        *,
        Nonce: int = ...,
    ) -> None: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Nonce", b"Nonce"]
    ) -> None: ...

class NetConnPivot(Message):
    DESCRIPTOR: Descriptor

    PEERID_FIELD_NUMBER: int
    REMOTEADDRESS_FIELD_NUMBER: int
    PeerID: int
    RemoteAddress: str
    def __init__(
        self,
        *,
        PeerID: int = ...,
        RemoteAddress: str = ...,
    ) -> None: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "PeerID", b"PeerID", "RemoteAddress", b"RemoteAddress"
        ],
    ) -> None: ...

class PivotPeerFailure(Message):
    DESCRIPTOR: Descriptor

    PEERID_FIELD_NUMBER: int
    TYPE_FIELD_NUMBER: int
    ERR_FIELD_NUMBER: int
    PeerID: int
    Type: PeerFailureType.ValueType
    Err: str
    def __init__(
        self,
        *,
        PeerID: int = ...,
        Type: PeerFailureType.ValueType = ...,
        Err: str = ...,
    ) -> None: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Err", b"Err", "PeerID", b"PeerID", "Type", b"Type"
        ],
    ) -> None: ...

class PivotListenersReq(Message):
    DESCRIPTOR: Descriptor

    REQUEST_FIELD_NUMBER: int
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> None: ...

class PivotListeners(Message):
    DESCRIPTOR: Descriptor

    LISTENERS_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    @property
    def Listeners(self) -> RepeatedCompositeFieldContainer[PivotListener]: ...
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Listeners: Iterable[PivotListener] | None = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Listeners", b"Listeners", "Response", b"Response"
        ],
    ) -> None: ...

class WGPortForwardStartReq(Message):
    """*** Wiregard ***"""

    DESCRIPTOR: Descriptor

    LOCALPORT_FIELD_NUMBER: int
    REMOTEADDRESS_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    LocalPort: int
    RemoteAddress: str
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        LocalPort: int = ...,
        RemoteAddress: str = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "LocalPort",
            b"LocalPort",
            "RemoteAddress",
            b"RemoteAddress",
            "Request",
            b"Request",
        ],
    ) -> None: ...

class WGPortForward(Message):
    DESCRIPTOR: Descriptor

    FORWARDER_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    @property
    def Forwarder(self) -> WGTCPForwarder: ...
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Forwarder: WGTCPForwarder | None = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self,
        field_name: typing_extensions.Literal[
            "Forwarder", b"Forwarder", "Response", b"Response"
        ],
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Forwarder", b"Forwarder", "Response", b"Response"
        ],
    ) -> None: ...

class WGPortForwardStopReq(Message):
    DESCRIPTOR: Descriptor

    ID_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    ID: int
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        ID: int = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["ID", b"ID", "Request", b"Request"]
    ) -> None: ...

class WGSocksStartReq(Message):
    DESCRIPTOR: Descriptor

    PORT_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Port: int
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Port: int = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal["Port", b"Port", "Request", b"Request"],
    ) -> None: ...

class WGSocks(Message):
    DESCRIPTOR: Descriptor

    SERVER_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    @property
    def Server(self) -> WGSocksServer: ...
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Server: WGSocksServer | None = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self,
        field_name: typing_extensions.Literal[
            "Response", b"Response", "Server", b"Server"
        ],
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Response", b"Response", "Server", b"Server"
        ],
    ) -> None: ...

class WGSocksStopReq(Message):
    DESCRIPTOR: Descriptor

    ID_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    ID: int
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        ID: int = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["ID", b"ID", "Request", b"Request"]
    ) -> None: ...

class WGTCPForwardersReq(Message):
    DESCRIPTOR: Descriptor

    REQUEST_FIELD_NUMBER: int
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> None: ...

class WGSocksServersReq(Message):
    DESCRIPTOR: Descriptor

    REQUEST_FIELD_NUMBER: int
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> None: ...

class WGTCPForwarder(Message):
    DESCRIPTOR: Descriptor

    ID_FIELD_NUMBER: int
    LOCALADDR_FIELD_NUMBER: int
    REMOTEADDR_FIELD_NUMBER: int
    ID: int
    LocalAddr: str
    RemoteAddr: str
    def __init__(
        self,
        *,
        ID: int = ...,
        LocalAddr: str = ...,
        RemoteAddr: str = ...,
    ) -> None: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "ID", b"ID", "LocalAddr", b"LocalAddr", "RemoteAddr", b"RemoteAddr"
        ],
    ) -> None: ...

class WGSocksServer(Message):
    DESCRIPTOR: Descriptor

    ID_FIELD_NUMBER: int
    LOCALADDR_FIELD_NUMBER: int
    ID: int
    LocalAddr: str
    def __init__(
        self,
        *,
        ID: int = ...,
        LocalAddr: str = ...,
    ) -> None: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal["ID", b"ID", "LocalAddr", b"LocalAddr"],
    ) -> None: ...

class WGSocksServers(Message):
    DESCRIPTOR: Descriptor

    SERVERS_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    @property
    def Servers(self) -> RepeatedCompositeFieldContainer[WGSocksServer]: ...
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Servers: Iterable[WGSocksServer] | None = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Response", b"Response", "Servers", b"Servers"
        ],
    ) -> None: ...

class WGTCPForwarders(Message):
    DESCRIPTOR: Descriptor

    FORWARDERS_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    @property
    def Forwarders(self) -> RepeatedCompositeFieldContainer[WGTCPForwarder]: ...
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Forwarders: Iterable[WGTCPForwarder] | None = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Forwarders", b"Forwarders", "Response", b"Response"
        ],
    ) -> None: ...

class ReconfigureReq(Message):
    """ReconfigureReq - Request the implant to reconfigure itself"""

    DESCRIPTOR: Descriptor

    RECONNECTINTERVAL_FIELD_NUMBER: int
    BEACONINTERVAL_FIELD_NUMBER: int
    BEACONJITTER_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    ReconnectInterval: int
    BeaconInterval: int
    BeaconJitter: int
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        ReconnectInterval: int = ...,
        BeaconInterval: int = ...,
        BeaconJitter: int = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "BeaconInterval",
            b"BeaconInterval",
            "BeaconJitter",
            b"BeaconJitter",
            "ReconnectInterval",
            b"ReconnectInterval",
            "Request",
            b"Request",
        ],
    ) -> None: ...

class Reconfigure(Message):
    DESCRIPTOR: Descriptor

    RESPONSE_FIELD_NUMBER: int
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> None: ...

class PollIntervalReq(Message):
    """PollIntervalReq - Request the implant to update it's poll intervbal"""

    DESCRIPTOR: Descriptor

    POLLINTERVAL_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    PollInterval: int
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        PollInterval: int = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "PollInterval", b"PollInterval", "Request", b"Request"
        ],
    ) -> None: ...

class PollInterval(Message):
    DESCRIPTOR: Descriptor

    RESPONSE_FIELD_NUMBER: int
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> None: ...

class SSHCommandReq(Message):
    DESCRIPTOR: Descriptor

    USERNAME_FIELD_NUMBER: int
    HOSTNAME_FIELD_NUMBER: int
    PORT_FIELD_NUMBER: int
    COMMAND_FIELD_NUMBER: int
    PASSWORD_FIELD_NUMBER: int
    PRIVKEY_FIELD_NUMBER: int
    KRB5CONF_FIELD_NUMBER: int
    KEYTAB_FIELD_NUMBER: int
    REALM_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Username: str
    Hostname: str
    Port: int
    Command: str
    Password: str
    PrivKey: bytes
    Krb5Conf: str
    Keytab: bytes
    Realm: str
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Username: str = ...,
        Hostname: str = ...,
        Port: int = ...,
        Command: str = ...,
        Password: str = ...,
        PrivKey: bytes = ...,
        Krb5Conf: str = ...,
        Keytab: bytes = ...,
        Realm: str = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Command",
            b"Command",
            "Hostname",
            b"Hostname",
            "Keytab",
            b"Keytab",
            "Krb5Conf",
            b"Krb5Conf",
            "Password",
            b"Password",
            "Port",
            b"Port",
            "PrivKey",
            b"PrivKey",
            "Realm",
            b"Realm",
            "Request",
            b"Request",
            "Username",
            b"Username",
        ],
    ) -> None: ...

class SSHCommand(Message):
    DESCRIPTOR: Descriptor

    STDOUT_FIELD_NUMBER: int
    STDERR_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    StdOut: str
    StdErr: str
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        StdOut: str = ...,
        StdErr: str = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Response", b"Response", "StdErr", b"StdErr", "StdOut", b"StdOut"
        ],
    ) -> None: ...

class GetPrivsReq(Message):
    DESCRIPTOR: Descriptor

    REQUEST_FIELD_NUMBER: int
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> None: ...

class WindowsPrivilegeEntry(Message):
    DESCRIPTOR: Descriptor

    NAME_FIELD_NUMBER: int
    DESCRIPTION_FIELD_NUMBER: int
    ENABLED_FIELD_NUMBER: int
    ENABLEDBYDEFAULT_FIELD_NUMBER: int
    REMOVED_FIELD_NUMBER: int
    USEDFORACCESS_FIELD_NUMBER: int
    Name: str
    Description: str
    Enabled: bool
    EnabledByDefault: bool
    Removed: bool
    UsedForAccess: bool
    def __init__(
        self,
        *,
        Name: str = ...,
        Description: str = ...,
        Enabled: bool = ...,
        EnabledByDefault: bool = ...,
        Removed: bool = ...,
        UsedForAccess: bool = ...,
    ) -> None: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Description",
            b"Description",
            "Enabled",
            b"Enabled",
            "EnabledByDefault",
            b"EnabledByDefault",
            "Name",
            b"Name",
            "Removed",
            b"Removed",
            "UsedForAccess",
            b"UsedForAccess",
        ],
    ) -> None: ...

class GetPrivs(Message):
    DESCRIPTOR: Descriptor

    PRIVINFO_FIELD_NUMBER: int
    PROCESSINTEGRITY_FIELD_NUMBER: int
    PROCESSNAME_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    @property
    def PrivInfo(self) -> RepeatedCompositeFieldContainer[WindowsPrivilegeEntry]: ...
    ProcessIntegrity: str
    ProcessName: str
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        PrivInfo: Iterable[WindowsPrivilegeEntry] | None = ...,
        ProcessIntegrity: str = ...,
        ProcessName: str = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "PrivInfo",
            b"PrivInfo",
            "ProcessIntegrity",
            b"ProcessIntegrity",
            "ProcessName",
            b"ProcessName",
            "Response",
            b"Response",
        ],
    ) -> None: ...

class RegisterExtensionReq(Message):
    """Extensions"""

    DESCRIPTOR: Descriptor

    NAME_FIELD_NUMBER: int
    DATA_FIELD_NUMBER: int
    OS_FIELD_NUMBER: int
    INIT_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Name: str
    Data: bytes
    OS: str
    Init: str
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Name: str = ...,
        Data: bytes = ...,
        OS: str = ...,
        Init: str = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Data",
            b"Data",
            "Init",
            b"Init",
            "Name",
            b"Name",
            "OS",
            b"OS",
            "Request",
            b"Request",
        ],
    ) -> None: ...

class RegisterExtension(Message):
    DESCRIPTOR: Descriptor

    RESPONSE_FIELD_NUMBER: int
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> None: ...

class CallExtensionReq(Message):
    DESCRIPTOR: Descriptor

    NAME_FIELD_NUMBER: int
    SERVERSTORE_FIELD_NUMBER: int
    ARGS_FIELD_NUMBER: int
    EXPORT_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Name: str
    ServerStore: bool
    Args: bytes
    Export: str
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Name: str = ...,
        ServerStore: bool = ...,
        Args: bytes = ...,
        Export: str = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Args",
            b"Args",
            "Export",
            b"Export",
            "Name",
            b"Name",
            "Request",
            b"Request",
            "ServerStore",
            b"ServerStore",
        ],
    ) -> None: ...

class CallExtension(Message):
    DESCRIPTOR: Descriptor

    OUTPUT_FIELD_NUMBER: int
    SERVERSTORE_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    Output: bytes
    ServerStore: bool
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Output: bytes = ...,
        ServerStore: bool = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Output", b"Output", "Response", b"Response", "ServerStore", b"ServerStore"
        ],
    ) -> None: ...

class ListExtensionsReq(Message):
    DESCRIPTOR: Descriptor

    REQUEST_FIELD_NUMBER: int
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> None: ...

class ListExtensions(Message):
    DESCRIPTOR: Descriptor

    NAMES_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    @property
    def Names(self) -> RepeatedScalarFieldContainer[str]: ...
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Names: Iterable[str] | None = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Names", b"Names", "Response", b"Response"
        ],
    ) -> None: ...

class RportFwdStopListenerReq(Message):
    """*** RportFwd ***"""

    DESCRIPTOR: Descriptor

    ID_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    ID: int
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        ID: int = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["ID", b"ID", "Request", b"Request"]
    ) -> None: ...

class RportFwdStartListenerReq(Message):
    DESCRIPTOR: Descriptor

    BINDADDRESS_FIELD_NUMBER: int
    BINDPORT_FIELD_NUMBER: int
    FORWARDPORT_FIELD_NUMBER: int
    FORWARDADDRESS_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    BindAddress: str
    BindPort: int
    forwardPort: int
    forwardAddress: str
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        BindAddress: str = ...,
        BindPort: int = ...,
        forwardPort: int = ...,
        forwardAddress: str = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "BindAddress",
            b"BindAddress",
            "BindPort",
            b"BindPort",
            "Request",
            b"Request",
            "forwardAddress",
            b"forwardAddress",
            "forwardPort",
            b"forwardPort",
        ],
    ) -> None: ...

class RportFwdListener(Message):
    DESCRIPTOR: Descriptor

    ID_FIELD_NUMBER: int
    BINDADDRESS_FIELD_NUMBER: int
    BINDPORT_FIELD_NUMBER: int
    FORWARDADDRESS_FIELD_NUMBER: int
    FORWARDPORT_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    ID: int
    BindAddress: str
    bindPort: int
    forwardAddress: str
    forwardPort: int
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        ID: int = ...,
        BindAddress: str = ...,
        bindPort: int = ...,
        forwardAddress: str = ...,
        forwardPort: int = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "BindAddress",
            b"BindAddress",
            "ID",
            b"ID",
            "Response",
            b"Response",
            "bindPort",
            b"bindPort",
            "forwardAddress",
            b"forwardAddress",
            "forwardPort",
            b"forwardPort",
        ],
    ) -> None: ...

class RportFwdListeners(Message):
    DESCRIPTOR: Descriptor

    LISTENERS_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    @property
    def Listeners(self) -> RepeatedCompositeFieldContainer[RportFwdListener]: ...
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Listeners: Iterable[RportFwdListener] | None = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Listeners", b"Listeners", "Response", b"Response"
        ],
    ) -> None: ...

class RportFwdListenersReq(Message):
    DESCRIPTOR: Descriptor

    REQUEST_FIELD_NUMBER: int
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> None: ...

class RPortfwd(Message):
    DESCRIPTOR: Descriptor

    PORT_FIELD_NUMBER: int
    PROTOCOL_FIELD_NUMBER: int
    HOST_FIELD_NUMBER: int
    TUNNELID_FIELD_NUMBER: int
    RESPONSE_FIELD_NUMBER: int
    Port: int
    Protocol: int
    Host: str
    TunnelID: int
    """Bind to this tunnel"""
    @property
    def Response(self) -> Response: ...
    def __init__(
        self,
        *,
        Port: int = ...,
        Protocol: int = ...,
        Host: str = ...,
        TunnelID: int = ...,
        Response: Response | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Response", b"Response"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Host",
            b"Host",
            "Port",
            b"Port",
            "Protocol",
            b"Protocol",
            "Response",
            b"Response",
            "TunnelID",
            b"TunnelID",
        ],
    ) -> None: ...

class RPortfwdReq(Message):
    DESCRIPTOR: Descriptor

    PORT_FIELD_NUMBER: int
    PROTOCOL_FIELD_NUMBER: int
    HOST_FIELD_NUMBER: int
    TUNNELID_FIELD_NUMBER: int
    REQUEST_FIELD_NUMBER: int
    Port: int
    Protocol: int
    Host: str
    TunnelID: int
    """Bind to this tunnel"""
    @property
    def Request(self) -> Request: ...
    def __init__(
        self,
        *,
        Port: int = ...,
        Protocol: int = ...,
        Host: str = ...,
        TunnelID: int = ...,
        Request: Request | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing_extensions.Literal["Request", b"Request"]
    ) -> bool: ...
    def ClearField(
        self,
        field_name: typing_extensions.Literal[
            "Host",
            b"Host",
            "Port",
            b"Port",
            "Protocol",
            b"Protocol",
            "Request",
            b"Request",
            "TunnelID",
            b"TunnelID",
        ],
    ) -> None: ...
