import * as jspb from 'google-protobuf'

import * as common_common_pb from '../common/common_pb';
import * as google_protobuf_timestamp_pb from 'google-protobuf/google/protobuf/timestamp_pb';
import * as google_protobuf_duration_pb from 'google-protobuf/google/protobuf/duration_pb';


export class Modulation extends jspb.Message {
  getLora(): LoRaModulationInfo | undefined;
  setLora(value?: LoRaModulationInfo): Modulation;
  hasLora(): boolean;
  clearLora(): Modulation;

  getFsk(): FSKModulationInfo | undefined;
  setFsk(value?: FSKModulationInfo): Modulation;
  hasFsk(): boolean;
  clearFsk(): Modulation;

  getLrFhss(): LRFHSSModulationInfo | undefined;
  setLrFhss(value?: LRFHSSModulationInfo): Modulation;
  hasLrFhss(): boolean;
  clearLrFhss(): Modulation;

  getParametersCase(): Modulation.ParametersCase;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Modulation.AsObject;
  static toObject(includeInstance: boolean, msg: Modulation): Modulation.AsObject;
  static serializeBinaryToWriter(message: Modulation, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Modulation;
  static deserializeBinaryFromReader(message: Modulation, reader: jspb.BinaryReader): Modulation;
}

export namespace Modulation {
  export type AsObject = {
    lora?: LoRaModulationInfo.AsObject,
    fsk?: FSKModulationInfo.AsObject,
    lrFhss?: LRFHSSModulationInfo.AsObject,
  }

  export enum ParametersCase { 
    PARAMETERS_NOT_SET = 0,
    LORA = 3,
    FSK = 4,
    LR_FHSS = 5,
  }
}

export class UplinkTXInfo extends jspb.Message {
  getFrequency(): number;
  setFrequency(value: number): UplinkTXInfo;

  getModulation(): common_common_pb.Modulation;
  setModulation(value: common_common_pb.Modulation): UplinkTXInfo;

  getLoraModulationInfo(): LoRaModulationInfo | undefined;
  setLoraModulationInfo(value?: LoRaModulationInfo): UplinkTXInfo;
  hasLoraModulationInfo(): boolean;
  clearLoraModulationInfo(): UplinkTXInfo;

  getFskModulationInfo(): FSKModulationInfo | undefined;
  setFskModulationInfo(value?: FSKModulationInfo): UplinkTXInfo;
  hasFskModulationInfo(): boolean;
  clearFskModulationInfo(): UplinkTXInfo;

  getLrFhssModulationInfo(): LRFHSSModulationInfo | undefined;
  setLrFhssModulationInfo(value?: LRFHSSModulationInfo): UplinkTXInfo;
  hasLrFhssModulationInfo(): boolean;
  clearLrFhssModulationInfo(): UplinkTXInfo;

  getModulationInfoCase(): UplinkTXInfo.ModulationInfoCase;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): UplinkTXInfo.AsObject;
  static toObject(includeInstance: boolean, msg: UplinkTXInfo): UplinkTXInfo.AsObject;
  static serializeBinaryToWriter(message: UplinkTXInfo, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): UplinkTXInfo;
  static deserializeBinaryFromReader(message: UplinkTXInfo, reader: jspb.BinaryReader): UplinkTXInfo;
}

export namespace UplinkTXInfo {
  export type AsObject = {
    frequency: number,
    modulation: common_common_pb.Modulation,
    loraModulationInfo?: LoRaModulationInfo.AsObject,
    fskModulationInfo?: FSKModulationInfo.AsObject,
    lrFhssModulationInfo?: LRFHSSModulationInfo.AsObject,
  }

  export enum ModulationInfoCase { 
    MODULATION_INFO_NOT_SET = 0,
    LORA_MODULATION_INFO = 3,
    FSK_MODULATION_INFO = 4,
    LR_FHSS_MODULATION_INFO = 5,
  }
}

export class LoRaModulationInfo extends jspb.Message {
  getBandwidth(): number;
  setBandwidth(value: number): LoRaModulationInfo;

  getSpreadingFactor(): number;
  setSpreadingFactor(value: number): LoRaModulationInfo;

  getCodeRate(): string;
  setCodeRate(value: string): LoRaModulationInfo;

  getPolarizationInversion(): boolean;
  setPolarizationInversion(value: boolean): LoRaModulationInfo;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): LoRaModulationInfo.AsObject;
  static toObject(includeInstance: boolean, msg: LoRaModulationInfo): LoRaModulationInfo.AsObject;
  static serializeBinaryToWriter(message: LoRaModulationInfo, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): LoRaModulationInfo;
  static deserializeBinaryFromReader(message: LoRaModulationInfo, reader: jspb.BinaryReader): LoRaModulationInfo;
}

export namespace LoRaModulationInfo {
  export type AsObject = {
    bandwidth: number,
    spreadingFactor: number,
    codeRate: string,
    polarizationInversion: boolean,
  }
}

export class FSKModulationInfo extends jspb.Message {
  getFrequencyDeviation(): number;
  setFrequencyDeviation(value: number): FSKModulationInfo;

  getDatarate(): number;
  setDatarate(value: number): FSKModulationInfo;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): FSKModulationInfo.AsObject;
  static toObject(includeInstance: boolean, msg: FSKModulationInfo): FSKModulationInfo.AsObject;
  static serializeBinaryToWriter(message: FSKModulationInfo, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): FSKModulationInfo;
  static deserializeBinaryFromReader(message: FSKModulationInfo, reader: jspb.BinaryReader): FSKModulationInfo;
}

export namespace FSKModulationInfo {
  export type AsObject = {
    frequencyDeviation: number,
    datarate: number,
  }
}

export class LRFHSSModulationInfo extends jspb.Message {
  getOperatingChannelWidth(): number;
  setOperatingChannelWidth(value: number): LRFHSSModulationInfo;

  getCodeRate(): string;
  setCodeRate(value: string): LRFHSSModulationInfo;

  getGridSteps(): number;
  setGridSteps(value: number): LRFHSSModulationInfo;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): LRFHSSModulationInfo.AsObject;
  static toObject(includeInstance: boolean, msg: LRFHSSModulationInfo): LRFHSSModulationInfo.AsObject;
  static serializeBinaryToWriter(message: LRFHSSModulationInfo, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): LRFHSSModulationInfo;
  static deserializeBinaryFromReader(message: LRFHSSModulationInfo, reader: jspb.BinaryReader): LRFHSSModulationInfo;
}

export namespace LRFHSSModulationInfo {
  export type AsObject = {
    operatingChannelWidth: number,
    codeRate: string,
    gridSteps: number,
  }
}

export class EncryptedFineTimestamp extends jspb.Message {
  getAesKeyIndex(): number;
  setAesKeyIndex(value: number): EncryptedFineTimestamp;

  getEncryptedNs(): Uint8Array | string;
  getEncryptedNs_asU8(): Uint8Array;
  getEncryptedNs_asB64(): string;
  setEncryptedNs(value: Uint8Array | string): EncryptedFineTimestamp;

  getFpgaId(): Uint8Array | string;
  getFpgaId_asU8(): Uint8Array;
  getFpgaId_asB64(): string;
  setFpgaId(value: Uint8Array | string): EncryptedFineTimestamp;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): EncryptedFineTimestamp.AsObject;
  static toObject(includeInstance: boolean, msg: EncryptedFineTimestamp): EncryptedFineTimestamp.AsObject;
  static serializeBinaryToWriter(message: EncryptedFineTimestamp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): EncryptedFineTimestamp;
  static deserializeBinaryFromReader(message: EncryptedFineTimestamp, reader: jspb.BinaryReader): EncryptedFineTimestamp;
}

export namespace EncryptedFineTimestamp {
  export type AsObject = {
    aesKeyIndex: number,
    encryptedNs: Uint8Array | string,
    fpgaId: Uint8Array | string,
  }
}

export class PlainFineTimestamp extends jspb.Message {
  getTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setTime(value?: google_protobuf_timestamp_pb.Timestamp): PlainFineTimestamp;
  hasTime(): boolean;
  clearTime(): PlainFineTimestamp;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): PlainFineTimestamp.AsObject;
  static toObject(includeInstance: boolean, msg: PlainFineTimestamp): PlainFineTimestamp.AsObject;
  static serializeBinaryToWriter(message: PlainFineTimestamp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): PlainFineTimestamp;
  static deserializeBinaryFromReader(message: PlainFineTimestamp, reader: jspb.BinaryReader): PlainFineTimestamp;
}

export namespace PlainFineTimestamp {
  export type AsObject = {
    time?: google_protobuf_timestamp_pb.Timestamp.AsObject,
  }
}

export class GatewayStats extends jspb.Message {
  getGatewayId(): Uint8Array | string;
  getGatewayId_asU8(): Uint8Array;
  getGatewayId_asB64(): string;
  setGatewayId(value: Uint8Array | string): GatewayStats;

  getIp(): string;
  setIp(value: string): GatewayStats;

  getTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setTime(value?: google_protobuf_timestamp_pb.Timestamp): GatewayStats;
  hasTime(): boolean;
  clearTime(): GatewayStats;

  getLocation(): common_common_pb.Location | undefined;
  setLocation(value?: common_common_pb.Location): GatewayStats;
  hasLocation(): boolean;
  clearLocation(): GatewayStats;

  getConfigVersion(): string;
  setConfigVersion(value: string): GatewayStats;

  getRxPacketsReceived(): number;
  setRxPacketsReceived(value: number): GatewayStats;

  getRxPacketsReceivedOk(): number;
  setRxPacketsReceivedOk(value: number): GatewayStats;

  getTxPacketsReceived(): number;
  setTxPacketsReceived(value: number): GatewayStats;

  getTxPacketsEmitted(): number;
  setTxPacketsEmitted(value: number): GatewayStats;

  getMetaDataMap(): jspb.Map<string, string>;
  clearMetaDataMap(): GatewayStats;

  getStatsId(): Uint8Array | string;
  getStatsId_asU8(): Uint8Array;
  getStatsId_asB64(): string;
  setStatsId(value: Uint8Array | string): GatewayStats;

  getTxPacketsPerFrequencyMap(): jspb.Map<number, number>;
  clearTxPacketsPerFrequencyMap(): GatewayStats;

  getRxPacketsPerFrequencyMap(): jspb.Map<number, number>;
  clearRxPacketsPerFrequencyMap(): GatewayStats;

  getTxPacketsPerModulationList(): Array<PerModulationCount>;
  setTxPacketsPerModulationList(value: Array<PerModulationCount>): GatewayStats;
  clearTxPacketsPerModulationList(): GatewayStats;
  addTxPacketsPerModulation(value?: PerModulationCount, index?: number): PerModulationCount;

  getRxPacketsPerModulationList(): Array<PerModulationCount>;
  setRxPacketsPerModulationList(value: Array<PerModulationCount>): GatewayStats;
  clearRxPacketsPerModulationList(): GatewayStats;
  addRxPacketsPerModulation(value?: PerModulationCount, index?: number): PerModulationCount;

  getTxPacketsPerStatusMap(): jspb.Map<string, number>;
  clearTxPacketsPerStatusMap(): GatewayStats;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GatewayStats.AsObject;
  static toObject(includeInstance: boolean, msg: GatewayStats): GatewayStats.AsObject;
  static serializeBinaryToWriter(message: GatewayStats, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GatewayStats;
  static deserializeBinaryFromReader(message: GatewayStats, reader: jspb.BinaryReader): GatewayStats;
}

export namespace GatewayStats {
  export type AsObject = {
    gatewayId: Uint8Array | string,
    ip: string,
    time?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    location?: common_common_pb.Location.AsObject,
    configVersion: string,
    rxPacketsReceived: number,
    rxPacketsReceivedOk: number,
    txPacketsReceived: number,
    txPacketsEmitted: number,
    metaDataMap: Array<[string, string]>,
    statsId: Uint8Array | string,
    txPacketsPerFrequencyMap: Array<[number, number]>,
    rxPacketsPerFrequencyMap: Array<[number, number]>,
    txPacketsPerModulationList: Array<PerModulationCount.AsObject>,
    rxPacketsPerModulationList: Array<PerModulationCount.AsObject>,
    txPacketsPerStatusMap: Array<[string, number]>,
  }
}

export class PerModulationCount extends jspb.Message {
  getModulation(): Modulation | undefined;
  setModulation(value?: Modulation): PerModulationCount;
  hasModulation(): boolean;
  clearModulation(): PerModulationCount;

  getCount(): number;
  setCount(value: number): PerModulationCount;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): PerModulationCount.AsObject;
  static toObject(includeInstance: boolean, msg: PerModulationCount): PerModulationCount.AsObject;
  static serializeBinaryToWriter(message: PerModulationCount, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): PerModulationCount;
  static deserializeBinaryFromReader(message: PerModulationCount, reader: jspb.BinaryReader): PerModulationCount;
}

export namespace PerModulationCount {
  export type AsObject = {
    modulation?: Modulation.AsObject,
    count: number,
  }
}

export class UplinkRXInfo extends jspb.Message {
  getGatewayId(): Uint8Array | string;
  getGatewayId_asU8(): Uint8Array;
  getGatewayId_asB64(): string;
  setGatewayId(value: Uint8Array | string): UplinkRXInfo;

  getTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setTime(value?: google_protobuf_timestamp_pb.Timestamp): UplinkRXInfo;
  hasTime(): boolean;
  clearTime(): UplinkRXInfo;

  getTimeSinceGpsEpoch(): google_protobuf_duration_pb.Duration | undefined;
  setTimeSinceGpsEpoch(value?: google_protobuf_duration_pb.Duration): UplinkRXInfo;
  hasTimeSinceGpsEpoch(): boolean;
  clearTimeSinceGpsEpoch(): UplinkRXInfo;

  getRssi(): number;
  setRssi(value: number): UplinkRXInfo;

  getLoraSnr(): number;
  setLoraSnr(value: number): UplinkRXInfo;

  getChannel(): number;
  setChannel(value: number): UplinkRXInfo;

  getRfChain(): number;
  setRfChain(value: number): UplinkRXInfo;

  getBoard(): number;
  setBoard(value: number): UplinkRXInfo;

  getAntenna(): number;
  setAntenna(value: number): UplinkRXInfo;

  getLocation(): common_common_pb.Location | undefined;
  setLocation(value?: common_common_pb.Location): UplinkRXInfo;
  hasLocation(): boolean;
  clearLocation(): UplinkRXInfo;

  getFineTimestampType(): FineTimestampType;
  setFineTimestampType(value: FineTimestampType): UplinkRXInfo;

  getEncryptedFineTimestamp(): EncryptedFineTimestamp | undefined;
  setEncryptedFineTimestamp(value?: EncryptedFineTimestamp): UplinkRXInfo;
  hasEncryptedFineTimestamp(): boolean;
  clearEncryptedFineTimestamp(): UplinkRXInfo;

  getPlainFineTimestamp(): PlainFineTimestamp | undefined;
  setPlainFineTimestamp(value?: PlainFineTimestamp): UplinkRXInfo;
  hasPlainFineTimestamp(): boolean;
  clearPlainFineTimestamp(): UplinkRXInfo;

  getContext(): Uint8Array | string;
  getContext_asU8(): Uint8Array;
  getContext_asB64(): string;
  setContext(value: Uint8Array | string): UplinkRXInfo;

  getUplinkId(): Uint8Array | string;
  getUplinkId_asU8(): Uint8Array;
  getUplinkId_asB64(): string;
  setUplinkId(value: Uint8Array | string): UplinkRXInfo;

  getCrcStatus(): CRCStatus;
  setCrcStatus(value: CRCStatus): UplinkRXInfo;

  getMetadataMap(): jspb.Map<string, string>;
  clearMetadataMap(): UplinkRXInfo;

  getFineTimestampCase(): UplinkRXInfo.FineTimestampCase;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): UplinkRXInfo.AsObject;
  static toObject(includeInstance: boolean, msg: UplinkRXInfo): UplinkRXInfo.AsObject;
  static serializeBinaryToWriter(message: UplinkRXInfo, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): UplinkRXInfo;
  static deserializeBinaryFromReader(message: UplinkRXInfo, reader: jspb.BinaryReader): UplinkRXInfo;
}

export namespace UplinkRXInfo {
  export type AsObject = {
    gatewayId: Uint8Array | string,
    time?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    timeSinceGpsEpoch?: google_protobuf_duration_pb.Duration.AsObject,
    rssi: number,
    loraSnr: number,
    channel: number,
    rfChain: number,
    board: number,
    antenna: number,
    location?: common_common_pb.Location.AsObject,
    fineTimestampType: FineTimestampType,
    encryptedFineTimestamp?: EncryptedFineTimestamp.AsObject,
    plainFineTimestamp?: PlainFineTimestamp.AsObject,
    context: Uint8Array | string,
    uplinkId: Uint8Array | string,
    crcStatus: CRCStatus,
    metadataMap: Array<[string, string]>,
  }

  export enum FineTimestampCase { 
    FINE_TIMESTAMP_NOT_SET = 0,
    ENCRYPTED_FINE_TIMESTAMP = 13,
    PLAIN_FINE_TIMESTAMP = 14,
  }
}

export class DownlinkTXInfo extends jspb.Message {
  getGatewayId(): Uint8Array | string;
  getGatewayId_asU8(): Uint8Array;
  getGatewayId_asB64(): string;
  setGatewayId(value: Uint8Array | string): DownlinkTXInfo;

  getFrequency(): number;
  setFrequency(value: number): DownlinkTXInfo;

  getPower(): number;
  setPower(value: number): DownlinkTXInfo;

  getModulation(): common_common_pb.Modulation;
  setModulation(value: common_common_pb.Modulation): DownlinkTXInfo;

  getLoraModulationInfo(): LoRaModulationInfo | undefined;
  setLoraModulationInfo(value?: LoRaModulationInfo): DownlinkTXInfo;
  hasLoraModulationInfo(): boolean;
  clearLoraModulationInfo(): DownlinkTXInfo;

  getFskModulationInfo(): FSKModulationInfo | undefined;
  setFskModulationInfo(value?: FSKModulationInfo): DownlinkTXInfo;
  hasFskModulationInfo(): boolean;
  clearFskModulationInfo(): DownlinkTXInfo;

  getBoard(): number;
  setBoard(value: number): DownlinkTXInfo;

  getAntenna(): number;
  setAntenna(value: number): DownlinkTXInfo;

  getTiming(): DownlinkTiming;
  setTiming(value: DownlinkTiming): DownlinkTXInfo;

  getImmediatelyTimingInfo(): ImmediatelyTimingInfo | undefined;
  setImmediatelyTimingInfo(value?: ImmediatelyTimingInfo): DownlinkTXInfo;
  hasImmediatelyTimingInfo(): boolean;
  clearImmediatelyTimingInfo(): DownlinkTXInfo;

  getDelayTimingInfo(): DelayTimingInfo | undefined;
  setDelayTimingInfo(value?: DelayTimingInfo): DownlinkTXInfo;
  hasDelayTimingInfo(): boolean;
  clearDelayTimingInfo(): DownlinkTXInfo;

  getGpsEpochTimingInfo(): GPSEpochTimingInfo | undefined;
  setGpsEpochTimingInfo(value?: GPSEpochTimingInfo): DownlinkTXInfo;
  hasGpsEpochTimingInfo(): boolean;
  clearGpsEpochTimingInfo(): DownlinkTXInfo;

  getContext(): Uint8Array | string;
  getContext_asU8(): Uint8Array;
  getContext_asB64(): string;
  setContext(value: Uint8Array | string): DownlinkTXInfo;

  getModulationInfoCase(): DownlinkTXInfo.ModulationInfoCase;

  getTimingInfoCase(): DownlinkTXInfo.TimingInfoCase;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DownlinkTXInfo.AsObject;
  static toObject(includeInstance: boolean, msg: DownlinkTXInfo): DownlinkTXInfo.AsObject;
  static serializeBinaryToWriter(message: DownlinkTXInfo, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DownlinkTXInfo;
  static deserializeBinaryFromReader(message: DownlinkTXInfo, reader: jspb.BinaryReader): DownlinkTXInfo;
}

export namespace DownlinkTXInfo {
  export type AsObject = {
    gatewayId: Uint8Array | string,
    frequency: number,
    power: number,
    modulation: common_common_pb.Modulation,
    loraModulationInfo?: LoRaModulationInfo.AsObject,
    fskModulationInfo?: FSKModulationInfo.AsObject,
    board: number,
    antenna: number,
    timing: DownlinkTiming,
    immediatelyTimingInfo?: ImmediatelyTimingInfo.AsObject,
    delayTimingInfo?: DelayTimingInfo.AsObject,
    gpsEpochTimingInfo?: GPSEpochTimingInfo.AsObject,
    context: Uint8Array | string,
  }

  export enum ModulationInfoCase { 
    MODULATION_INFO_NOT_SET = 0,
    LORA_MODULATION_INFO = 8,
    FSK_MODULATION_INFO = 9,
  }

  export enum TimingInfoCase { 
    TIMING_INFO_NOT_SET = 0,
    IMMEDIATELY_TIMING_INFO = 13,
    DELAY_TIMING_INFO = 14,
    GPS_EPOCH_TIMING_INFO = 15,
  }
}

export class ImmediatelyTimingInfo extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ImmediatelyTimingInfo.AsObject;
  static toObject(includeInstance: boolean, msg: ImmediatelyTimingInfo): ImmediatelyTimingInfo.AsObject;
  static serializeBinaryToWriter(message: ImmediatelyTimingInfo, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ImmediatelyTimingInfo;
  static deserializeBinaryFromReader(message: ImmediatelyTimingInfo, reader: jspb.BinaryReader): ImmediatelyTimingInfo;
}

export namespace ImmediatelyTimingInfo {
  export type AsObject = {
  }
}

export class DelayTimingInfo extends jspb.Message {
  getDelay(): google_protobuf_duration_pb.Duration | undefined;
  setDelay(value?: google_protobuf_duration_pb.Duration): DelayTimingInfo;
  hasDelay(): boolean;
  clearDelay(): DelayTimingInfo;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DelayTimingInfo.AsObject;
  static toObject(includeInstance: boolean, msg: DelayTimingInfo): DelayTimingInfo.AsObject;
  static serializeBinaryToWriter(message: DelayTimingInfo, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DelayTimingInfo;
  static deserializeBinaryFromReader(message: DelayTimingInfo, reader: jspb.BinaryReader): DelayTimingInfo;
}

export namespace DelayTimingInfo {
  export type AsObject = {
    delay?: google_protobuf_duration_pb.Duration.AsObject,
  }
}

export class GPSEpochTimingInfo extends jspb.Message {
  getTimeSinceGpsEpoch(): google_protobuf_duration_pb.Duration | undefined;
  setTimeSinceGpsEpoch(value?: google_protobuf_duration_pb.Duration): GPSEpochTimingInfo;
  hasTimeSinceGpsEpoch(): boolean;
  clearTimeSinceGpsEpoch(): GPSEpochTimingInfo;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GPSEpochTimingInfo.AsObject;
  static toObject(includeInstance: boolean, msg: GPSEpochTimingInfo): GPSEpochTimingInfo.AsObject;
  static serializeBinaryToWriter(message: GPSEpochTimingInfo, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GPSEpochTimingInfo;
  static deserializeBinaryFromReader(message: GPSEpochTimingInfo, reader: jspb.BinaryReader): GPSEpochTimingInfo;
}

export namespace GPSEpochTimingInfo {
  export type AsObject = {
    timeSinceGpsEpoch?: google_protobuf_duration_pb.Duration.AsObject,
  }
}

export class UplinkFrame extends jspb.Message {
  getPhyPayload(): Uint8Array | string;
  getPhyPayload_asU8(): Uint8Array;
  getPhyPayload_asB64(): string;
  setPhyPayload(value: Uint8Array | string): UplinkFrame;

  getTxInfo(): UplinkTXInfo | undefined;
  setTxInfo(value?: UplinkTXInfo): UplinkFrame;
  hasTxInfo(): boolean;
  clearTxInfo(): UplinkFrame;

  getRxInfo(): UplinkRXInfo | undefined;
  setRxInfo(value?: UplinkRXInfo): UplinkFrame;
  hasRxInfo(): boolean;
  clearRxInfo(): UplinkFrame;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): UplinkFrame.AsObject;
  static toObject(includeInstance: boolean, msg: UplinkFrame): UplinkFrame.AsObject;
  static serializeBinaryToWriter(message: UplinkFrame, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): UplinkFrame;
  static deserializeBinaryFromReader(message: UplinkFrame, reader: jspb.BinaryReader): UplinkFrame;
}

export namespace UplinkFrame {
  export type AsObject = {
    phyPayload: Uint8Array | string,
    txInfo?: UplinkTXInfo.AsObject,
    rxInfo?: UplinkRXInfo.AsObject,
  }
}

export class UplinkFrameSet extends jspb.Message {
  getPhyPayload(): Uint8Array | string;
  getPhyPayload_asU8(): Uint8Array;
  getPhyPayload_asB64(): string;
  setPhyPayload(value: Uint8Array | string): UplinkFrameSet;

  getTxInfo(): UplinkTXInfo | undefined;
  setTxInfo(value?: UplinkTXInfo): UplinkFrameSet;
  hasTxInfo(): boolean;
  clearTxInfo(): UplinkFrameSet;

  getRxInfoList(): Array<UplinkRXInfo>;
  setRxInfoList(value: Array<UplinkRXInfo>): UplinkFrameSet;
  clearRxInfoList(): UplinkFrameSet;
  addRxInfo(value?: UplinkRXInfo, index?: number): UplinkRXInfo;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): UplinkFrameSet.AsObject;
  static toObject(includeInstance: boolean, msg: UplinkFrameSet): UplinkFrameSet.AsObject;
  static serializeBinaryToWriter(message: UplinkFrameSet, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): UplinkFrameSet;
  static deserializeBinaryFromReader(message: UplinkFrameSet, reader: jspb.BinaryReader): UplinkFrameSet;
}

export namespace UplinkFrameSet {
  export type AsObject = {
    phyPayload: Uint8Array | string,
    txInfo?: UplinkTXInfo.AsObject,
    rxInfoList: Array<UplinkRXInfo.AsObject>,
  }
}

export class DownlinkFrame extends jspb.Message {
  getPhyPayload(): Uint8Array | string;
  getPhyPayload_asU8(): Uint8Array;
  getPhyPayload_asB64(): string;
  setPhyPayload(value: Uint8Array | string): DownlinkFrame;

  getTxInfo(): DownlinkTXInfo | undefined;
  setTxInfo(value?: DownlinkTXInfo): DownlinkFrame;
  hasTxInfo(): boolean;
  clearTxInfo(): DownlinkFrame;

  getToken(): number;
  setToken(value: number): DownlinkFrame;

  getDownlinkId(): Uint8Array | string;
  getDownlinkId_asU8(): Uint8Array;
  getDownlinkId_asB64(): string;
  setDownlinkId(value: Uint8Array | string): DownlinkFrame;

  getItemsList(): Array<DownlinkFrameItem>;
  setItemsList(value: Array<DownlinkFrameItem>): DownlinkFrame;
  clearItemsList(): DownlinkFrame;
  addItems(value?: DownlinkFrameItem, index?: number): DownlinkFrameItem;

  getGatewayId(): Uint8Array | string;
  getGatewayId_asU8(): Uint8Array;
  getGatewayId_asB64(): string;
  setGatewayId(value: Uint8Array | string): DownlinkFrame;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DownlinkFrame.AsObject;
  static toObject(includeInstance: boolean, msg: DownlinkFrame): DownlinkFrame.AsObject;
  static serializeBinaryToWriter(message: DownlinkFrame, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DownlinkFrame;
  static deserializeBinaryFromReader(message: DownlinkFrame, reader: jspb.BinaryReader): DownlinkFrame;
}

export namespace DownlinkFrame {
  export type AsObject = {
    phyPayload: Uint8Array | string,
    txInfo?: DownlinkTXInfo.AsObject,
    token: number,
    downlinkId: Uint8Array | string,
    itemsList: Array<DownlinkFrameItem.AsObject>,
    gatewayId: Uint8Array | string,
  }
}

export class DownlinkFrameItem extends jspb.Message {
  getPhyPayload(): Uint8Array | string;
  getPhyPayload_asU8(): Uint8Array;
  getPhyPayload_asB64(): string;
  setPhyPayload(value: Uint8Array | string): DownlinkFrameItem;

  getTxInfo(): DownlinkTXInfo | undefined;
  setTxInfo(value?: DownlinkTXInfo): DownlinkFrameItem;
  hasTxInfo(): boolean;
  clearTxInfo(): DownlinkFrameItem;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DownlinkFrameItem.AsObject;
  static toObject(includeInstance: boolean, msg: DownlinkFrameItem): DownlinkFrameItem.AsObject;
  static serializeBinaryToWriter(message: DownlinkFrameItem, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DownlinkFrameItem;
  static deserializeBinaryFromReader(message: DownlinkFrameItem, reader: jspb.BinaryReader): DownlinkFrameItem;
}

export namespace DownlinkFrameItem {
  export type AsObject = {
    phyPayload: Uint8Array | string,
    txInfo?: DownlinkTXInfo.AsObject,
  }
}

export class DownlinkTXAck extends jspb.Message {
  getGatewayId(): Uint8Array | string;
  getGatewayId_asU8(): Uint8Array;
  getGatewayId_asB64(): string;
  setGatewayId(value: Uint8Array | string): DownlinkTXAck;

  getToken(): number;
  setToken(value: number): DownlinkTXAck;

  getError(): string;
  setError(value: string): DownlinkTXAck;

  getDownlinkId(): Uint8Array | string;
  getDownlinkId_asU8(): Uint8Array;
  getDownlinkId_asB64(): string;
  setDownlinkId(value: Uint8Array | string): DownlinkTXAck;

  getItemsList(): Array<DownlinkTXAckItem>;
  setItemsList(value: Array<DownlinkTXAckItem>): DownlinkTXAck;
  clearItemsList(): DownlinkTXAck;
  addItems(value?: DownlinkTXAckItem, index?: number): DownlinkTXAckItem;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DownlinkTXAck.AsObject;
  static toObject(includeInstance: boolean, msg: DownlinkTXAck): DownlinkTXAck.AsObject;
  static serializeBinaryToWriter(message: DownlinkTXAck, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DownlinkTXAck;
  static deserializeBinaryFromReader(message: DownlinkTXAck, reader: jspb.BinaryReader): DownlinkTXAck;
}

export namespace DownlinkTXAck {
  export type AsObject = {
    gatewayId: Uint8Array | string,
    token: number,
    error: string,
    downlinkId: Uint8Array | string,
    itemsList: Array<DownlinkTXAckItem.AsObject>,
  }
}

export class DownlinkTXAckItem extends jspb.Message {
  getStatus(): TxAckStatus;
  setStatus(value: TxAckStatus): DownlinkTXAckItem;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DownlinkTXAckItem.AsObject;
  static toObject(includeInstance: boolean, msg: DownlinkTXAckItem): DownlinkTXAckItem.AsObject;
  static serializeBinaryToWriter(message: DownlinkTXAckItem, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DownlinkTXAckItem;
  static deserializeBinaryFromReader(message: DownlinkTXAckItem, reader: jspb.BinaryReader): DownlinkTXAckItem;
}

export namespace DownlinkTXAckItem {
  export type AsObject = {
    status: TxAckStatus,
  }
}

export class GatewayConfiguration extends jspb.Message {
  getGatewayId(): Uint8Array | string;
  getGatewayId_asU8(): Uint8Array;
  getGatewayId_asB64(): string;
  setGatewayId(value: Uint8Array | string): GatewayConfiguration;

  getVersion(): string;
  setVersion(value: string): GatewayConfiguration;

  getChannelsList(): Array<ChannelConfiguration>;
  setChannelsList(value: Array<ChannelConfiguration>): GatewayConfiguration;
  clearChannelsList(): GatewayConfiguration;
  addChannels(value?: ChannelConfiguration, index?: number): ChannelConfiguration;

  getStatsInterval(): google_protobuf_duration_pb.Duration | undefined;
  setStatsInterval(value?: google_protobuf_duration_pb.Duration): GatewayConfiguration;
  hasStatsInterval(): boolean;
  clearStatsInterval(): GatewayConfiguration;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GatewayConfiguration.AsObject;
  static toObject(includeInstance: boolean, msg: GatewayConfiguration): GatewayConfiguration.AsObject;
  static serializeBinaryToWriter(message: GatewayConfiguration, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GatewayConfiguration;
  static deserializeBinaryFromReader(message: GatewayConfiguration, reader: jspb.BinaryReader): GatewayConfiguration;
}

export namespace GatewayConfiguration {
  export type AsObject = {
    gatewayId: Uint8Array | string,
    version: string,
    channelsList: Array<ChannelConfiguration.AsObject>,
    statsInterval?: google_protobuf_duration_pb.Duration.AsObject,
  }
}

export class ChannelConfiguration extends jspb.Message {
  getFrequency(): number;
  setFrequency(value: number): ChannelConfiguration;

  getModulation(): common_common_pb.Modulation;
  setModulation(value: common_common_pb.Modulation): ChannelConfiguration;

  getLoraModulationConfig(): LoRaModulationConfig | undefined;
  setLoraModulationConfig(value?: LoRaModulationConfig): ChannelConfiguration;
  hasLoraModulationConfig(): boolean;
  clearLoraModulationConfig(): ChannelConfiguration;

  getFskModulationConfig(): FSKModulationConfig | undefined;
  setFskModulationConfig(value?: FSKModulationConfig): ChannelConfiguration;
  hasFskModulationConfig(): boolean;
  clearFskModulationConfig(): ChannelConfiguration;

  getBoard(): number;
  setBoard(value: number): ChannelConfiguration;

  getDemodulator(): number;
  setDemodulator(value: number): ChannelConfiguration;

  getModulationConfigCase(): ChannelConfiguration.ModulationConfigCase;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ChannelConfiguration.AsObject;
  static toObject(includeInstance: boolean, msg: ChannelConfiguration): ChannelConfiguration.AsObject;
  static serializeBinaryToWriter(message: ChannelConfiguration, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ChannelConfiguration;
  static deserializeBinaryFromReader(message: ChannelConfiguration, reader: jspb.BinaryReader): ChannelConfiguration;
}

export namespace ChannelConfiguration {
  export type AsObject = {
    frequency: number,
    modulation: common_common_pb.Modulation,
    loraModulationConfig?: LoRaModulationConfig.AsObject,
    fskModulationConfig?: FSKModulationConfig.AsObject,
    board: number,
    demodulator: number,
  }

  export enum ModulationConfigCase { 
    MODULATION_CONFIG_NOT_SET = 0,
    LORA_MODULATION_CONFIG = 3,
    FSK_MODULATION_CONFIG = 4,
  }
}

export class LoRaModulationConfig extends jspb.Message {
  getBandwidth(): number;
  setBandwidth(value: number): LoRaModulationConfig;

  getSpreadingFactorsList(): Array<number>;
  setSpreadingFactorsList(value: Array<number>): LoRaModulationConfig;
  clearSpreadingFactorsList(): LoRaModulationConfig;
  addSpreadingFactors(value: number, index?: number): LoRaModulationConfig;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): LoRaModulationConfig.AsObject;
  static toObject(includeInstance: boolean, msg: LoRaModulationConfig): LoRaModulationConfig.AsObject;
  static serializeBinaryToWriter(message: LoRaModulationConfig, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): LoRaModulationConfig;
  static deserializeBinaryFromReader(message: LoRaModulationConfig, reader: jspb.BinaryReader): LoRaModulationConfig;
}

export namespace LoRaModulationConfig {
  export type AsObject = {
    bandwidth: number,
    spreadingFactorsList: Array<number>,
  }
}

export class FSKModulationConfig extends jspb.Message {
  getBandwidth(): number;
  setBandwidth(value: number): FSKModulationConfig;

  getBitrate(): number;
  setBitrate(value: number): FSKModulationConfig;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): FSKModulationConfig.AsObject;
  static toObject(includeInstance: boolean, msg: FSKModulationConfig): FSKModulationConfig.AsObject;
  static serializeBinaryToWriter(message: FSKModulationConfig, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): FSKModulationConfig;
  static deserializeBinaryFromReader(message: FSKModulationConfig, reader: jspb.BinaryReader): FSKModulationConfig;
}

export namespace FSKModulationConfig {
  export type AsObject = {
    bandwidth: number,
    bitrate: number,
  }
}

export class GatewayCommandExecRequest extends jspb.Message {
  getGatewayId(): Uint8Array | string;
  getGatewayId_asU8(): Uint8Array;
  getGatewayId_asB64(): string;
  setGatewayId(value: Uint8Array | string): GatewayCommandExecRequest;

  getCommand(): string;
  setCommand(value: string): GatewayCommandExecRequest;

  getExecid(): Uint8Array | string;
  getExecid_asU8(): Uint8Array;
  getExecid_asB64(): string;
  setExecid(value: Uint8Array | string): GatewayCommandExecRequest;

  getStdin(): Uint8Array | string;
  getStdin_asU8(): Uint8Array;
  getStdin_asB64(): string;
  setStdin(value: Uint8Array | string): GatewayCommandExecRequest;

  getEnvironmentMap(): jspb.Map<string, string>;
  clearEnvironmentMap(): GatewayCommandExecRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GatewayCommandExecRequest.AsObject;
  static toObject(includeInstance: boolean, msg: GatewayCommandExecRequest): GatewayCommandExecRequest.AsObject;
  static serializeBinaryToWriter(message: GatewayCommandExecRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GatewayCommandExecRequest;
  static deserializeBinaryFromReader(message: GatewayCommandExecRequest, reader: jspb.BinaryReader): GatewayCommandExecRequest;
}

export namespace GatewayCommandExecRequest {
  export type AsObject = {
    gatewayId: Uint8Array | string,
    command: string,
    execid: Uint8Array | string,
    stdin: Uint8Array | string,
    environmentMap: Array<[string, string]>,
  }
}

export class GatewayCommandExecResponse extends jspb.Message {
  getGatewayId(): Uint8Array | string;
  getGatewayId_asU8(): Uint8Array;
  getGatewayId_asB64(): string;
  setGatewayId(value: Uint8Array | string): GatewayCommandExecResponse;

  getExecId(): Uint8Array | string;
  getExecId_asU8(): Uint8Array;
  getExecId_asB64(): string;
  setExecId(value: Uint8Array | string): GatewayCommandExecResponse;

  getStdout(): Uint8Array | string;
  getStdout_asU8(): Uint8Array;
  getStdout_asB64(): string;
  setStdout(value: Uint8Array | string): GatewayCommandExecResponse;

  getStderr(): Uint8Array | string;
  getStderr_asU8(): Uint8Array;
  getStderr_asB64(): string;
  setStderr(value: Uint8Array | string): GatewayCommandExecResponse;

  getError(): string;
  setError(value: string): GatewayCommandExecResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GatewayCommandExecResponse.AsObject;
  static toObject(includeInstance: boolean, msg: GatewayCommandExecResponse): GatewayCommandExecResponse.AsObject;
  static serializeBinaryToWriter(message: GatewayCommandExecResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GatewayCommandExecResponse;
  static deserializeBinaryFromReader(message: GatewayCommandExecResponse, reader: jspb.BinaryReader): GatewayCommandExecResponse;
}

export namespace GatewayCommandExecResponse {
  export type AsObject = {
    gatewayId: Uint8Array | string,
    execId: Uint8Array | string,
    stdout: Uint8Array | string,
    stderr: Uint8Array | string,
    error: string,
  }
}

export class RawPacketForwarderEvent extends jspb.Message {
  getGatewayId(): Uint8Array | string;
  getGatewayId_asU8(): Uint8Array;
  getGatewayId_asB64(): string;
  setGatewayId(value: Uint8Array | string): RawPacketForwarderEvent;

  getRawId(): Uint8Array | string;
  getRawId_asU8(): Uint8Array;
  getRawId_asB64(): string;
  setRawId(value: Uint8Array | string): RawPacketForwarderEvent;

  getPayload(): Uint8Array | string;
  getPayload_asU8(): Uint8Array;
  getPayload_asB64(): string;
  setPayload(value: Uint8Array | string): RawPacketForwarderEvent;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): RawPacketForwarderEvent.AsObject;
  static toObject(includeInstance: boolean, msg: RawPacketForwarderEvent): RawPacketForwarderEvent.AsObject;
  static serializeBinaryToWriter(message: RawPacketForwarderEvent, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): RawPacketForwarderEvent;
  static deserializeBinaryFromReader(message: RawPacketForwarderEvent, reader: jspb.BinaryReader): RawPacketForwarderEvent;
}

export namespace RawPacketForwarderEvent {
  export type AsObject = {
    gatewayId: Uint8Array | string,
    rawId: Uint8Array | string,
    payload: Uint8Array | string,
  }
}

export class RawPacketForwarderCommand extends jspb.Message {
  getGatewayId(): Uint8Array | string;
  getGatewayId_asU8(): Uint8Array;
  getGatewayId_asB64(): string;
  setGatewayId(value: Uint8Array | string): RawPacketForwarderCommand;

  getRawId(): Uint8Array | string;
  getRawId_asU8(): Uint8Array;
  getRawId_asB64(): string;
  setRawId(value: Uint8Array | string): RawPacketForwarderCommand;

  getPayload(): Uint8Array | string;
  getPayload_asU8(): Uint8Array;
  getPayload_asB64(): string;
  setPayload(value: Uint8Array | string): RawPacketForwarderCommand;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): RawPacketForwarderCommand.AsObject;
  static toObject(includeInstance: boolean, msg: RawPacketForwarderCommand): RawPacketForwarderCommand.AsObject;
  static serializeBinaryToWriter(message: RawPacketForwarderCommand, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): RawPacketForwarderCommand;
  static deserializeBinaryFromReader(message: RawPacketForwarderCommand, reader: jspb.BinaryReader): RawPacketForwarderCommand;
}

export namespace RawPacketForwarderCommand {
  export type AsObject = {
    gatewayId: Uint8Array | string,
    rawId: Uint8Array | string,
    payload: Uint8Array | string,
  }
}

export class ConnState extends jspb.Message {
  getGatewayId(): Uint8Array | string;
  getGatewayId_asU8(): Uint8Array;
  getGatewayId_asB64(): string;
  setGatewayId(value: Uint8Array | string): ConnState;

  getState(): ConnState.State;
  setState(value: ConnState.State): ConnState;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ConnState.AsObject;
  static toObject(includeInstance: boolean, msg: ConnState): ConnState.AsObject;
  static serializeBinaryToWriter(message: ConnState, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ConnState;
  static deserializeBinaryFromReader(message: ConnState, reader: jspb.BinaryReader): ConnState;
}

export namespace ConnState {
  export type AsObject = {
    gatewayId: Uint8Array | string,
    state: ConnState.State,
  }

  export enum State { 
    OFFLINE = 0,
    ONLINE = 1,
  }
}

export enum DownlinkTiming { 
  IMMEDIATELY = 0,
  DELAY = 1,
  GPS_EPOCH = 2,
}
export enum FineTimestampType { 
  NONE = 0,
  ENCRYPTED = 1,
  PLAIN = 2,
}
export enum CRCStatus { 
  NO_CRC = 0,
  BAD_CRC = 1,
  CRC_OK = 2,
}
export enum TxAckStatus { 
  IGNORED = 0,
  OK = 1,
  TOO_LATE = 2,
  TOO_EARLY = 3,
  COLLISION_PACKET = 4,
  COLLISION_BEACON = 5,
  TX_FREQ = 6,
  TX_POWER = 7,
  GPS_UNLOCKED = 8,
  QUEUE_FULL = 9,
  INTERNAL_ERROR = 10,
}