Class GRPCApiAbstract

Protectedconstructor

• new GRPCApi(options: Options & { host: string; port: number }): GRPCApi

  Parameters

  • options: Options & { host: string; port: number }

  Returns GRPCApi

Protectedclient

Protectedfetch_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]>>

Protectedhandle

• 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>

Protectedtry_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>