Interface SliverRPCClient<CallOptionsExt>

interface SliverRPCClient<CallOptionsExt = {}> {
    backdoor(
        request: {
            FilePath?: string;
            Name?: string;
            ProfileName?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Backdoor>;
    builderRegister(
        request: {
            CrossCompilers?: {
                CCPath?: string;
                CXXPath?: string;
                TargetGOARCH?: string;
                TargetGOOS?: string;
            }[];
            GOARCH?: string;
            GOOS?: string;
            Name?: string;
            OperatorName?: string;
            Targets?: { Format?: OutputFormat; GOARCH?: string; GOOS?: string }[];
            Templates?: string[];
        },
        options?: CallOptions & CallOptionsExt,
    ): AsyncIterable<clientpb.Event>;
    builders(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Builders>;
    builderTrigger(
        request: {
            Client?: {
                ID?: number;
                Name?: string;
                Operator?: { Name?: string; Online?: boolean };
            };
            Data?: Buffer<ArrayBufferLike>;
            Err?: string;
            EventType?: string;
            Job?: {
                Description?: string;
                Domains?: string[];
                ID?: number;
                Name?: string;
                Port?: number;
                ProfileName?: string;
                Protocol?: string;
            };
            Session?: {
                ActiveC2?: string;
                Arch?: string;
                Burned?: boolean;
                Evasion?: boolean;
                Extensions?: string[];
                Filename?: string;
                FirstContact?: string;
                GID?: string;
                Hostname?: string;
                ID?: string;
                Integrity?: string;
                IsDead?: boolean;
                LastCheckin?: string;
                Locale?: string;
                Name?: string;
                OS?: string;
                PeerID?: string;
                PID?: number;
                ProxyURL?: string;
                ReconnectInterval?: string;
                RemoteAddress?: string;
                Transport?: string;
                UID?: string;
                Username?: string;
                UUID?: string;
                Version?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    callExtension(
        request: {
            Args?: Buffer<ArrayBufferLike>;
            Export?: string;
            Name?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            ServerStore?: boolean;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.CallExtension>;
    canaries(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Canaries>;
    cancelBeaconTask(
        request: {
            BeaconID?: string;
            CompletedAt?: string;
            CreatedAt?: string;
            Description?: string;
            ID?: string;
            Request?: Buffer<ArrayBufferLike>;
            Response?: Buffer<ArrayBufferLike>;
            SentAt?: string;
            State?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.BeaconTask>;
    cd(
        request: {
            Path?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Pwd>;
    chmod(
        request: {
            FileMode?: string;
            Path?: string;
            Recursive?: boolean;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Chmod>;
    chown(
        request: {
            Gid?: string;
            Path?: string;
            Recursive?: boolean;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            Uid?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Chown>;
    chtimes(
        request: {
            ATime?: string;
            MTime?: string;
            Path?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Chtimes>;
    clientLog(
        request: AsyncIterable<
            { Data?: Buffer<ArrayBufferLike>; Stream?: string },
        >,
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    closeSession(
        request: {
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            Response?: {
                Async?: boolean;
                BeaconID?: string;
                Err?: string;
                TaskID?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    closeSocks(
        request: { SessionID?: string; TunnelID?: string },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    closeTunnel(
        request: { SessionID?: string; TunnelID?: string },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    cp(
        request: {
            Dst?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            Src?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Cp>;
    crack(
        request: {
            AttackMode?: CrackAttackMode;
            BackendDevices?: number[];
            BackendIgnoreCUDA?: boolean;
            BackendIgnoreHip?: boolean;
            BackendIgnoreMetal?: boolean;
            BackendIgnoreOpenCL?: boolean;
            BackendInfo?: boolean;
            BackendVectorWidth?: number;
            Benchmark?: boolean;
            BenchmarkAll?: boolean;
            BitmapMax?: number;
            BitmapMin?: number;
            BrainClient?: boolean;
            BrainClientFeatures?: string;
            BrainHost?: string;
            BrainPassword?: string;
            BrainPort?: number;
            BrainServer?: boolean;
            BrainServerTimer?: number;
            BrainSession?: string;
            BrainSessionWhitelist?: string;
            CPUAffinity?: number[];
            CustomCharset1?: string;
            CustomCharset2?: string;
            CustomCharset3?: string;
            CustomCharset4?: string;
            DebugMode?: number;
            DeprecatedCheckDisable?: boolean;
            EncodingFrom?: CrackEncoding;
            EncodingTo?: CrackEncoding;
            Force?: boolean;
            GenerateRules?: number;
            GenerateRulesFuncSel?: string;
            GenerateRulesFunMax?: number;
            GenerateRulesFunMin?: number;
            GenerateRulesSeed?: number;
            Hashes?: string[];
            HashInfo?: boolean;
            HashType?: HashType;
            HccapxMessagePair?: number;
            HexCharset?: boolean;
            HexSalt?: boolean;
            HexWordlist?: boolean;
            HookThreads?: number;
            HwmonDisable?: boolean;
            HwmonTempAbort?: number;
            Identify?: string;
            Increment?: boolean;
            IncrementMax?: number;
            IncrementMin?: number;
            KeepGuessing?: boolean;
            KernelAccel?: number;
            KernelLoops?: number;
            KernelThreads?: number;
            KeyboardLayoutMapping?: Buffer<ArrayBufferLike>;
            Keyspace?: boolean;
            Left?: boolean;
            Limit?: string;
            LogfileDisable?: boolean;
            Loopback?: boolean;
            MachineReadable?: boolean;
            MarkovClassic?: boolean;
            MarkovDisable?: boolean;
            MarkovHcstat2?: Buffer<ArrayBufferLike>;
            MarkovInverse?: boolean;
            MarkovThreshold?: number;
            MultiplyAccelDisabled?: boolean;
            NonceErrorCorrections?: number;
            OpenCLDeviceTypes?: number[];
            OptimizedKernelEnable?: boolean;
            OutfileAutohexDisable?: boolean;
            OutfileCheckTimer?: number;
            OutfileFormat?: CrackOutfileFormat[];
            Potfile?: Buffer<ArrayBufferLike>;
            PotfileDisable?: boolean;
            ProgressOnly?: boolean;
            Quiet?: boolean;
            Remove?: boolean;
            RemoveTimer?: number;
            Restore?: boolean;
            RestoreDisable?: boolean;
            RestoreFile?: Buffer<ArrayBufferLike>;
            RulesFile?: Buffer<ArrayBufferLike>;
            Runtime?: number;
            ScryptTMTO?: number;
            SegmentSize?: number;
            SelfTestDisable?: boolean;
            Separator?: string;
            Session?: string;
            Show?: boolean;
            Skip?: string;
            SlowCandidates?: boolean;
            SpeedOnly?: boolean;
            SpinDamp?: number;
            Status?: boolean;
            StatusJSON?: boolean;
            StatusTimer?: number;
            StdinTimeoutAbort?: number;
            Stdout?: boolean;
            Username?: boolean;
            WordlistAutohexDisable?: boolean;
            WorkloadProfile?: CrackWorkloadProfile;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.CrackResponse>;
    crackFileChunkDownload(
        request: {
            CrackFileID?: string;
            Data?: Buffer<ArrayBufferLike>;
            ID?: string;
            N?: number;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.CrackFileChunk>;
    crackFileChunkUpload(
        request: {
            CrackFileID?: string;
            Data?: Buffer<ArrayBufferLike>;
            ID?: string;
            N?: number;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    crackFileComplete(
        request: {
            Chunks?: {
                CrackFileID?: string;
                Data?: Buffer<ArrayBufferLike>;
                ID?: string;
                N?: number;
            }[];
            ChunkSize?: string;
            CreatedAt?: string;
            ID?: string;
            IsCompressed?: boolean;
            LastModified?: string;
            MaxFileSize?: string;
            Name?: string;
            Sha2256?: string;
            Type?: CrackFileType;
            UncompressedSize?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    crackFileCreate(
        request: {
            Chunks?: {
                CrackFileID?: string;
                Data?: Buffer<ArrayBufferLike>;
                ID?: string;
                N?: number;
            }[];
            ChunkSize?: string;
            CreatedAt?: string;
            ID?: string;
            IsCompressed?: boolean;
            LastModified?: string;
            MaxFileSize?: string;
            Name?: string;
            Sha2256?: string;
            Type?: CrackFileType;
            UncompressedSize?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.CrackFile>;
    crackFileDelete(
        request: {
            Chunks?: {
                CrackFileID?: string;
                Data?: Buffer<ArrayBufferLike>;
                ID?: string;
                N?: number;
            }[];
            ChunkSize?: string;
            CreatedAt?: string;
            ID?: string;
            IsCompressed?: boolean;
            LastModified?: string;
            MaxFileSize?: string;
            Name?: string;
            Sha2256?: string;
            Type?: CrackFileType;
            UncompressedSize?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    crackFilesList(
        request: {
            Chunks?: {
                CrackFileID?: string;
                Data?: Buffer<ArrayBufferLike>;
                ID?: string;
                N?: number;
            }[];
            ChunkSize?: string;
            CreatedAt?: string;
            ID?: string;
            IsCompressed?: boolean;
            LastModified?: string;
            MaxFileSize?: string;
            Name?: string;
            Sha2256?: string;
            Type?: CrackFileType;
            UncompressedSize?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.CrackFiles>;
    crackstationBenchmark(
        request: {
            Benchmarks?: { [key: number]: undefined | string };
            HostUUID?: string;
            Name?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    crackstationRegister(
        request: {
            Benchmarks?: { [key: number]: undefined | string };
            CUDA?: {
                Clock?: number;
                CUDAVersion?: string;
                MemoryFree?: string;
                MemoryTotal?: string;
                Name?: string;
                Processors?: number;
                Type?: string;
                Vendor?: string;
                VendorID?: number;
                Version?: string;
            }[];
            GOARCH?: string;
            GOOS?: string;
            HashcatVersion?: string;
            HostUUID?: string;
            ID?: string;
            Metal?: {
                Clock?: number;
                MemoryFree?: string;
                MemoryTotal?: string;
                MetalVersion?: string;
                Name?: string;
                Processors?: number;
                Type?: string;
                Vendor?: string;
                VendorID?: number;
                Version?: string;
            }[];
            Name?: string;
            OpenCL?: {
                Clock?: number;
                MemoryFree?: string;
                MemoryTotal?: string;
                Name?: string;
                OpenCLDriverVersion?: string;
                OpenCLVersion?: string;
                Processors?: number;
                Type?: string;
                Vendor?: string;
                VendorID?: number;
                Version?: string;
            }[];
            OperatorName?: string;
            Version?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): AsyncIterable<clientpb.Event>;
    crackstations(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Crackstations>;
    crackstationTrigger(
        request: {
            Client?: {
                ID?: number;
                Name?: string;
                Operator?: { Name?: string; Online?: boolean };
            };
            Data?: Buffer<ArrayBufferLike>;
            Err?: string;
            EventType?: string;
            Job?: {
                Description?: string;
                Domains?: string[];
                ID?: number;
                Name?: string;
                Port?: number;
                ProfileName?: string;
                Protocol?: string;
            };
            Session?: {
                ActiveC2?: string;
                Arch?: string;
                Burned?: boolean;
                Evasion?: boolean;
                Extensions?: string[];
                Filename?: string;
                FirstContact?: string;
                GID?: string;
                Hostname?: string;
                ID?: string;
                Integrity?: string;
                IsDead?: boolean;
                LastCheckin?: string;
                Locale?: string;
                Name?: string;
                OS?: string;
                PeerID?: string;
                PID?: number;
                ProxyURL?: string;
                ReconnectInterval?: string;
                RemoteAddress?: string;
                Transport?: string;
                UID?: string;
                Username?: string;
                UUID?: string;
                Version?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    crackTaskByID(
        request: {
            Command?: {
                AttackMode?: CrackAttackMode;
                BackendDevices?: number[];
                BackendIgnoreCUDA?: boolean;
                BackendIgnoreHip?: boolean;
                BackendIgnoreMetal?: boolean;
                BackendIgnoreOpenCL?: boolean;
                BackendInfo?: boolean;
                BackendVectorWidth?: number;
                Benchmark?: boolean;
                BenchmarkAll?: boolean;
                BitmapMax?: number;
                BitmapMin?: number;
                BrainClient?: boolean;
                BrainClientFeatures?: string;
                BrainHost?: string;
                BrainPassword?: string;
                BrainPort?: number;
                BrainServer?: boolean;
                BrainServerTimer?: number;
                BrainSession?: string;
                BrainSessionWhitelist?: string;
                CPUAffinity?: number[];
                CustomCharset1?: string;
                CustomCharset2?: string;
                CustomCharset3?: string;
                CustomCharset4?: string;
                DebugMode?: number;
                DeprecatedCheckDisable?: boolean;
                EncodingFrom?: CrackEncoding;
                EncodingTo?: CrackEncoding;
                Force?: boolean;
                GenerateRules?: number;
                GenerateRulesFuncSel?: string;
                GenerateRulesFunMax?: number;
                GenerateRulesFunMin?: number;
                GenerateRulesSeed?: number;
                Hashes?: string[];
                HashInfo?: boolean;
                HashType?: HashType;
                HccapxMessagePair?: number;
                HexCharset?: boolean;
                HexSalt?: boolean;
                HexWordlist?: boolean;
                HookThreads?: number;
                HwmonDisable?: boolean;
                HwmonTempAbort?: number;
                Identify?: string;
                Increment?: boolean;
                IncrementMax?: number;
                IncrementMin?: number;
                KeepGuessing?: boolean;
                KernelAccel?: number;
                KernelLoops?: number;
                KernelThreads?: number;
                KeyboardLayoutMapping?: Buffer<ArrayBufferLike>;
                Keyspace?: boolean;
                Left?: boolean;
                Limit?: string;
                LogfileDisable?: boolean;
                Loopback?: boolean;
                MachineReadable?: boolean;
                MarkovClassic?: boolean;
                MarkovDisable?: boolean;
                MarkovHcstat2?: Buffer<ArrayBufferLike>;
                MarkovInverse?: boolean;
                MarkovThreshold?: number;
                MultiplyAccelDisabled?: boolean;
                NonceErrorCorrections?: number;
                OpenCLDeviceTypes?: number[];
                OptimizedKernelEnable?: boolean;
                OutfileAutohexDisable?: boolean;
                OutfileCheckTimer?: number;
                OutfileFormat?: CrackOutfileFormat[];
                Potfile?: Buffer<ArrayBufferLike>;
                PotfileDisable?: boolean;
                ProgressOnly?: boolean;
                Quiet?: boolean;
                Remove?: boolean;
                RemoveTimer?: number;
                Restore?: boolean;
                RestoreDisable?: boolean;
                RestoreFile?: Buffer<ArrayBufferLike>;
                RulesFile?: Buffer<ArrayBufferLike>;
                Runtime?: number;
                ScryptTMTO?: number;
                SegmentSize?: number;
                SelfTestDisable?: boolean;
                Separator?: string;
                Session?: string;
                Show?: boolean;
                Skip?: string;
                SlowCandidates?: boolean;
                SpeedOnly?: boolean;
                SpinDamp?: number;
                Status?: boolean;
                StatusJSON?: boolean;
                StatusTimer?: number;
                StdinTimeoutAbort?: number;
                Stdout?: boolean;
                Username?: boolean;
                WordlistAutohexDisable?: boolean;
                WorkloadProfile?: CrackWorkloadProfile;
            };
            CompletedAt?: string;
            CreatedAt?: string;
            Err?: string;
            HostUUID?: string;
            ID?: string;
            StartedAt?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.CrackTask>;
    crackTaskUpdate(
        request: {
            Command?: {
                AttackMode?: CrackAttackMode;
                BackendDevices?: number[];
                BackendIgnoreCUDA?: boolean;
                BackendIgnoreHip?: boolean;
                BackendIgnoreMetal?: boolean;
                BackendIgnoreOpenCL?: boolean;
                BackendInfo?: boolean;
                BackendVectorWidth?: number;
                Benchmark?: boolean;
                BenchmarkAll?: boolean;
                BitmapMax?: number;
                BitmapMin?: number;
                BrainClient?: boolean;
                BrainClientFeatures?: string;
                BrainHost?: string;
                BrainPassword?: string;
                BrainPort?: number;
                BrainServer?: boolean;
                BrainServerTimer?: number;
                BrainSession?: string;
                BrainSessionWhitelist?: string;
                CPUAffinity?: number[];
                CustomCharset1?: string;
                CustomCharset2?: string;
                CustomCharset3?: string;
                CustomCharset4?: string;
                DebugMode?: number;
                DeprecatedCheckDisable?: boolean;
                EncodingFrom?: CrackEncoding;
                EncodingTo?: CrackEncoding;
                Force?: boolean;
                GenerateRules?: number;
                GenerateRulesFuncSel?: string;
                GenerateRulesFunMax?: number;
                GenerateRulesFunMin?: number;
                GenerateRulesSeed?: number;
                Hashes?: string[];
                HashInfo?: boolean;
                HashType?: HashType;
                HccapxMessagePair?: number;
                HexCharset?: boolean;
                HexSalt?: boolean;
                HexWordlist?: boolean;
                HookThreads?: number;
                HwmonDisable?: boolean;
                HwmonTempAbort?: number;
                Identify?: string;
                Increment?: boolean;
                IncrementMax?: number;
                IncrementMin?: number;
                KeepGuessing?: boolean;
                KernelAccel?: number;
                KernelLoops?: number;
                KernelThreads?: number;
                KeyboardLayoutMapping?: Buffer<ArrayBufferLike>;
                Keyspace?: boolean;
                Left?: boolean;
                Limit?: string;
                LogfileDisable?: boolean;
                Loopback?: boolean;
                MachineReadable?: boolean;
                MarkovClassic?: boolean;
                MarkovDisable?: boolean;
                MarkovHcstat2?: Buffer<ArrayBufferLike>;
                MarkovInverse?: boolean;
                MarkovThreshold?: number;
                MultiplyAccelDisabled?: boolean;
                NonceErrorCorrections?: number;
                OpenCLDeviceTypes?: number[];
                OptimizedKernelEnable?: boolean;
                OutfileAutohexDisable?: boolean;
                OutfileCheckTimer?: number;
                OutfileFormat?: CrackOutfileFormat[];
                Potfile?: Buffer<ArrayBufferLike>;
                PotfileDisable?: boolean;
                ProgressOnly?: boolean;
                Quiet?: boolean;
                Remove?: boolean;
                RemoveTimer?: number;
                Restore?: boolean;
                RestoreDisable?: boolean;
                RestoreFile?: Buffer<ArrayBufferLike>;
                RulesFile?: Buffer<ArrayBufferLike>;
                Runtime?: number;
                ScryptTMTO?: number;
                SegmentSize?: number;
                SelfTestDisable?: boolean;
                Separator?: string;
                Session?: string;
                Show?: boolean;
                Skip?: string;
                SlowCandidates?: boolean;
                SpeedOnly?: boolean;
                SpinDamp?: number;
                Status?: boolean;
                StatusJSON?: boolean;
                StatusTimer?: number;
                StdinTimeoutAbort?: number;
                Stdout?: boolean;
                Username?: boolean;
                WordlistAutohexDisable?: boolean;
                WorkloadProfile?: CrackWorkloadProfile;
            };
            CompletedAt?: string;
            CreatedAt?: string;
            Err?: string;
            HostUUID?: string;
            ID?: string;
            StartedAt?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    createSocks(
        request: { SessionID?: string; TunnelID?: string },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Socks>;
    createTunnel(
        request: { SessionID?: string; TunnelID?: string },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Tunnel>;
    creds(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Credentials>;
    credsAdd(
        request: {
            Credentials?: {
                Collection?: string;
                Hash?: string;
                HashType?: HashType;
                ID?: string;
                IsCracked?: boolean;
                OriginHostUUID?: string;
                Plaintext?: string;
                Username?: string;
            }[];
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    credsRm(
        request: {
            Credentials?: {
                Collection?: string;
                Hash?: string;
                HashType?: HashType;
                ID?: string;
                IsCracked?: boolean;
                OriginHostUUID?: string;
                Plaintext?: string;
                Username?: string;
            }[];
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    credsSniffHashType(
        request: {
            Collection?: string;
            Hash?: string;
            HashType?: HashType;
            ID?: string;
            IsCracked?: boolean;
            OriginHostUUID?: string;
            Plaintext?: string;
            Username?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Credential>;
    credsUpdate(
        request: {
            Credentials?: {
                Collection?: string;
                Hash?: string;
                HashType?: HashType;
                ID?: string;
                IsCracked?: boolean;
                OriginHostUUID?: string;
                Plaintext?: string;
                Username?: string;
            }[];
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    currentTokenOwner(
        request: {
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.CurrentTokenOwner>;
    deleteImplantBuild(
        request: { Name?: string },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    deleteImplantProfile(
        request: { Name?: string },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    download(
        request: {
            MaxBytes?: string;
            MaxLines?: string;
            Path?: string;
            Recurse?: boolean;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            RestrictedToFile?: boolean;
            Start?: string;
            Stop?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Download>;
    events(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): AsyncIterable<clientpb.Event>;
    execute(
        request: {
            Args?: string[];
            Background?: boolean;
            Env?: { [key: string]: undefined | string };
            EnvInheritance?: boolean;
            Output?: boolean;
            Path?: string;
            PPid?: number;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            Stderr?: string;
            Stdout?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Execute>;
    executeAssembly(
        request: {
            AmsiBypass?: boolean;
            AppDomain?: string;
            Arch?: string;
            Arguments?: string[];
            Assembly?: Buffer<ArrayBufferLike>;
            ClassName?: string;
            EtwBypass?: boolean;
            InProcess?: boolean;
            IsDLL?: boolean;
            Method?: string;
            PPid?: number;
            Process?: string;
            ProcessArgs?: string[];
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            Runtime?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.ExecuteAssembly>;
    executeChildren(
        request: {
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.ExecuteChildren>;
    executeWindows(
        request: {
            Args?: string[];
            Background?: boolean;
            HideWindow?: boolean;
            Output?: boolean;
            Path?: string;
            PPid?: number;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            Stderr?: string;
            Stdout?: string;
            UseToken?: boolean;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Execute>;
    execWasmExtension(
        request: {
            Args?: string[];
            Interactive?: boolean;
            MemFS?: { [key: string]: undefined | Buffer<ArrayBufferLike> };
            Name?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            TunnelID?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.ExecWasmExtension>;
    generate(
        request: {
            Config?: {
                Assets?: { Data?: Buffer<ArrayBufferLike>; Name?: string }[];
                BeaconInterval?: string;
                BeaconJitter?: string;
                C2?: { ID?: string; Options?: string; Priority?: number; URL?: string }[];
                CanaryDomains?: string[];
                ConnectionStrategy?: string;
                Debug?: boolean;
                DebugFile?: string;
                Evasion?: boolean;
                exports?: string[];
                Extension?: string;
                Format?: OutputFormat;
                GOARCH?: string;
                GOOS?: string;
                GoPackage?: string;
                HTTPC2ConfigName?: string;
                ID?: string;
                ImplantBuilds?: {
                    AgeServerPublicKey?: string;
                    Burned?: boolean;
                    ID?: string;
                    ImplantConfigID?: string;
                    ImplantID?: string;
                    MD5?: string;
                    MinisignServerPublicKey?: string;
                    MtlsCACert?: string;
                    MtlsCert?: string;
                    MtlsKey?: string;
                    Name?: string;
                    PeerPrivateKey?: string;
                    PeerPublicKey?: string;
                    PeerPublicKeyDigest?: string;
                    PeerPublicKeySignature?: string;
                    SHA1?: string;
                    SHA256?: string;
                    Stage?: boolean;
                    WGImplantPrivKey?: string;
                    WGServerPubKey?: string;
                }[];
                ImplantProfileID?: string;
                IncludeDNS?: boolean;
                IncludeHTTP?: boolean;
                IncludeMTLS?: boolean;
                IncludeNamePipe?: boolean;
                IncludeTCP?: boolean;
                IncludeWG?: boolean;
                IsBeacon?: boolean;
                IsService?: boolean;
                IsSharedLib?: boolean;
                IsShellcode?: boolean;
                LimitDatetime?: string;
                LimitDomainJoined?: boolean;
                LimitFileExists?: string;
                LimitHostname?: string;
                LimitLocale?: string;
                LimitUsername?: string;
                MaxConnectionErrors?: number;
                NetGoEnabled?: boolean;
                ObfuscateSymbols?: boolean;
                PollTimeout?: string;
                ReconnectInterval?: string;
                RunAtLoad?: boolean;
                SGNEnabled?: boolean;
                ShellcodeConfig?: {
                    Bypass?: number;
                    Compress?: number;
                    Entropy?: number;
                    ExitOpt?: number;
                    Headers?: number;
                    OEP?: number;
                    Thread?: boolean;
                    Unicode?: boolean;
                };
                ShellcodeEncoder?: ShellcodeEncoder;
                TemplateName?: string;
                TrafficEncoders?: string[];
                TrafficEncodersEnabled?: boolean;
                WGKeyExchangePort?: number;
                WGPeerTunIP?: string;
                WGTcpCommsPort?: number;
            };
            Name?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Generate>;
    generateExternal(
        request: {
            BuilderName?: string;
            Config?: {
                Assets?: { Data?: Buffer<ArrayBufferLike>; Name?: string }[];
                BeaconInterval?: string;
                BeaconJitter?: string;
                C2?: { ID?: string; Options?: string; Priority?: number; URL?: string }[];
                CanaryDomains?: string[];
                ConnectionStrategy?: string;
                Debug?: boolean;
                DebugFile?: string;
                Evasion?: boolean;
                exports?: string[];
                Extension?: string;
                Format?: OutputFormat;
                GOARCH?: string;
                GOOS?: string;
                GoPackage?: string;
                HTTPC2ConfigName?: string;
                ID?: string;
                ImplantBuilds?: {
                    AgeServerPublicKey?: string;
                    Burned?: boolean;
                    ID?: string;
                    ImplantConfigID?: string;
                    ImplantID?: string;
                    MD5?: string;
                    MinisignServerPublicKey?: string;
                    MtlsCACert?: string;
                    MtlsCert?: string;
                    MtlsKey?: string;
                    Name?: string;
                    PeerPrivateKey?: string;
                    PeerPublicKey?: string;
                    PeerPublicKeyDigest?: string;
                    PeerPublicKeySignature?: string;
                    SHA1?: string;
                    SHA256?: string;
                    Stage?: boolean;
                    WGImplantPrivKey?: string;
                    WGServerPubKey?: string;
                }[];
                ImplantProfileID?: string;
                IncludeDNS?: boolean;
                IncludeHTTP?: boolean;
                IncludeMTLS?: boolean;
                IncludeNamePipe?: boolean;
                IncludeTCP?: boolean;
                IncludeWG?: boolean;
                IsBeacon?: boolean;
                IsService?: boolean;
                IsSharedLib?: boolean;
                IsShellcode?: boolean;
                LimitDatetime?: string;
                LimitDomainJoined?: boolean;
                LimitFileExists?: string;
                LimitHostname?: string;
                LimitLocale?: string;
                LimitUsername?: string;
                MaxConnectionErrors?: number;
                NetGoEnabled?: boolean;
                ObfuscateSymbols?: boolean;
                PollTimeout?: string;
                ReconnectInterval?: string;
                RunAtLoad?: boolean;
                SGNEnabled?: boolean;
                ShellcodeConfig?: {
                    Bypass?: number;
                    Compress?: number;
                    Entropy?: number;
                    ExitOpt?: number;
                    Headers?: number;
                    OEP?: number;
                    Thread?: boolean;
                    Unicode?: boolean;
                };
                ShellcodeEncoder?: ShellcodeEncoder;
                TemplateName?: string;
                TrafficEncoders?: string[];
                TrafficEncodersEnabled?: boolean;
                WGKeyExchangePort?: number;
                WGPeerTunIP?: string;
                WGTcpCommsPort?: number;
            };
            Name?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.ExternalImplantConfig>;
    generateExternalGetBuildConfig(
        request: {
            AgeServerPublicKey?: string;
            Burned?: boolean;
            ID?: string;
            ImplantConfigID?: string;
            ImplantID?: string;
            MD5?: string;
            MinisignServerPublicKey?: string;
            MtlsCACert?: string;
            MtlsCert?: string;
            MtlsKey?: string;
            Name?: string;
            PeerPrivateKey?: string;
            PeerPublicKey?: string;
            PeerPublicKeyDigest?: string;
            PeerPublicKeySignature?: string;
            SHA1?: string;
            SHA256?: string;
            Stage?: boolean;
            WGImplantPrivKey?: string;
            WGServerPubKey?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.ExternalImplantConfig>;
    generateExternalSaveBuild(
        request: {
            File?: { Data?: Buffer<ArrayBufferLike>; Name?: string };
            ImplantBuildID?: string;
            Name?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    generateStage(
        request: {
            AESEncryptIv?: string;
            AESEncryptKey?: string;
            Compress?: string;
            CompressF?: string;
            Name?: string;
            PrependSize?: boolean;
            Profile?: string;
            RC4EncryptKey?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Generate>;
    generateUniqueIP(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.UniqueWGIP>;
    generateWGClientConfig(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.WGClientConfig>;
    getBeacon(
        request: {
            ActiveC2?: string;
            Arch?: string;
            Burned?: boolean;
            Evasion?: boolean;
            Filename?: string;
            FirstContact?: string;
            GID?: string;
            Hostname?: string;
            ID?: string;
            Integrity?: string;
            Interval?: string;
            IsDead?: boolean;
            Jitter?: string;
            LastCheckin?: string;
            Locale?: string;
            Name?: string;
            NextCheckin?: string;
            OS?: string;
            PID?: number;
            ProxyURL?: string;
            ReconnectInterval?: string;
            RemoteAddress?: string;
            TasksCount?: string;
            TasksCountCompleted?: string;
            Transport?: string;
            UID?: string;
            Username?: string;
            UUID?: string;
            Version?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Beacon>;
    getBeacons(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Beacons>;
    getBeaconTaskContent(
        request: {
            BeaconID?: string;
            CompletedAt?: string;
            CreatedAt?: string;
            Description?: string;
            ID?: string;
            Request?: Buffer<ArrayBufferLike>;
            Response?: Buffer<ArrayBufferLike>;
            SentAt?: string;
            State?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.BeaconTask>;
    getBeaconTasks(
        request: {
            ActiveC2?: string;
            Arch?: string;
            Burned?: boolean;
            Evasion?: boolean;
            Filename?: string;
            FirstContact?: string;
            GID?: string;
            Hostname?: string;
            ID?: string;
            Integrity?: string;
            Interval?: string;
            IsDead?: boolean;
            Jitter?: string;
            LastCheckin?: string;
            Locale?: string;
            Name?: string;
            NextCheckin?: string;
            OS?: string;
            PID?: number;
            ProxyURL?: string;
            ReconnectInterval?: string;
            RemoteAddress?: string;
            TasksCount?: string;
            TasksCountCompleted?: string;
            Transport?: string;
            UID?: string;
            Username?: string;
            UUID?: string;
            Version?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.BeaconTasks>;
    getCertificateAuthorityInfo(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.CertificateAuthorityInfo>;
    getCertificateInfo(
        request: { CategoryFilters?: number; CN?: string },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.CertificateInfo>;
    getCompiler(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Compiler>;
    getCredByID(
        request: {
            Collection?: string;
            Hash?: string;
            HashType?: HashType;
            ID?: string;
            IsCracked?: boolean;
            OriginHostUUID?: string;
            Plaintext?: string;
            Username?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Credential>;
    getCredsByHashType(
        request: {
            Collection?: string;
            Hash?: string;
            HashType?: HashType;
            ID?: string;
            IsCracked?: boolean;
            OriginHostUUID?: string;
            Plaintext?: string;
            Username?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Credentials>;
    getEnv(
        request: {
            Name?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.EnvInfo>;
    getHTTPC2ProfileByName(
        request: { Name?: string },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.HTTPC2Config>;
    getHTTPC2Profiles(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.HTTPC2Configs>;
    getJobs(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Jobs>;
    getOperators(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Operators>;
    getPlaintextCredsByHashType(
        request: {
            Collection?: string;
            Hash?: string;
            HashType?: HashType;
            ID?: string;
            IsCracked?: boolean;
            OriginHostUUID?: string;
            Plaintext?: string;
            Username?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Credentials>;
    getPrivs(
        request: {
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.GetPrivs>;
    getRportFwdListeners(
        request: {
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.RportFwdListeners>;
    getSessions(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Sessions>;
    getSystem(
        request: {
            Config?: {
                Assets?: { Data?: Buffer<ArrayBufferLike>; Name?: string }[];
                BeaconInterval?: string;
                BeaconJitter?: string;
                C2?: { ID?: string; Options?: string; Priority?: number; URL?: string }[];
                CanaryDomains?: string[];
                ConnectionStrategy?: string;
                Debug?: boolean;
                DebugFile?: string;
                Evasion?: boolean;
                exports?: string[];
                Extension?: string;
                Format?: OutputFormat;
                GOARCH?: string;
                GOOS?: string;
                GoPackage?: string;
                HTTPC2ConfigName?: string;
                ID?: string;
                ImplantBuilds?: {
                    AgeServerPublicKey?: string;
                    Burned?: boolean;
                    ID?: string;
                    ImplantConfigID?: string;
                    ImplantID?: string;
                    MD5?: string;
                    MinisignServerPublicKey?: string;
                    MtlsCACert?: string;
                    MtlsCert?: string;
                    MtlsKey?: string;
                    Name?: string;
                    PeerPrivateKey?: string;
                    PeerPublicKey?: string;
                    PeerPublicKeyDigest?: string;
                    PeerPublicKeySignature?: string;
                    SHA1?: string;
                    SHA256?: string;
                    Stage?: boolean;
                    WGImplantPrivKey?: string;
                    WGServerPubKey?: string;
                }[];
                ImplantProfileID?: string;
                IncludeDNS?: boolean;
                IncludeHTTP?: boolean;
                IncludeMTLS?: boolean;
                IncludeNamePipe?: boolean;
                IncludeTCP?: boolean;
                IncludeWG?: boolean;
                IsBeacon?: boolean;
                IsService?: boolean;
                IsSharedLib?: boolean;
                IsShellcode?: boolean;
                LimitDatetime?: string;
                LimitDomainJoined?: boolean;
                LimitFileExists?: string;
                LimitHostname?: string;
                LimitLocale?: string;
                LimitUsername?: string;
                MaxConnectionErrors?: number;
                NetGoEnabled?: boolean;
                ObfuscateSymbols?: boolean;
                PollTimeout?: string;
                ReconnectInterval?: string;
                RunAtLoad?: boolean;
                SGNEnabled?: boolean;
                ShellcodeConfig?: {
                    Bypass?: number;
                    Compress?: number;
                    Entropy?: number;
                    ExitOpt?: number;
                    Headers?: number;
                    OEP?: number;
                    Thread?: boolean;
                    Unicode?: boolean;
                };
                ShellcodeEncoder?: ShellcodeEncoder;
                TemplateName?: string;
                TrafficEncoders?: string[];
                TrafficEncodersEnabled?: boolean;
                WGKeyExchangePort?: number;
                WGPeerTunIP?: string;
                WGTcpCommsPort?: number;
            };
            HostingProcess?: string;
            Name?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.GetSystem>;
    getVersion(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Version>;
    grep(
        request: {
            LinesAfter?: number;
            LinesBefore?: number;
            Path?: string;
            Recursive?: boolean;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            SearchPattern?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Grep>;
    hijackDLL(
        request: {
            Name?: string;
            ProfileName?: string;
            ReferenceDLL?: Buffer<ArrayBufferLike>;
            ReferenceDLLPath?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            TargetDLL?: Buffer<ArrayBufferLike>;
            TargetLocation?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.DllHijack>;
    host(
        request: {
            ExtensionData?: { [key: string]: undefined | { Output?: string } };
            FirstContact?: string;
            Hostname?: string;
            HostUUID?: string;
            ID?: string;
            IOCs?: { FileHash?: string; ID?: string; Path?: string }[];
            Locale?: string;
            OSVersion?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Host>;
    hostIOCRm(
        request: { FileHash?: string; ID?: string; Path?: string },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    hostRm(
        request: {
            ExtensionData?: { [key: string]: undefined | { Output?: string } };
            FirstContact?: string;
            Hostname?: string;
            HostUUID?: string;
            ID?: string;
            IOCs?: { FileHash?: string; ID?: string; Path?: string }[];
            Locale?: string;
            OSVersion?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    hosts(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.AllHosts>;
    ifconfig(
        request: {
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Ifconfig>;
    impersonate(
        request: {
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            Username?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Impersonate>;
    implantBuilds(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.ImplantBuilds>;
    implantProfiles(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.ImplantProfiles>;
    kill(
        request: {
            Force?: boolean;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    killJob(
        request: { ID?: number },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.KillJob>;
    listExtensions(
        request: {
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.ListExtensions>;
    listWasmExtensions(
        request: {
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.ListWasmExtensions>;
    lootAdd(
        request: {
            File?: { Data?: Buffer<ArrayBufferLike>; Name?: string };
            FileType?: FileType;
            ID?: string;
            Name?: string;
            OriginHostUUID?: string;
            Size?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Loot>;
    lootAll(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.AllLoot>;
    lootContent(
        request: {
            File?: { Data?: Buffer<ArrayBufferLike>; Name?: string };
            FileType?: FileType;
            ID?: string;
            Name?: string;
            OriginHostUUID?: string;
            Size?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Loot>;
    lootRm(
        request: {
            File?: { Data?: Buffer<ArrayBufferLike>; Name?: string };
            FileType?: FileType;
            ID?: string;
            Name?: string;
            OriginHostUUID?: string;
            Size?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    lootUpdate(
        request: {
            File?: { Data?: Buffer<ArrayBufferLike>; Name?: string };
            FileType?: FileType;
            ID?: string;
            Name?: string;
            OriginHostUUID?: string;
            Size?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Loot>;
    ls(
        request: {
            Path?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Ls>;
    makeToken(
        request: {
            Domain?: string;
            LogonType?: number;
            Password?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            Username?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.MakeToken>;
    memfilesAdd(
        request: {
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.MemfilesAdd>;
    memfilesList(
        request: {
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Ls>;
    memfilesRm(
        request: {
            Fd?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.MemfilesRm>;
    migrate(
        request: {
            Config?: {
                Assets?: { Data?: Buffer<ArrayBufferLike>; Name?: string }[];
                BeaconInterval?: string;
                BeaconJitter?: string;
                C2?: { ID?: string; Options?: string; Priority?: number; URL?: string }[];
                CanaryDomains?: string[];
                ConnectionStrategy?: string;
                Debug?: boolean;
                DebugFile?: string;
                Evasion?: boolean;
                exports?: string[];
                Extension?: string;
                Format?: OutputFormat;
                GOARCH?: string;
                GOOS?: string;
                GoPackage?: string;
                HTTPC2ConfigName?: string;
                ID?: string;
                ImplantBuilds?: {
                    AgeServerPublicKey?: string;
                    Burned?: boolean;
                    ID?: string;
                    ImplantConfigID?: string;
                    ImplantID?: string;
                    MD5?: string;
                    MinisignServerPublicKey?: string;
                    MtlsCACert?: string;
                    MtlsCert?: string;
                    MtlsKey?: string;
                    Name?: string;
                    PeerPrivateKey?: string;
                    PeerPublicKey?: string;
                    PeerPublicKeyDigest?: string;
                    PeerPublicKeySignature?: string;
                    SHA1?: string;
                    SHA256?: string;
                    Stage?: boolean;
                    WGImplantPrivKey?: string;
                    WGServerPubKey?: string;
                }[];
                ImplantProfileID?: string;
                IncludeDNS?: boolean;
                IncludeHTTP?: boolean;
                IncludeMTLS?: boolean;
                IncludeNamePipe?: boolean;
                IncludeTCP?: boolean;
                IncludeWG?: boolean;
                IsBeacon?: boolean;
                IsService?: boolean;
                IsSharedLib?: boolean;
                IsShellcode?: boolean;
                LimitDatetime?: string;
                LimitDomainJoined?: boolean;
                LimitFileExists?: string;
                LimitHostname?: string;
                LimitLocale?: string;
                LimitUsername?: string;
                MaxConnectionErrors?: number;
                NetGoEnabled?: boolean;
                ObfuscateSymbols?: boolean;
                PollTimeout?: string;
                ReconnectInterval?: string;
                RunAtLoad?: boolean;
                SGNEnabled?: boolean;
                ShellcodeConfig?: {
                    Bypass?: number;
                    Compress?: number;
                    Entropy?: number;
                    ExitOpt?: number;
                    Headers?: number;
                    OEP?: number;
                    Thread?: boolean;
                    Unicode?: boolean;
                };
                ShellcodeEncoder?: ShellcodeEncoder;
                TemplateName?: string;
                TrafficEncoders?: string[];
                TrafficEncodersEnabled?: boolean;
                WGKeyExchangePort?: number;
                WGPeerTunIP?: string;
                WGTcpCommsPort?: number;
            };
            Encoder?: ShellcodeEncoder;
            Name?: string;
            Pid?: number;
            ProcName?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Migrate>;
    mkdir(
        request: {
            Path?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Mkdir>;
    monitorAddConfig(
        request: {
            APIKey?: string;
            APIPassword?: string;
            ID?: string;
            Type?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Response>;
    monitorDelConfig(
        request: {
            APIKey?: string;
            APIPassword?: string;
            ID?: string;
            Type?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Response>;
    monitorListConfig(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.MonitoringProviders>;
    monitorStart(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Response>;
    monitorStop(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    mount(
        request: {
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Mount>;
    msf(
        request: {
            Encoder?: string;
            Iterations?: number;
            LHost?: string;
            LPort?: number;
            Payload?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Task>;
    msfRemote(
        request: {
            Encoder?: string;
            Iterations?: number;
            LHost?: string;
            LPort?: number;
            Payload?: string;
            PID?: number;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Task>;
    mv(
        request: {
            Dst?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            Src?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Mv>;
    netstat(
        request: {
            IP4?: boolean;
            IP6?: boolean;
            Listening?: boolean;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            TCP?: boolean;
            UDP?: boolean;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Netstat>;
    openSession(
        request: {
            C2s?: string[];
            Delay?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            Response?: {
                Async?: boolean;
                BeaconID?: string;
                Err?: string;
                TaskID?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.OpenSession>;
    ping(
        request: {
            Nonce?: number;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            Response?: {
                Async?: boolean;
                BeaconID?: string;
                Err?: string;
                TaskID?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Ping>;
    pivotGraph(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.PivotGraph>;
    pivotSessionListeners(
        request: {
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.PivotListeners>;
    pivotStartListener(
        request: {
            BindAddress?: string;
            Options?: boolean[];
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            Type?: PivotType;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.PivotListener>;
    pivotStopListener(
        request: {
            ID?: number;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    portfwd(
        request: {
            Host?: string;
            Port?: number;
            Protocol?: number;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            TunnelID?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Portfwd>;
    processDump(
        request: {
            Pid?: number;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            Timeout?: number;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.ProcessDump>;
    ps(
        request: {
            FullInfo?: boolean;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Ps>;
    pwd(
        request: {
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Pwd>;
    reconfigure(
        request: {
            BeaconInterval?: string;
            BeaconJitter?: string;
            ReconnectInterval?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Reconfigure>;
    regenerate(
        request: { ImplantName?: string },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Generate>;
    registerExtension(
        request: {
            Data?: Buffer<ArrayBufferLike>;
            Init?: string;
            Name?: string;
            OS?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.RegisterExtension>;
    registerWasmExtension(
        request: {
            Name?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            WasmGz?: Buffer<ArrayBufferLike>;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.RegisterWasmExtension>;
    registryCreateKey(
        request: {
            Hive?: string;
            Hostname?: string;
            Key?: string;
            Path?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.RegistryCreateKey>;
    registryDeleteKey(
        request: {
            Hive?: string;
            Hostname?: string;
            Key?: string;
            Path?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.RegistryDeleteKey>;
    registryListSubKeys(
        request: {
            Hive?: string;
            Hostname?: string;
            Path?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.RegistrySubKeyList>;
    registryListValues(
        request: {
            Hive?: string;
            Hostname?: string;
            Path?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.RegistryValuesList>;
    registryRead(
        request: {
            Hive?: string;
            Hostname?: string;
            Key?: string;
            Path?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.RegistryRead>;
    registryReadHive(
        request: {
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            RequestedHive?: string;
            RootHive?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.RegistryReadHive>;
    registryWrite(
        request: {
            ByteValue?: Buffer<ArrayBufferLike>;
            DWordValue?: number;
            Hive?: string;
            Hostname?: string;
            Key?: string;
            Path?: string;
            QWordValue?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            StringValue?: string;
            Type?: number;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.RegistryWrite>;
    removeService(
        request: {
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            ServiceInfo?: { Hostname?: string; ServiceName?: string };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.ServiceInfo>;
    rename(
        request: { BeaconID?: string; Name?: string; SessionID?: string },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    restartJobs(
        request: { JobIDs?: number[] },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    revToSelf(
        request: {
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.RevToSelf>;
    rm(
        request: {
            Force?: boolean;
            Path?: string;
            Recursive?: boolean;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Rm>;
    rmBeacon(
        request: {
            ActiveC2?: string;
            Arch?: string;
            Burned?: boolean;
            Evasion?: boolean;
            Filename?: string;
            FirstContact?: string;
            GID?: string;
            Hostname?: string;
            ID?: string;
            Integrity?: string;
            Interval?: string;
            IsDead?: boolean;
            Jitter?: string;
            LastCheckin?: string;
            Locale?: string;
            Name?: string;
            NextCheckin?: string;
            OS?: string;
            PID?: number;
            ProxyURL?: string;
            ReconnectInterval?: string;
            RemoteAddress?: string;
            TasksCount?: string;
            TasksCountCompleted?: string;
            Transport?: string;
            UID?: string;
            Username?: string;
            UUID?: string;
            Version?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    runAs(
        request: {
            Args?: string;
            Domain?: string;
            HideWindow?: boolean;
            NetOnly?: boolean;
            Password?: string;
            ProcessName?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            Username?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.RunAs>;
    runSSHCommand(
        request: {
            Command?: string;
            Hostname?: string;
            Keytab?: Buffer<ArrayBufferLike>;
            Krb5Conf?: string;
            Password?: string;
            Port?: number;
            PrivKey?: Buffer<ArrayBufferLike>;
            Realm?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            Username?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.SSHCommand>;
    saveHTTPC2Profile(
        request: {
            C2Config?: {
                Created?: string;
                ID?: string;
                ImplantConfig?: {
                    ChromeBaseVersion?: number;
                    extensions?: string[];
                    ExtraURLParameters?: {
                        ID?: string;
                        Method?: string;
                        Name?: string;
                        Probability?: number;
                        Value?: string;
                    }[];
                    Headers?: {
                        ID?: string;
                        Method?: string;
                        Name?: string;
                        Probability?: number;
                        Value?: string;
                    }[];
                    ID?: string;
                    MacOSVersion?: string;
                    MaxFileGen?: number;
                    MaxPathGen?: number;
                    MaxPathLength?: number;
                    MinFileGen?: number;
                    MinPathGen?: number;
                    MinPathLength?: number;
                    NonceMode?: string;
                    NonceQueryArgChars?: string;
                    NonceQueryLength?: number;
                    PathSegments?: { ID?: string; IsFile?: boolean; Value?: string }[];
                    UserAgent?: string;
                };
                Name?: string;
                ServerConfig?: {
                    Cookies?: { ID?: string; Name?: string }[];
                    Headers?: {
                        ID?: string;
                        Method?: string;
                        Name?: string;
                        Probability?: number;
                        Value?: string;
                    }[];
                    ID?: string;
                    RandomVersionHeaders?: boolean;
                };
            };
            overwrite?: boolean;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    saveImplantProfile(
        request: {
            Config?: {
                Assets?: { Data?: Buffer<ArrayBufferLike>; Name?: string }[];
                BeaconInterval?: string;
                BeaconJitter?: string;
                C2?: { ID?: string; Options?: string; Priority?: number; URL?: string }[];
                CanaryDomains?: string[];
                ConnectionStrategy?: string;
                Debug?: boolean;
                DebugFile?: string;
                Evasion?: boolean;
                exports?: string[];
                Extension?: string;
                Format?: OutputFormat;
                GOARCH?: string;
                GOOS?: string;
                GoPackage?: string;
                HTTPC2ConfigName?: string;
                ID?: string;
                ImplantBuilds?: {
                    AgeServerPublicKey?: string;
                    Burned?: boolean;
                    ID?: string;
                    ImplantConfigID?: string;
                    ImplantID?: string;
                    MD5?: string;
                    MinisignServerPublicKey?: string;
                    MtlsCACert?: string;
                    MtlsCert?: string;
                    MtlsKey?: string;
                    Name?: string;
                    PeerPrivateKey?: string;
                    PeerPublicKey?: string;
                    PeerPublicKeyDigest?: string;
                    PeerPublicKeySignature?: string;
                    SHA1?: string;
                    SHA256?: string;
                    Stage?: boolean;
                    WGImplantPrivKey?: string;
                    WGServerPubKey?: string;
                }[];
                ImplantProfileID?: string;
                IncludeDNS?: boolean;
                IncludeHTTP?: boolean;
                IncludeMTLS?: boolean;
                IncludeNamePipe?: boolean;
                IncludeTCP?: boolean;
                IncludeWG?: boolean;
                IsBeacon?: boolean;
                IsService?: boolean;
                IsSharedLib?: boolean;
                IsShellcode?: boolean;
                LimitDatetime?: string;
                LimitDomainJoined?: boolean;
                LimitFileExists?: string;
                LimitHostname?: string;
                LimitLocale?: string;
                LimitUsername?: string;
                MaxConnectionErrors?: number;
                NetGoEnabled?: boolean;
                ObfuscateSymbols?: boolean;
                PollTimeout?: string;
                ReconnectInterval?: string;
                RunAtLoad?: boolean;
                SGNEnabled?: boolean;
                ShellcodeConfig?: {
                    Bypass?: number;
                    Compress?: number;
                    Entropy?: number;
                    ExitOpt?: number;
                    Headers?: number;
                    OEP?: number;
                    Thread?: boolean;
                    Unicode?: boolean;
                };
                ShellcodeEncoder?: ShellcodeEncoder;
                TemplateName?: string;
                TrafficEncoders?: string[];
                TrafficEncodersEnabled?: boolean;
                WGKeyExchangePort?: number;
                WGPeerTunIP?: string;
                WGTcpCommsPort?: number;
            };
            ID?: string;
            Name?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.ImplantProfile>;
    screenshot(
        request: {
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Screenshot>;
    serviceDetail(
        request: {
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            ServiceInfo?: { Hostname?: string; ServiceName?: string };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.ServiceDetail>;
    services(
        request: {
            Hostname?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Services>;
    setEnv(
        request: {
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            Variable?: { Key?: string; Value?: string };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.SetEnv>;
    shell(
        request: {
            Cols?: number;
            EnablePTY?: boolean;
            Path?: string;
            Pid?: number;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            Rows?: number;
            TunnelID?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Shell>;
    shellcodeEncoder(
        request: {
            Architecture?: string;
            BadChars?: Buffer<ArrayBufferLike>;
            Data?: Buffer<ArrayBufferLike>;
            Encoder?: ShellcodeEncoder;
            Iterations?: number;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.ShellcodeEncode>;
    shellcodeEncoderMap(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.ShellcodeEncoderMap>;
    shellcodeRDI(
        request: {
            Arguments?: string;
            Data?: Buffer<ArrayBufferLike>;
            FunctionName?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.ShellcodeRDI>;
    shellResize(
        request: {
            Cols?: number;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            Rows?: number;
            TunnelID?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    sideload(
        request: {
            Args?: string[];
            Data?: Buffer<ArrayBufferLike>;
            EntryPoint?: string;
            isDLL?: boolean;
            isUnicode?: boolean;
            Kill?: boolean;
            PPid?: number;
            ProcessArgs?: string[];
            ProcessName?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Sideload>;
    socksProxy(
        request: AsyncIterable<
            {
                CloseConn?: boolean;
                Data?: Buffer<ArrayBufferLike>;
                Password?: string;
                Request?: {
                    Async?: boolean;
                    BeaconID?: string;
                    SessionID?: string;
                    Timeout?: string;
                };
                Sequence?: string;
                TunnelID?: string;
                Username?: string;
            },
        >,
        options?: CallOptions & CallOptionsExt,
    ): AsyncIterable<sliverpb.SocksData>;
    spawnDll(
        request: {
            Args?: string[];
            Data?: Buffer<ArrayBufferLike>;
            EntryPoint?: string;
            Kill?: boolean;
            PPid?: number;
            ProcessArgs?: string[];
            ProcessName?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.SpawnDll>;
    stageImplantBuild(
        request: { Build?: string[] },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    startDNSListener(
        request: {
            Canaries?: boolean;
            Domains?: string[];
            EnforceOTP?: boolean;
            Host?: string;
            Port?: number;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.ListenerJob>;
    startHTTPListener(
        request: {
            ACME?: boolean;
            Cert?: Buffer<ArrayBufferLike>;
            Domain?: string;
            EnforceOTP?: boolean;
            Host?: string;
            Key?: Buffer<ArrayBufferLike>;
            LongPollJitter?: string;
            LongPollTimeout?: string;
            Port?: number;
            RandomizeJARM?: boolean;
            Secure?: boolean;
            Website?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.ListenerJob>;
    startHTTPSListener(
        request: {
            ACME?: boolean;
            Cert?: Buffer<ArrayBufferLike>;
            Domain?: string;
            EnforceOTP?: boolean;
            Host?: string;
            Key?: Buffer<ArrayBufferLike>;
            LongPollJitter?: string;
            LongPollTimeout?: string;
            Port?: number;
            RandomizeJARM?: boolean;
            Secure?: boolean;
            Website?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.ListenerJob>;
    startMTLSListener(
        request: { Host?: string; Port?: number },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.ListenerJob>;
    startRportFwdListener(
        request: {
            BindAddress?: string;
            BindPort?: number;
            ForwardAddress?: string;
            ForwardPort?: number;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.RportFwdListener>;
    startService(
        request: {
            Arguments?: string;
            BinPath?: string;
            Hostname?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            ServiceDescription?: string;
            ServiceName?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.ServiceInfo>;
    startServiceByName(
        request: {
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            ServiceInfo?: { Hostname?: string; ServiceName?: string };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.ServiceInfo>;
    startTCPStagerListener(
        request: {
            Data?: Buffer<ArrayBufferLike>;
            Host?: string;
            Port?: number;
            ProfileName?: string;
            Protocol?: StageProtocol;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.StagerListener>;
    startWGListener(
        request: {
            Host?: string;
            KeyPort?: number;
            NPort?: number;
            Port?: number;
            TunIP?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.ListenerJob>;
    stopRportFwdListener(
        request: {
            ID?: number;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.RportFwdListener>;
    stopService(
        request: {
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            ServiceInfo?: { Hostname?: string; ServiceName?: string };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.ServiceInfo>;
    task(
        request: {
            Data?: Buffer<ArrayBufferLike>;
            Encoder?: string;
            Pid?: number;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
            RWXPages?: boolean;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Task>;
    terminate(
        request: {
            Force?: boolean;
            Pid?: number;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Terminate>;
    trafficEncoderAdd(
        request: {
            ID?: string;
            SkipTests?: boolean;
            TestID?: string;
            Wasm?: { Data?: Buffer<ArrayBufferLike>; Name?: string };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.TrafficEncoderTests>;
    trafficEncoderMap(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.TrafficEncoderMap>;
    trafficEncoderRm(
        request: {
            ID?: string;
            SkipTests?: boolean;
            TestID?: string;
            Wasm?: { Data?: Buffer<ArrayBufferLike>; Name?: string };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    tunnelData(
        request: AsyncIterable<
            {
                Ack?: string;
                Closed?: boolean;
                CreateReverse?: boolean;
                Data?: Buffer<ArrayBufferLike>;
                Resend?: boolean;
                rportfwd?: {
                    Host?: string;
                    Port?: number;
                    Protocol?: number;
                    Response?: {
                        Async?: boolean;
                        BeaconID?: string;
                        Err?: string;
                        TaskID?: string;
                    };
                    TunnelID?: string;
                };
                Sequence?: string;
                SessionID?: string;
                TunnelID?: string;
            },
        >,
        options?: CallOptions & CallOptionsExt,
    ): AsyncIterable<sliverpb.TunnelData>;
    unsetEnv(
        request: {
            Name?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.UnsetEnv>;
    updateBeaconIntegrityInformation(
        request: { BeaconID?: string; Integrity?: string },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    upload(
        request: {
            Data?: Buffer<ArrayBufferLike>;
            Encoder?: string;
            FileName?: string;
            IsDirectory?: boolean;
            IsIOC?: boolean;
            Overwrite?: boolean;
            Path?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.Upload>;
    website(
        request: {
            Contents?: {
                [key: string]:
                    | undefined
                    | {
                        Content?: Buffer<ArrayBufferLike>;
                        ContentType?: string;
                        ID?: string;
                        OriginalFile?: string;
                        Path?: string;
                        Sha256?: string;
                        Size?: string;
                        WebsiteID?: string;
                    };
            };
            ID?: string;
            Name?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Website>;
    websiteAddContent(
        request: {
            Contents?: {
                [key: string]:
                    | undefined
                    | {
                        Content?: Buffer<ArrayBufferLike>;
                        ContentType?: string;
                        ID?: string;
                        OriginalFile?: string;
                        Path?: string;
                        Sha256?: string;
                        Size?: string;
                        WebsiteID?: string;
                    };
            };
            Name?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Website>;
    websiteRemove(
        request: {
            Contents?: {
                [key: string]:
                    | undefined
                    | {
                        Content?: Buffer<ArrayBufferLike>;
                        ContentType?: string;
                        ID?: string;
                        OriginalFile?: string;
                        Path?: string;
                        Sha256?: string;
                        Size?: string;
                        WebsiteID?: string;
                    };
            };
            ID?: string;
            Name?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<commonpb.Empty>;
    websiteRemoveContent(
        request: { Name?: string; Paths?: string[] },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Website>;
    websites(
        request: {},
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Websites>;
    websiteUpdateContent(
        request: {
            Contents?: {
                [key: string]:
                    | undefined
                    | {
                        Content?: Buffer<ArrayBufferLike>;
                        ContentType?: string;
                        ID?: string;
                        OriginalFile?: string;
                        Path?: string;
                        Sha256?: string;
                        Size?: string;
                        WebsiteID?: string;
                    };
            };
            Name?: string;
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<clientpb.Website>;
    wGListForwarders(
        request: {
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.WGTCPForwarders>;
    wGListSocksServers(
        request: {
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.WGSocksServers>;
    wGStartPortForward(
        request: {
            LocalPort?: number;
            RemoteAddress?: string;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.WGPortForward>;
    wGStartSocks(
        request: {
            Port?: number;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.WGSocks>;
    wGStopPortForward(
        request: {
            ID?: number;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.WGPortForward>;
    wGStopSocks(
        request: {
            ID?: number;
            Request?: {
                Async?: boolean;
                BeaconID?: string;
                SessionID?: string;
                Timeout?: string;
            };
        },
        options?: CallOptions & CallOptionsExt,
    ): Promise<sliverpb.WGSocks>;
}