Class Dishy

Hierarchy (View Summary)

GRPCApi
- Dishy

Constructors

constructor

new Dishy(__namedParameters?: Options): Dishy
Parameters
- __namedParameters: Options = {}
Returns Dishy
Overrides GRPCApi.constructor

Properties

`Protected`client

client: DeviceClient

`Readonly`host

host: string

`Readonly`port

port: number

`Optional` `Readonly`timeout

timeout?: number

Methods

activate_rssi_scan

activate_rssi_scan(scan?: DishActivateRssiScan): Promise<boolean>
Activates an RSSI scan on the dish
Parameters
- Optionalscan: DishActivateRssiScan
Returns Promise<boolean>

clear_obstruction_map

clear_obstruction_map(): Promise<boolean>
Clears the accumulated obstruction map

Returns Promise<boolean>

close

close(): void
Closes the underlying gRPC channel and releases resources

Returns void
Inherited from GRPCApi.close

factory_reset

factory_reset(app_reset?: boolean): Promise<boolean>
Issues a dish-level factory reset
Parameters
- app_reset: boolean = false
Returns Promise<boolean>

fetch_config

fetch_config(): Promise<DishGetConfigResponse>
Fetches the active dish configuration

Returns Promise<DishGetConfigResponse>

fetch_connections

fetch_connections(): Promise<GetConnectionsResponse>
Fetches the service-side connection state from the dish

Returns Promise<GetConnectionsResponse>

fetch_context

fetch_context(): Promise<DishGetContextResponse>
Fetches dish context information

Returns Promise<DishGetContextResponse>

fetch_device_info

fetch_device_info(): Promise<GetDeviceInfoResponse>
Fetches device-level identification information

Returns Promise<GetDeviceInfoResponse>

fetch_diagnostics

fetch_diagnostics(): Promise<StarlinkGRPC.Dishy.Diagnostics>
Fetches diagnostic information from a dishy

Returns Promise<StarlinkGRPC.Dishy.Diagnostics>

fetch_emc

fetch_emc(): Promise<DishGetEmcResponse>
Fetches dish EMC/RF status

Returns Promise<DishGetEmcResponse>

fetch_gnss_measurement

fetch_gnss_measurement(): Promise<GetGnssMeasurementResponse>
Fetches GNSS measurements observed by the dish (satellite system, PRN, pseudorange, ephemeris) along with the dish device id

Returns Promise<GetGnssMeasurementResponse>

fetch_history

fetch_history(): Promise<DishGetHistoryResponse>
Fetches history information from a dishy

Returns Promise<DishGetHistoryResponse>

fetch_location

fetch_location(source?: PositionSource): Promise<GetLocationResponse>
Fetches location information from a dishy

Note: Location information must be enabled in the dishy settings
Parameters
- Optionalsource: PositionSource
  optional position-source preference; the dish picks its own default when omitted
Returns Promise<GetLocationResponse>

fetch_log

fetch_log(): Promise<GetLogResponse>
Fetches the current and saved log bundles from the dish (syslog, dmesg, kernel panic, netsys debug, etc.)

Returns Promise<GetLogResponse>

fetch_network_interfaces

fetch_network_interfaces(): Promise<GetNetworkInterfacesResponse>
Fetches the configured network interfaces

Returns Promise<GetNetworkInterfacesResponse>

fetch_obstruction_map

fetch_obstruction_map(): Promise<DishGetObstructionMapResponse>
Fetches obstruction map information from a dishy

Returns Promise<DishGetObstructionMapResponse>

`Protected`fetch_or_throw

fetch_or_throw<K extends keyof Response>(
    request: {
        authenticate?: {
            challenge?: {
                data?: Uint8Array<ArrayBufferLike>;
                signature?: Uint8Array<ArrayBufferLike>;
            };
        };
        dishActivateRssiScan?: { scanQuery?: { channel?: number } };
        dishClearObstructionMap?: {};
        dishEmc?: {
            chanOverride?: boolean;
            desiredTiltAngle?: number;
            fastSwitching?: boolean;
            forceEirpFailure?: boolean;
            forcePllUnlock?: boolean;
            idle?: boolean;
            manualTilting?: boolean;
            modulation?: number;
            phi?: number;
            phiEnabled?: boolean;
            reboot?: boolean;
            rxChan?: number;
            skySearch?: boolean;
            snowActiveOverride?: boolean;
            theta?: number;
            thetaEnabled?: boolean;
            tiltToStowed?: boolean;
            txChan?: number;
        };
        dishFactoryReset?: { appReset?: boolean };
        dishGetConfig?: {};
        dishGetContext?: {};
        dishGetEmc?: {};
        dishGetObstructionMap?: {};
        dishGetRssiScanResult?: {};
        dishInhibitGps?: { inhibitGps?: boolean };
        dishInhibitRf?: { inhibitRf?: boolean };
        dishPowerSave?: {
            enablePowerSave?: boolean;
            powerSaveDurationMinutes?: number;
            powerSaveStartMinutes?: number;
        };
        dishSetConfig?: {
            dishConfig?: {
                applyAssetClass?: boolean;
                applyLevelDishMode?: boolean;
                applyLocationRequestMode?: boolean;
                applyPowerSaveDurationMinutes?: boolean;
                applyPowerSaveMode?: boolean;
                applyPowerSaveStartMinutes?: boolean;
                applySnowMeltMode?: boolean;
                applySwupdateRebootHour?: boolean;
                applySwupdateThreeDayDeferralEnabled?: boolean;
                assetClass?: number;
                levelDishMode?: DishConfig_LevelDishMode;
                locationRequestMode?: DishConfig_LocationRequestMode;
                powerSaveDurationMinutes?: number;
                powerSaveMode?: boolean;
                powerSaveStartMinutes?: number;
                snowMeltMode?: DishConfig_SnowMeltMode;
                swupdateRebootHour?: number;
                swupdateThreeDayDeferralEnabled?: boolean;
            };
        };
        dishStow?: { unstow?: boolean };
        enableFlow?: { durationH?: number; name?: string };
        epochId?: number;
        factoryReset?: {};
        fuse?: {};
        getConnections?: {};
        getDeviceInfo?: {};
        getDiagnostics?: {};
        getGnssMeasurement?: {};
        getHeapDump?: {};
        getHistory?: {};
        getLocation?: { source?: PositionSource };
        getLog?: {};
        getNetworkInterfaces?: {};
        getNextId?: {};
        getPing?: {};
        getRadioStats?: {};
        getSpeedtestStatus?: {};
        getStatus?: { routerRole?: RouterRole };
        id?: number;
        pingHost?: { address?: string; size?: number };
        reboot?: {};
        reportClientSpeedtest?: {
            appBuild?: number;
            appVersion?: string;
            clientPlatform?: {
                majorVersion?: number;
                minorVersion?: number;
                platform?: ClientPlatform_Platform;
            };
            clientRssi?: number;
            clientSpeedtest?: {
                downloadBytesProcessed?: number;
                downloadMbps?: number;
                downloadStartTime?: number;
                durationS?: number;
                latencyMs?: number;
                startTime?: number;
                tcpStreams?: number;
                uploadBytesProcessed?: number;
                uploadMbps?: number;
                uploadStartTime?: number;
            };
            id?: number;
            wifiSpeedtest?: {
                downloadBytesProcessed?: number;
                downloadMbps?: number;
                downloadStartTime?: number;
                durationS?: number;
                latencyMs?: number;
                startTime?: number;
                tcpStreams?: number;
                uploadBytesProcessed?: number;
                uploadMbps?: number;
                uploadStartTime?: number;
            };
        };
        resetButton?: { pressed?: boolean };
        restartControl?: {};
        runIperfServer?: { durationS?: number };
        setSku?: {
            applyCountryCode?: boolean;
            countryCode?: string;
            sku?: string;
        };
        setTrustedKeys?: {
            keys?: { capabilities?: Capability[]; key?: string }[];
        };
        signedRequest?: {
            data?: Uint8Array<ArrayBufferLike>;
            signature?: Uint8Array<ArrayBufferLike>;
        };
        speedTest?: {};
        startSpeedtest?: { durationS?: number; sendTelemetry?: boolean };
        targetId?: string;
        tcpConnectivityTest?: { port?: number; target?: string };
        time?: {};
        transceiverGetStatus?: {};
        transceiverGetTelemetry?: {};
        transceiverIfLoopbackTest?: { enableIfLoopback?: boolean };
        udpConnectivityTest?: {
            port?: number;
            probeData?: UdpConnectivityTestRequest_UDPProbeDataType;
            target?: string;
        };
        update?: {};
        wifiBackhaulStats?: {};
        wifiGetClientHistory?: { clientId?: number; macAddress?: string };
        wifiGetClients?: {};
        wifiGetConfig?: {};
        wifiGetDiagnostics?: {};
        wifiGetFirewall?: {};
        wifiGetPingMetrics?: {};
        wifiGuestInfo?: {};
        wifiRunSelfTest?: {};
        wifiSelfTest?: {};
        wifiSetClientGivenName?: {
            clientConfig?: {
                clientId?: number;
                givenName?: string;
                groupId?: string;
                macAddress?: string;
                weeklyBlockSchedules?: {
                    blockRanges?: { endMinutes?: ...; startMinutes?: ... }[];
                    groupId?: string;
                }[];
            };
            clientName?: { givenName?: string; macAddress?: string };
        };
        wifiSetConfig?: {
            wifiConfig?: {
                applyMacLan?: boolean;
                applyMacLan2ghz?: boolean;
                applyMacLan5ghz?: boolean;
                applyMacWan?: boolean;
                applyNetworkName?: boolean;
                applyNetworkName5ghz?: boolean;
                applyNetworkPassword?: boolean;
                applySetupComplete?: boolean;
                applyWifiDisabled?: boolean;
                applyWifiSecurity?: boolean;
                countryCode?: string;
                deviceId?: string;
                factoryResetTicker?: number;
                lanIpv4?: string;
                lanIpv4SubnetMask?: string;
                macLan?: string;
                macLan2ghz?: string;
                macLan5ghz?: string;
                macWan?: string;
                networkName?: string;
                networkName5ghz?: string;
                networkPassword?: string;
                setupComplete?: boolean;
                version?: number;
                wifiDisabled?: boolean;
                wifiSecurity?: WifiConfig_Security;
            };
        };
        wifiSetMeshConfig?: {
            deviceId?: string;
            meshConfig?: {
                applyAuth?: boolean;
                applyDisplayName?: boolean;
                auth?: MeshAuth;
                displayName?: string;
                hardwareVersion?: string;
                incarnation?: number;
                lastConnected?: number;
                supports5ghzHigh?: boolean;
            };
        };
        wifiSetup?: {
            networkName?: string;
            networkPassword?: string;
            skip?: boolean;
        };
    },
    field: K,
    noun: string,
): Promise<NonNullable<Response[K]>>
Sends request and returns response[field], throwing if the named response variant is absent. noun is interpolated into the error message
Type Parameters
- K extends keyof Response
Parameters
- request: {
      authenticate?: {
          challenge?: {
              data?: Uint8Array<ArrayBufferLike>;
              signature?: Uint8Array<ArrayBufferLike>;
          };
      };
      dishActivateRssiScan?: { scanQuery?: { channel?: number } };
      dishClearObstructionMap?: {};
      dishEmc?: {
          chanOverride?: boolean;
          desiredTiltAngle?: number;
          fastSwitching?: boolean;
          forceEirpFailure?: boolean;
          forcePllUnlock?: boolean;
          idle?: boolean;
          manualTilting?: boolean;
          modulation?: number;
          phi?: number;
          phiEnabled?: boolean;
          reboot?: boolean;
          rxChan?: number;
          skySearch?: boolean;
          snowActiveOverride?: boolean;
          theta?: number;
          thetaEnabled?: boolean;
          tiltToStowed?: boolean;
          txChan?: number;
      };
      dishFactoryReset?: { appReset?: boolean };
      dishGetConfig?: {};
      dishGetContext?: {};
      dishGetEmc?: {};
      dishGetObstructionMap?: {};
      dishGetRssiScanResult?: {};
      dishInhibitGps?: { inhibitGps?: boolean };
      dishInhibitRf?: { inhibitRf?: boolean };
      dishPowerSave?: {
          enablePowerSave?: boolean;
          powerSaveDurationMinutes?: number;
          powerSaveStartMinutes?: number;
      };
      dishSetConfig?: {
          dishConfig?: {
              applyAssetClass?: boolean;
              applyLevelDishMode?: boolean;
              applyLocationRequestMode?: boolean;
              applyPowerSaveDurationMinutes?: boolean;
              applyPowerSaveMode?: boolean;
              applyPowerSaveStartMinutes?: boolean;
              applySnowMeltMode?: boolean;
              applySwupdateRebootHour?: boolean;
              applySwupdateThreeDayDeferralEnabled?: boolean;
              assetClass?: number;
              levelDishMode?: DishConfig_LevelDishMode;
              locationRequestMode?: DishConfig_LocationRequestMode;
              powerSaveDurationMinutes?: number;
              powerSaveMode?: boolean;
              powerSaveStartMinutes?: number;
              snowMeltMode?: DishConfig_SnowMeltMode;
              swupdateRebootHour?: number;
              swupdateThreeDayDeferralEnabled?: boolean;
          };
      };
      dishStow?: { unstow?: boolean };
      enableFlow?: { durationH?: number; name?: string };
      epochId?: number;
      factoryReset?: {};
      fuse?: {};
      getConnections?: {};
      getDeviceInfo?: {};
      getDiagnostics?: {};
      getGnssMeasurement?: {};
      getHeapDump?: {};
      getHistory?: {};
      getLocation?: { source?: PositionSource };
      getLog?: {};
      getNetworkInterfaces?: {};
      getNextId?: {};
      getPing?: {};
      getRadioStats?: {};
      getSpeedtestStatus?: {};
      getStatus?: { routerRole?: RouterRole };
      id?: number;
      pingHost?: { address?: string; size?: number };
      reboot?: {};
      reportClientSpeedtest?: {
          appBuild?: number;
          appVersion?: string;
          clientPlatform?: {
              majorVersion?: number;
              minorVersion?: number;
              platform?: ClientPlatform_Platform;
          };
          clientRssi?: number;
          clientSpeedtest?: {
              downloadBytesProcessed?: number;
              downloadMbps?: number;
              downloadStartTime?: number;
              durationS?: number;
              latencyMs?: number;
              startTime?: number;
              tcpStreams?: number;
              uploadBytesProcessed?: number;
              uploadMbps?: number;
              uploadStartTime?: number;
          };
          id?: number;
          wifiSpeedtest?: {
              downloadBytesProcessed?: number;
              downloadMbps?: number;
              downloadStartTime?: number;
              durationS?: number;
              latencyMs?: number;
              startTime?: number;
              tcpStreams?: number;
              uploadBytesProcessed?: number;
              uploadMbps?: number;
              uploadStartTime?: number;
          };
      };
      resetButton?: { pressed?: boolean };
      restartControl?: {};
      runIperfServer?: { durationS?: number };
      setSku?: { applyCountryCode?: boolean; countryCode?: string; sku?: string };
      setTrustedKeys?: { keys?: { capabilities?: Capability[]; key?: string }[] };
      signedRequest?: {
          data?: Uint8Array<ArrayBufferLike>;
          signature?: Uint8Array<ArrayBufferLike>;
      };
      speedTest?: {};
      startSpeedtest?: { durationS?: number; sendTelemetry?: boolean };
      targetId?: string;
      tcpConnectivityTest?: { port?: number; target?: string };
      time?: {};
      transceiverGetStatus?: {};
      transceiverGetTelemetry?: {};
      transceiverIfLoopbackTest?: { enableIfLoopback?: boolean };
      udpConnectivityTest?: {
          port?: number;
          probeData?: UdpConnectivityTestRequest_UDPProbeDataType;
          target?: string;
      };
      update?: {};
      wifiBackhaulStats?: {};
      wifiGetClientHistory?: { clientId?: number; macAddress?: string };
      wifiGetClients?: {};
      wifiGetConfig?: {};
      wifiGetDiagnostics?: {};
      wifiGetFirewall?: {};
      wifiGetPingMetrics?: {};
      wifiGuestInfo?: {};
      wifiRunSelfTest?: {};
      wifiSelfTest?: {};
      wifiSetClientGivenName?: {
          clientConfig?: {
              clientId?: number;
              givenName?: string;
              groupId?: string;
              macAddress?: string;
              weeklyBlockSchedules?: {
                  blockRanges?: { endMinutes?: ...; startMinutes?: ... }[];
                  groupId?: string;
              }[];
          };
          clientName?: { givenName?: string; macAddress?: string };
      };
      wifiSetConfig?: {
          wifiConfig?: {
              applyMacLan?: boolean;
              applyMacLan2ghz?: boolean;
              applyMacLan5ghz?: boolean;
              applyMacWan?: boolean;
              applyNetworkName?: boolean;
              applyNetworkName5ghz?: boolean;
              applyNetworkPassword?: boolean;
              applySetupComplete?: boolean;
              applyWifiDisabled?: boolean;
              applyWifiSecurity?: boolean;
              countryCode?: string;
              deviceId?: string;
              factoryResetTicker?: number;
              lanIpv4?: string;
              lanIpv4SubnetMask?: string;
              macLan?: string;
              macLan2ghz?: string;
              macLan5ghz?: string;
              macWan?: string;
              networkName?: string;
              networkName5ghz?: string;
              networkPassword?: string;
              setupComplete?: boolean;
              version?: number;
              wifiDisabled?: boolean;
              wifiSecurity?: WifiConfig_Security;
          };
      };
      wifiSetMeshConfig?: {
          deviceId?: string;
          meshConfig?: {
              applyAuth?: boolean;
              applyDisplayName?: boolean;
              auth?: MeshAuth;
              displayName?: string;
              hardwareVersion?: string;
              incarnation?: number;
              lastConnected?: number;
              supports5ghzHigh?: boolean;
          };
      };
      wifiSetup?: {
          networkName?: string;
          networkPassword?: string;
          skip?: boolean;
      };
  }
- field: K
- noun: string
Returns Promise<NonNullable<Response[K]>>
Inherited from GRPCApi.fetch_or_throw

fetch_ping

fetch_ping(): Promise<GetPingResponse>
Fetches accumulated ping results recorded by the dish

Returns Promise<GetPingResponse>

fetch_radio_stats

fetch_radio_stats(): Promise<GetRadioStatsResponse>
Fetches radio statistics

Returns Promise<GetRadioStatsResponse>

fetch_rssi_scan_result

fetch_rssi_scan_result(): Promise<DishGetRssiScanResultResponse>
Fetches the most recently completed RSSI scan result

Returns Promise<DishGetRssiScanResultResponse>

fetch_speedtest_status

fetch_speedtest_status(): Promise<SpeedtestStatus>
Fetches status of the most recently started async speedtest

Returns Promise<SpeedtestStatus>

fetch_status

fetch_status(): Promise<DishGetStatusResponse>
Fetches status information from a dishy

Returns Promise<DishGetStatusResponse>

fetch_time

fetch_time(): Promise<GetTimeResponse>
Fetches the dish's view of wall-clock time (nanoseconds since the Unix epoch)

Returns Promise<GetTimeResponse>

fetch_transceiver_status

fetch_transceiver_status(): Promise<TransceiverGetStatusResponse>
Fetches transceiver-level status (modulator/demodulator state, tx/rx state, faults, transmit-blanking state, modem and IF temperatures)

Returns Promise<TransceiverGetStatusResponse>

fetch_transceiver_telemetry

fetch_transceiver_telemetry(): Promise<TransceiverGetTelemetryResponse>
Fetches transceiver-level telemetry (antenna pointing, beam parameters, cell/slot/satellite state, SNR samples)

Returns Promise<TransceiverGetTelemetryResponse>

`Protected`handle

handle(
    request: {
        authenticate?: {
            challenge?: {
                data?: Uint8Array<ArrayBufferLike>;
                signature?: Uint8Array<ArrayBufferLike>;
            };
        };
        dishActivateRssiScan?: { scanQuery?: { channel?: number } };
        dishClearObstructionMap?: {};
        dishEmc?: {
            chanOverride?: boolean;
            desiredTiltAngle?: number;
            fastSwitching?: boolean;
            forceEirpFailure?: boolean;
            forcePllUnlock?: boolean;
            idle?: boolean;
            manualTilting?: boolean;
            modulation?: number;
            phi?: number;
            phiEnabled?: boolean;
            reboot?: boolean;
            rxChan?: number;
            skySearch?: boolean;
            snowActiveOverride?: boolean;
            theta?: number;
            thetaEnabled?: boolean;
            tiltToStowed?: boolean;
            txChan?: number;
        };
        dishFactoryReset?: { appReset?: boolean };
        dishGetConfig?: {};
        dishGetContext?: {};
        dishGetEmc?: {};
        dishGetObstructionMap?: {};
        dishGetRssiScanResult?: {};
        dishInhibitGps?: { inhibitGps?: boolean };
        dishInhibitRf?: { inhibitRf?: boolean };
        dishPowerSave?: {
            enablePowerSave?: boolean;
            powerSaveDurationMinutes?: number;
            powerSaveStartMinutes?: number;
        };
        dishSetConfig?: {
            dishConfig?: {
                applyAssetClass?: boolean;
                applyLevelDishMode?: boolean;
                applyLocationRequestMode?: boolean;
                applyPowerSaveDurationMinutes?: boolean;
                applyPowerSaveMode?: boolean;
                applyPowerSaveStartMinutes?: boolean;
                applySnowMeltMode?: boolean;
                applySwupdateRebootHour?: boolean;
                applySwupdateThreeDayDeferralEnabled?: boolean;
                assetClass?: number;
                levelDishMode?: DishConfig_LevelDishMode;
                locationRequestMode?: DishConfig_LocationRequestMode;
                powerSaveDurationMinutes?: number;
                powerSaveMode?: boolean;
                powerSaveStartMinutes?: number;
                snowMeltMode?: DishConfig_SnowMeltMode;
                swupdateRebootHour?: number;
                swupdateThreeDayDeferralEnabled?: boolean;
            };
        };
        dishStow?: { unstow?: boolean };
        enableFlow?: { durationH?: number; name?: string };
        epochId?: number;
        factoryReset?: {};
        fuse?: {};
        getConnections?: {};
        getDeviceInfo?: {};
        getDiagnostics?: {};
        getGnssMeasurement?: {};
        getHeapDump?: {};
        getHistory?: {};
        getLocation?: { source?: PositionSource };
        getLog?: {};
        getNetworkInterfaces?: {};
        getNextId?: {};
        getPing?: {};
        getRadioStats?: {};
        getSpeedtestStatus?: {};
        getStatus?: { routerRole?: RouterRole };
        id?: number;
        pingHost?: { address?: string; size?: number };
        reboot?: {};
        reportClientSpeedtest?: {
            appBuild?: number;
            appVersion?: string;
            clientPlatform?: {
                majorVersion?: number;
                minorVersion?: number;
                platform?: ClientPlatform_Platform;
            };
            clientRssi?: number;
            clientSpeedtest?: {
                downloadBytesProcessed?: number;
                downloadMbps?: number;
                downloadStartTime?: number;
                durationS?: number;
                latencyMs?: number;
                startTime?: number;
                tcpStreams?: number;
                uploadBytesProcessed?: number;
                uploadMbps?: number;
                uploadStartTime?: number;
            };
            id?: number;
            wifiSpeedtest?: {
                downloadBytesProcessed?: number;
                downloadMbps?: number;
                downloadStartTime?: number;
                durationS?: number;
                latencyMs?: number;
                startTime?: number;
                tcpStreams?: number;
                uploadBytesProcessed?: number;
                uploadMbps?: number;
                uploadStartTime?: number;
            };
        };
        resetButton?: { pressed?: boolean };
        restartControl?: {};
        runIperfServer?: { durationS?: number };
        setSku?: {
            applyCountryCode?: boolean;
            countryCode?: string;
            sku?: string;
        };
        setTrustedKeys?: {
            keys?: { capabilities?: Capability[]; key?: string }[];
        };
        signedRequest?: {
            data?: Uint8Array<ArrayBufferLike>;
            signature?: Uint8Array<ArrayBufferLike>;
        };
        speedTest?: {};
        startSpeedtest?: { durationS?: number; sendTelemetry?: boolean };
        targetId?: string;
        tcpConnectivityTest?: { port?: number; target?: string };
        time?: {};
        transceiverGetStatus?: {};
        transceiverGetTelemetry?: {};
        transceiverIfLoopbackTest?: { enableIfLoopback?: boolean };
        udpConnectivityTest?: {
            port?: number;
            probeData?: UdpConnectivityTestRequest_UDPProbeDataType;
            target?: string;
        };
        update?: {};
        wifiBackhaulStats?: {};
        wifiGetClientHistory?: { clientId?: number; macAddress?: string };
        wifiGetClients?: {};
        wifiGetConfig?: {};
        wifiGetDiagnostics?: {};
        wifiGetFirewall?: {};
        wifiGetPingMetrics?: {};
        wifiGuestInfo?: {};
        wifiRunSelfTest?: {};
        wifiSelfTest?: {};
        wifiSetClientGivenName?: {
            clientConfig?: {
                clientId?: number;
                givenName?: string;
                groupId?: string;
                macAddress?: string;
                weeklyBlockSchedules?: {
                    blockRanges?: { endMinutes?: ...; startMinutes?: ... }[];
                    groupId?: string;
                }[];
            };
            clientName?: { givenName?: string; macAddress?: string };
        };
        wifiSetConfig?: {
            wifiConfig?: {
                applyMacLan?: boolean;
                applyMacLan2ghz?: boolean;
                applyMacLan5ghz?: boolean;
                applyMacWan?: boolean;
                applyNetworkName?: boolean;
                applyNetworkName5ghz?: boolean;
                applyNetworkPassword?: boolean;
                applySetupComplete?: boolean;
                applyWifiDisabled?: boolean;
                applyWifiSecurity?: boolean;
                countryCode?: string;
                deviceId?: string;
                factoryResetTicker?: number;
                lanIpv4?: string;
                lanIpv4SubnetMask?: string;
                macLan?: string;
                macLan2ghz?: string;
                macLan5ghz?: string;
                macWan?: string;
                networkName?: string;
                networkName5ghz?: string;
                networkPassword?: string;
                setupComplete?: boolean;
                version?: number;
                wifiDisabled?: boolean;
                wifiSecurity?: WifiConfig_Security;
            };
        };
        wifiSetMeshConfig?: {
            deviceId?: string;
            meshConfig?: {
                applyAuth?: boolean;
                applyDisplayName?: boolean;
                auth?: MeshAuth;
                displayName?: string;
                hardwareVersion?: string;
                incarnation?: number;
                lastConnected?: number;
                supports5ghzHigh?: boolean;
            };
        };
        wifiSetup?: {
            networkName?: string;
            networkPassword?: string;
            skip?: boolean;
        };
    },
    timeout?: number | undefined,
): Promise<Response>
Protected
Performs a handle request against the GRPC server
Parameters
- request: {
      authenticate?: {
          challenge?: {
              data?: Uint8Array<ArrayBufferLike>;
              signature?: Uint8Array<ArrayBufferLike>;
          };
      };
      dishActivateRssiScan?: { scanQuery?: { channel?: number } };
      dishClearObstructionMap?: {};
      dishEmc?: {
          chanOverride?: boolean;
          desiredTiltAngle?: number;
          fastSwitching?: boolean;
          forceEirpFailure?: boolean;
          forcePllUnlock?: boolean;
          idle?: boolean;
          manualTilting?: boolean;
          modulation?: number;
          phi?: number;
          phiEnabled?: boolean;
          reboot?: boolean;
          rxChan?: number;
          skySearch?: boolean;
          snowActiveOverride?: boolean;
          theta?: number;
          thetaEnabled?: boolean;
          tiltToStowed?: boolean;
          txChan?: number;
      };
      dishFactoryReset?: { appReset?: boolean };
      dishGetConfig?: {};
      dishGetContext?: {};
      dishGetEmc?: {};
      dishGetObstructionMap?: {};
      dishGetRssiScanResult?: {};
      dishInhibitGps?: { inhibitGps?: boolean };
      dishInhibitRf?: { inhibitRf?: boolean };
      dishPowerSave?: {
          enablePowerSave?: boolean;
          powerSaveDurationMinutes?: number;
          powerSaveStartMinutes?: number;
      };
      dishSetConfig?: {
          dishConfig?: {
              applyAssetClass?: boolean;
              applyLevelDishMode?: boolean;
              applyLocationRequestMode?: boolean;
              applyPowerSaveDurationMinutes?: boolean;
              applyPowerSaveMode?: boolean;
              applyPowerSaveStartMinutes?: boolean;
              applySnowMeltMode?: boolean;
              applySwupdateRebootHour?: boolean;
              applySwupdateThreeDayDeferralEnabled?: boolean;
              assetClass?: number;
              levelDishMode?: DishConfig_LevelDishMode;
              locationRequestMode?: DishConfig_LocationRequestMode;
              powerSaveDurationMinutes?: number;
              powerSaveMode?: boolean;
              powerSaveStartMinutes?: number;
              snowMeltMode?: DishConfig_SnowMeltMode;
              swupdateRebootHour?: number;
              swupdateThreeDayDeferralEnabled?: boolean;
          };
      };
      dishStow?: { unstow?: boolean };
      enableFlow?: { durationH?: number; name?: string };
      epochId?: number;
      factoryReset?: {};
      fuse?: {};
      getConnections?: {};
      getDeviceInfo?: {};
      getDiagnostics?: {};
      getGnssMeasurement?: {};
      getHeapDump?: {};
      getHistory?: {};
      getLocation?: { source?: PositionSource };
      getLog?: {};
      getNetworkInterfaces?: {};
      getNextId?: {};
      getPing?: {};
      getRadioStats?: {};
      getSpeedtestStatus?: {};
      getStatus?: { routerRole?: RouterRole };
      id?: number;
      pingHost?: { address?: string; size?: number };
      reboot?: {};
      reportClientSpeedtest?: {
          appBuild?: number;
          appVersion?: string;
          clientPlatform?: {
              majorVersion?: number;
              minorVersion?: number;
              platform?: ClientPlatform_Platform;
          };
          clientRssi?: number;
          clientSpeedtest?: {
              downloadBytesProcessed?: number;
              downloadMbps?: number;
              downloadStartTime?: number;
              durationS?: number;
              latencyMs?: number;
              startTime?: number;
              tcpStreams?: number;
              uploadBytesProcessed?: number;
              uploadMbps?: number;
              uploadStartTime?: number;
          };
          id?: number;
          wifiSpeedtest?: {
              downloadBytesProcessed?: number;
              downloadMbps?: number;
              downloadStartTime?: number;
              durationS?: number;
              latencyMs?: number;
              startTime?: number;
              tcpStreams?: number;
              uploadBytesProcessed?: number;
              uploadMbps?: number;
              uploadStartTime?: number;
          };
      };
      resetButton?: { pressed?: boolean };
      restartControl?: {};
      runIperfServer?: { durationS?: number };
      setSku?: { applyCountryCode?: boolean; countryCode?: string; sku?: string };
      setTrustedKeys?: { keys?: { capabilities?: Capability[]; key?: string }[] };
      signedRequest?: {
          data?: Uint8Array<ArrayBufferLike>;
          signature?: Uint8Array<ArrayBufferLike>;
      };
      speedTest?: {};
      startSpeedtest?: { durationS?: number; sendTelemetry?: boolean };
      targetId?: string;
      tcpConnectivityTest?: { port?: number; target?: string };
      time?: {};
      transceiverGetStatus?: {};
      transceiverGetTelemetry?: {};
      transceiverIfLoopbackTest?: { enableIfLoopback?: boolean };
      udpConnectivityTest?: {
          port?: number;
          probeData?: UdpConnectivityTestRequest_UDPProbeDataType;
          target?: string;
      };
      update?: {};
      wifiBackhaulStats?: {};
      wifiGetClientHistory?: { clientId?: number; macAddress?: string };
      wifiGetClients?: {};
      wifiGetConfig?: {};
      wifiGetDiagnostics?: {};
      wifiGetFirewall?: {};
      wifiGetPingMetrics?: {};
      wifiGuestInfo?: {};
      wifiRunSelfTest?: {};
      wifiSelfTest?: {};
      wifiSetClientGivenName?: {
          clientConfig?: {
              clientId?: number;
              givenName?: string;
              groupId?: string;
              macAddress?: string;
              weeklyBlockSchedules?: {
                  blockRanges?: { endMinutes?: ...; startMinutes?: ... }[];
                  groupId?: string;
              }[];
          };
          clientName?: { givenName?: string; macAddress?: string };
      };
      wifiSetConfig?: {
          wifiConfig?: {
              applyMacLan?: boolean;
              applyMacLan2ghz?: boolean;
              applyMacLan5ghz?: boolean;
              applyMacWan?: boolean;
              applyNetworkName?: boolean;
              applyNetworkName5ghz?: boolean;
              applyNetworkPassword?: boolean;
              applySetupComplete?: boolean;
              applyWifiDisabled?: boolean;
              applyWifiSecurity?: boolean;
              countryCode?: string;
              deviceId?: string;
              factoryResetTicker?: number;
              lanIpv4?: string;
              lanIpv4SubnetMask?: string;
              macLan?: string;
              macLan2ghz?: string;
              macLan5ghz?: string;
              macWan?: string;
              networkName?: string;
              networkName5ghz?: string;
              networkPassword?: string;
              setupComplete?: boolean;
              version?: number;
              wifiDisabled?: boolean;
              wifiSecurity?: WifiConfig_Security;
          };
      };
      wifiSetMeshConfig?: {
          deviceId?: string;
          meshConfig?: {
              applyAuth?: boolean;
              applyDisplayName?: boolean;
              auth?: MeshAuth;
              displayName?: string;
              hardwareVersion?: string;
              incarnation?: number;
              lastConnected?: number;
              supports5ghzHigh?: boolean;
          };
      };
      wifiSetup?: {
          networkName?: string;
          networkPassword?: string;
          skip?: boolean;
      };
  }
- timeout: number | undefined = ...
Returns Promise<Response>
Inherited from GRPCApi.handle

inhibit_gps

inhibit_gps(inhibit: boolean): Promise<boolean>
Inhibits GPS reception on the dish (or releases the inhibit when false)
Parameters
- inhibit: boolean
Returns Promise<boolean>

inhibit_rf

inhibit_rf(inhibit: boolean): Promise<boolean>
Inhibits RF transmission on the dish (or releases the inhibit when false)
Parameters
- inhibit: boolean
Returns Promise<boolean>

ping_host

ping_host(address: string, size?: number): Promise<PingHostResponse>
Issues a ping from the dish to the supplied host
Parameters
- address: string
  target host (IP or DNS name)
- Optionalsize: number
  optional payload size in bytes
Returns Promise<PingHostResponse>

power_save

power_save(
    start_minutes: number,
    duration_minutes: number,
    enable?: boolean,
): Promise<boolean>
Configures dish power-save schedule
Parameters
- start_minutes: number
- duration_minutes: number
- enable: boolean = true
Returns Promise<boolean>

press_reset_button

press_reset_button(pressed: boolean): Promise<boolean>
Triggers the dish's hardware reset button via the API
Parameters
- pressed: boolean
Returns Promise<boolean>

reboot

reboot(): Promise<boolean>
Issues a reboot request to a dishy

Returns Promise<boolean>

report_client_speedtest

report_client_speedtest(
    id: number,
    client_speedtest?: SpeedTestStats,
    wifi_speedtest?: SpeedTestStats,
    client_rssi?: number,
): Promise<boolean>
Reports a client-measured speedtest back to the dish
Parameters
- id: number
- Optionalclient_speedtest: SpeedTestStats
- Optionalwifi_speedtest: SpeedTestStats
- client_rssi: number = 0
Returns Promise<boolean>

restart_control

restart_control(): Promise<boolean>
Restarts the dish control plane without rebooting the dish

Returns Promise<boolean>

run_iperf_server

run_iperf_server(duration_s: number): Promise<RunIperfServerResponse>
Starts a short-lived iperf3 server on the dish
Parameters
- duration_s: number
  how long the server should listen for connections
Returns Promise<RunIperfServerResponse>

run_transceiver_if_loopback_test

run_transceiver_if_loopback_test(
enable: boolean,
): Promise<TransceiverIFLoopbackTestResponse>
Runs an IF-loopback test on the transceiver and returns BER, SNR, RSSI, and PLL-lock measurements. Destructive: alters the IF path while running.
Parameters
- enable: boolean
  whether the loopback path should be enabled during the test
Returns Promise<TransceiverIFLoopbackTestResponse>

set_config

set_config(config: DishConfig): Promise<boolean>
Pushes a new dish configuration
Parameters
- config: DishConfig
Returns Promise<boolean>

speed_test

speed_test(): Promise<SpeedTestResponse>
Performs a synchronous speedtest from the dish

Returns Promise<SpeedTestResponse>

start_speedtest

start_speedtest(duration_s: number, send_telemetry?: boolean): Promise<boolean>
Starts an asynchronous speedtest. Use fetch_speedtest_status to poll for results.
Parameters
- duration_s: number
- send_telemetry: boolean = false
Returns Promise<boolean>

stow

stow(): Promise<boolean>
Issues a stow request to a dishy

Note: The dishy must support stow/unstow operations

Returns Promise<boolean>

tcp_connectivity_test

tcp_connectivity_test(target: string, port: number): Promise<boolean>
Probes TCP connectivity to a host:port from the dish
Parameters
- target: string
- port: number
Returns Promise<boolean>

`Protected`try_handle

try_handle(
    request: {
        authenticate?: {
            challenge?: {
                data?: Uint8Array<ArrayBufferLike>;
                signature?: Uint8Array<ArrayBufferLike>;
            };
        };
        dishActivateRssiScan?: { scanQuery?: { channel?: number } };
        dishClearObstructionMap?: {};
        dishEmc?: {
            chanOverride?: boolean;
            desiredTiltAngle?: number;
            fastSwitching?: boolean;
            forceEirpFailure?: boolean;
            forcePllUnlock?: boolean;
            idle?: boolean;
            manualTilting?: boolean;
            modulation?: number;
            phi?: number;
            phiEnabled?: boolean;
            reboot?: boolean;
            rxChan?: number;
            skySearch?: boolean;
            snowActiveOverride?: boolean;
            theta?: number;
            thetaEnabled?: boolean;
            tiltToStowed?: boolean;
            txChan?: number;
        };
        dishFactoryReset?: { appReset?: boolean };
        dishGetConfig?: {};
        dishGetContext?: {};
        dishGetEmc?: {};
        dishGetObstructionMap?: {};
        dishGetRssiScanResult?: {};
        dishInhibitGps?: { inhibitGps?: boolean };
        dishInhibitRf?: { inhibitRf?: boolean };
        dishPowerSave?: {
            enablePowerSave?: boolean;
            powerSaveDurationMinutes?: number;
            powerSaveStartMinutes?: number;
        };
        dishSetConfig?: {
            dishConfig?: {
                applyAssetClass?: boolean;
                applyLevelDishMode?: boolean;
                applyLocationRequestMode?: boolean;
                applyPowerSaveDurationMinutes?: boolean;
                applyPowerSaveMode?: boolean;
                applyPowerSaveStartMinutes?: boolean;
                applySnowMeltMode?: boolean;
                applySwupdateRebootHour?: boolean;
                applySwupdateThreeDayDeferralEnabled?: boolean;
                assetClass?: number;
                levelDishMode?: DishConfig_LevelDishMode;
                locationRequestMode?: DishConfig_LocationRequestMode;
                powerSaveDurationMinutes?: number;
                powerSaveMode?: boolean;
                powerSaveStartMinutes?: number;
                snowMeltMode?: DishConfig_SnowMeltMode;
                swupdateRebootHour?: number;
                swupdateThreeDayDeferralEnabled?: boolean;
            };
        };
        dishStow?: { unstow?: boolean };
        enableFlow?: { durationH?: number; name?: string };
        epochId?: number;
        factoryReset?: {};
        fuse?: {};
        getConnections?: {};
        getDeviceInfo?: {};
        getDiagnostics?: {};
        getGnssMeasurement?: {};
        getHeapDump?: {};
        getHistory?: {};
        getLocation?: { source?: PositionSource };
        getLog?: {};
        getNetworkInterfaces?: {};
        getNextId?: {};
        getPing?: {};
        getRadioStats?: {};
        getSpeedtestStatus?: {};
        getStatus?: { routerRole?: RouterRole };
        id?: number;
        pingHost?: { address?: string; size?: number };
        reboot?: {};
        reportClientSpeedtest?: {
            appBuild?: number;
            appVersion?: string;
            clientPlatform?: {
                majorVersion?: number;
                minorVersion?: number;
                platform?: ClientPlatform_Platform;
            };
            clientRssi?: number;
            clientSpeedtest?: {
                downloadBytesProcessed?: number;
                downloadMbps?: number;
                downloadStartTime?: number;
                durationS?: number;
                latencyMs?: number;
                startTime?: number;
                tcpStreams?: number;
                uploadBytesProcessed?: number;
                uploadMbps?: number;
                uploadStartTime?: number;
            };
            id?: number;
            wifiSpeedtest?: {
                downloadBytesProcessed?: number;
                downloadMbps?: number;
                downloadStartTime?: number;
                durationS?: number;
                latencyMs?: number;
                startTime?: number;
                tcpStreams?: number;
                uploadBytesProcessed?: number;
                uploadMbps?: number;
                uploadStartTime?: number;
            };
        };
        resetButton?: { pressed?: boolean };
        restartControl?: {};
        runIperfServer?: { durationS?: number };
        setSku?: {
            applyCountryCode?: boolean;
            countryCode?: string;
            sku?: string;
        };
        setTrustedKeys?: {
            keys?: { capabilities?: Capability[]; key?: string }[];
        };
        signedRequest?: {
            data?: Uint8Array<ArrayBufferLike>;
            signature?: Uint8Array<ArrayBufferLike>;
        };
        speedTest?: {};
        startSpeedtest?: { durationS?: number; sendTelemetry?: boolean };
        targetId?: string;
        tcpConnectivityTest?: { port?: number; target?: string };
        time?: {};
        transceiverGetStatus?: {};
        transceiverGetTelemetry?: {};
        transceiverIfLoopbackTest?: { enableIfLoopback?: boolean };
        udpConnectivityTest?: {
            port?: number;
            probeData?: UdpConnectivityTestRequest_UDPProbeDataType;
            target?: string;
        };
        update?: {};
        wifiBackhaulStats?: {};
        wifiGetClientHistory?: { clientId?: number; macAddress?: string };
        wifiGetClients?: {};
        wifiGetConfig?: {};
        wifiGetDiagnostics?: {};
        wifiGetFirewall?: {};
        wifiGetPingMetrics?: {};
        wifiGuestInfo?: {};
        wifiRunSelfTest?: {};
        wifiSelfTest?: {};
        wifiSetClientGivenName?: {
            clientConfig?: {
                clientId?: number;
                givenName?: string;
                groupId?: string;
                macAddress?: string;
                weeklyBlockSchedules?: {
                    blockRanges?: { endMinutes?: ...; startMinutes?: ... }[];
                    groupId?: string;
                }[];
            };
            clientName?: { givenName?: string; macAddress?: string };
        };
        wifiSetConfig?: {
            wifiConfig?: {
                applyMacLan?: boolean;
                applyMacLan2ghz?: boolean;
                applyMacLan5ghz?: boolean;
                applyMacWan?: boolean;
                applyNetworkName?: boolean;
                applyNetworkName5ghz?: boolean;
                applyNetworkPassword?: boolean;
                applySetupComplete?: boolean;
                applyWifiDisabled?: boolean;
                applyWifiSecurity?: boolean;
                countryCode?: string;
                deviceId?: string;
                factoryResetTicker?: number;
                lanIpv4?: string;
                lanIpv4SubnetMask?: string;
                macLan?: string;
                macLan2ghz?: string;
                macLan5ghz?: string;
                macWan?: string;
                networkName?: string;
                networkName5ghz?: string;
                networkPassword?: string;
                setupComplete?: boolean;
                version?: number;
                wifiDisabled?: boolean;
                wifiSecurity?: WifiConfig_Security;
            };
        };
        wifiSetMeshConfig?: {
            deviceId?: string;
            meshConfig?: {
                applyAuth?: boolean;
                applyDisplayName?: boolean;
                auth?: MeshAuth;
                displayName?: string;
                hardwareVersion?: string;
                incarnation?: number;
                lastConnected?: number;
                supports5ghzHigh?: boolean;
            };
        };
        wifiSetup?: {
            networkName?: string;
            networkPassword?: string;
            skip?: boolean;
        };
    },
): Promise<boolean>
Sends request and returns true on success, false on any thrown error
Parameters
- request: {
      authenticate?: {
          challenge?: {
              data?: Uint8Array<ArrayBufferLike>;
              signature?: Uint8Array<ArrayBufferLike>;
          };
      };
      dishActivateRssiScan?: { scanQuery?: { channel?: number } };
      dishClearObstructionMap?: {};
      dishEmc?: {
          chanOverride?: boolean;
          desiredTiltAngle?: number;
          fastSwitching?: boolean;
          forceEirpFailure?: boolean;
          forcePllUnlock?: boolean;
          idle?: boolean;
          manualTilting?: boolean;
          modulation?: number;
          phi?: number;
          phiEnabled?: boolean;
          reboot?: boolean;
          rxChan?: number;
          skySearch?: boolean;
          snowActiveOverride?: boolean;
          theta?: number;
          thetaEnabled?: boolean;
          tiltToStowed?: boolean;
          txChan?: number;
      };
      dishFactoryReset?: { appReset?: boolean };
      dishGetConfig?: {};
      dishGetContext?: {};
      dishGetEmc?: {};
      dishGetObstructionMap?: {};
      dishGetRssiScanResult?: {};
      dishInhibitGps?: { inhibitGps?: boolean };
      dishInhibitRf?: { inhibitRf?: boolean };
      dishPowerSave?: {
          enablePowerSave?: boolean;
          powerSaveDurationMinutes?: number;
          powerSaveStartMinutes?: number;
      };
      dishSetConfig?: {
          dishConfig?: {
              applyAssetClass?: boolean;
              applyLevelDishMode?: boolean;
              applyLocationRequestMode?: boolean;
              applyPowerSaveDurationMinutes?: boolean;
              applyPowerSaveMode?: boolean;
              applyPowerSaveStartMinutes?: boolean;
              applySnowMeltMode?: boolean;
              applySwupdateRebootHour?: boolean;
              applySwupdateThreeDayDeferralEnabled?: boolean;
              assetClass?: number;
              levelDishMode?: DishConfig_LevelDishMode;
              locationRequestMode?: DishConfig_LocationRequestMode;
              powerSaveDurationMinutes?: number;
              powerSaveMode?: boolean;
              powerSaveStartMinutes?: number;
              snowMeltMode?: DishConfig_SnowMeltMode;
              swupdateRebootHour?: number;
              swupdateThreeDayDeferralEnabled?: boolean;
          };
      };
      dishStow?: { unstow?: boolean };
      enableFlow?: { durationH?: number; name?: string };
      epochId?: number;
      factoryReset?: {};
      fuse?: {};
      getConnections?: {};
      getDeviceInfo?: {};
      getDiagnostics?: {};
      getGnssMeasurement?: {};
      getHeapDump?: {};
      getHistory?: {};
      getLocation?: { source?: PositionSource };
      getLog?: {};
      getNetworkInterfaces?: {};
      getNextId?: {};
      getPing?: {};
      getRadioStats?: {};
      getSpeedtestStatus?: {};
      getStatus?: { routerRole?: RouterRole };
      id?: number;
      pingHost?: { address?: string; size?: number };
      reboot?: {};
      reportClientSpeedtest?: {
          appBuild?: number;
          appVersion?: string;
          clientPlatform?: {
              majorVersion?: number;
              minorVersion?: number;
              platform?: ClientPlatform_Platform;
          };
          clientRssi?: number;
          clientSpeedtest?: {
              downloadBytesProcessed?: number;
              downloadMbps?: number;
              downloadStartTime?: number;
              durationS?: number;
              latencyMs?: number;
              startTime?: number;
              tcpStreams?: number;
              uploadBytesProcessed?: number;
              uploadMbps?: number;
              uploadStartTime?: number;
          };
          id?: number;
          wifiSpeedtest?: {
              downloadBytesProcessed?: number;
              downloadMbps?: number;
              downloadStartTime?: number;
              durationS?: number;
              latencyMs?: number;
              startTime?: number;
              tcpStreams?: number;
              uploadBytesProcessed?: number;
              uploadMbps?: number;
              uploadStartTime?: number;
          };
      };
      resetButton?: { pressed?: boolean };
      restartControl?: {};
      runIperfServer?: { durationS?: number };
      setSku?: { applyCountryCode?: boolean; countryCode?: string; sku?: string };
      setTrustedKeys?: { keys?: { capabilities?: Capability[]; key?: string }[] };
      signedRequest?: {
          data?: Uint8Array<ArrayBufferLike>;
          signature?: Uint8Array<ArrayBufferLike>;
      };
      speedTest?: {};
      startSpeedtest?: { durationS?: number; sendTelemetry?: boolean };
      targetId?: string;
      tcpConnectivityTest?: { port?: number; target?: string };
      time?: {};
      transceiverGetStatus?: {};
      transceiverGetTelemetry?: {};
      transceiverIfLoopbackTest?: { enableIfLoopback?: boolean };
      udpConnectivityTest?: {
          port?: number;
          probeData?: UdpConnectivityTestRequest_UDPProbeDataType;
          target?: string;
      };
      update?: {};
      wifiBackhaulStats?: {};
      wifiGetClientHistory?: { clientId?: number; macAddress?: string };
      wifiGetClients?: {};
      wifiGetConfig?: {};
      wifiGetDiagnostics?: {};
      wifiGetFirewall?: {};
      wifiGetPingMetrics?: {};
      wifiGuestInfo?: {};
      wifiRunSelfTest?: {};
      wifiSelfTest?: {};
      wifiSetClientGivenName?: {
          clientConfig?: {
              clientId?: number;
              givenName?: string;
              groupId?: string;
              macAddress?: string;
              weeklyBlockSchedules?: {
                  blockRanges?: { endMinutes?: ...; startMinutes?: ... }[];
                  groupId?: string;
              }[];
          };
          clientName?: { givenName?: string; macAddress?: string };
      };
      wifiSetConfig?: {
          wifiConfig?: {
              applyMacLan?: boolean;
              applyMacLan2ghz?: boolean;
              applyMacLan5ghz?: boolean;
              applyMacWan?: boolean;
              applyNetworkName?: boolean;
              applyNetworkName5ghz?: boolean;
              applyNetworkPassword?: boolean;
              applySetupComplete?: boolean;
              applyWifiDisabled?: boolean;
              applyWifiSecurity?: boolean;
              countryCode?: string;
              deviceId?: string;
              factoryResetTicker?: number;
              lanIpv4?: string;
              lanIpv4SubnetMask?: string;
              macLan?: string;
              macLan2ghz?: string;
              macLan5ghz?: string;
              macWan?: string;
              networkName?: string;
              networkName5ghz?: string;
              networkPassword?: string;
              setupComplete?: boolean;
              version?: number;
              wifiDisabled?: boolean;
              wifiSecurity?: WifiConfig_Security;
          };
      };
      wifiSetMeshConfig?: {
          deviceId?: string;
          meshConfig?: {
              applyAuth?: boolean;
              applyDisplayName?: boolean;
              auth?: MeshAuth;
              displayName?: string;
              hardwareVersion?: string;
              incarnation?: number;
              lastConnected?: number;
              supports5ghzHigh?: boolean;
          };
      };
      wifiSetup?: {
          networkName?: string;
          networkPassword?: string;
          skip?: boolean;
      };
  }
Returns Promise<boolean>
Inherited from GRPCApi.try_handle

udp_connectivity_test

udp_connectivity_test(
    target: string,
    port: number,
    probe_data?: UdpConnectivityTestRequest_UDPProbeDataType,
): Promise<boolean>
Probes UDP connectivity to a host:port from the dish
Parameters
- target: string
- port: number
- probe_data: UdpConnectivityTestRequest_UDPProbeDataType = UdpConnectivityTestRequest_UDPProbeDataType.EMPTY
Returns Promise<boolean>

unstow

unstow(): Promise<boolean>
Issues an unstow request to a dishy

Note: The dishy must support stow/unstow operations

Returns Promise<boolean>

update

update(): Promise<boolean>
Schedules a firmware update on the dish

Returns Promise<boolean>

Class Dishy

Hierarchy (View Summary)

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Returns Dishy

Properties

Protectedclient

Readonlyhost

Readonlyport

Optional Readonlytimeout

Methods

activate_rssi_scan

Parameters

Returns Promise<boolean>

clear_obstruction_map

Returns Promise<boolean>

close

Returns void

factory_reset

Parameters

Returns Promise<boolean>

fetch_config

Returns Promise<DishGetConfigResponse>

fetch_connections

Returns Promise<GetConnectionsResponse>

fetch_context

Returns Promise<DishGetContextResponse>

fetch_device_info

Returns Promise<GetDeviceInfoResponse>

fetch_diagnostics

Returns Promise<StarlinkGRPC.Dishy.Diagnostics>

fetch_emc

Returns Promise<DishGetEmcResponse>

fetch_gnss_measurement

Returns Promise<GetGnssMeasurementResponse>

fetch_history

Returns Promise<DishGetHistoryResponse>

fetch_location

Parameters

Returns Promise<GetLocationResponse>

fetch_log

Returns Promise<GetLogResponse>

fetch_network_interfaces

Returns Promise<GetNetworkInterfacesResponse>

fetch_obstruction_map

Returns Promise<DishGetObstructionMapResponse>

Protectedfetch_or_throw

Type Parameters

Parameters

Returns Promise<NonNullable<Response[K]>>

fetch_ping

Returns Promise<GetPingResponse>

fetch_radio_stats

Returns Promise<GetRadioStatsResponse>

fetch_rssi_scan_result

Returns Promise<DishGetRssiScanResultResponse>

fetch_speedtest_status

Returns Promise<SpeedtestStatus>

fetch_status

Returns Promise<DishGetStatusResponse>

fetch_time

Returns Promise<GetTimeResponse>

fetch_transceiver_status

Returns Promise<TransceiverGetStatusResponse>

fetch_transceiver_telemetry

Returns Promise<TransceiverGetTelemetryResponse>

Protectedhandle

Parameters

Returns Promise<Response>

inhibit_gps

Parameters

Returns Promise<boolean>

inhibit_rf

Parameters

Returns Promise<boolean>

`Protected`client

`Readonly`host

`Readonly`port

`Optional` `Readonly`timeout

`Protected`fetch_or_throw

`Protected`handle

`Protected`try_handle