ExternalVendorCode/chirpstack
1
0
Fork 0
mirror of https://github.com/chirpstack/chirpstack.git synced 2025-06-21 16:49:39 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Initial Relay support implementation (TS011).

Browse Source 
Closes #59.
This commit is contained in:
Orne Brocaar
2023-05-22 11:04:13 +01:00
parent 513aa7804d
commit cefe61072d
138 changed files with 28259 additions and 5157 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
api/grpc-web/api/device_pb.d.ts vendored
View File

@ -35,6 +35,9 @@ export class Device extends jspb.Message {
getTagsMap(): jspb.Map<string, string>;
clearTagsMap(): Device;
getJoinEui(): string;
setJoinEui(value: string): Device;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Device.AsObject;
static toObject(includeInstance: boolean, msg: Device): Device.AsObject;
@ -54,6 +57,7 @@ export namespace Device {
isDisabled: boolean,
variablesMap: Array<[string, string]>,
tagsMap: Array<[string, string]>,
joinEui: string,
}
}

32
api/grpc-web/api/device_pb.js vendored
View File

@ -832,7 +832,8 @@ proto.api.Device.toObject = function(includeInstance, msg) {
skipFcntCheck: jspb.Message.getBooleanFieldWithDefault(msg, 6, false),
isDisabled: jspb.Message.getBooleanFieldWithDefault(msg, 7, false),
variablesMap: (f = msg.getVariablesMap()) ? f.toObject(includeInstance, undefined) : [],
tagsMap: (f = msg.getTagsMap()) ? f.toObject(includeInstance, undefined) : []
tagsMap: (f = msg.getTagsMap()) ? f.toObject(includeInstance, undefined) : [],
joinEui: jspb.Message.getFieldWithDefault(msg, 10, "")
};
if (includeInstance) {
@ -909,6 +910,10 @@ proto.api.Device.deserializeBinaryFromReader = function(msg, reader) {
jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", "");
});
break;
case 10:
var value = /** @type {string} */ (reader.readString());
msg.setJoinEui(value);
break;
default:
reader.skipField();
break;
@ -995,6 +1000,13 @@ proto.api.Device.serializeBinaryToWriter = function(message, writer) {
if (f && f.getLength() > 0) {
f.serializeBinary(9, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString);
}
f = message.getJoinEui();
if (f.length > 0) {
writer.writeString(
10,
f
);
}
};
@ -1168,6 +1180,24 @@ proto.api.Device.prototype.clearTagsMap = function() {
return this;};
/**
* optional string join_eui = 10;
* @return {string}
*/
proto.api.Device.prototype.getJoinEui = function() {
return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 10, ""));
};
/**
* @param {string} value
* @return {!proto.api.Device} returns this
*/
proto.api.Device.prototype.setJoinEui = function(value) {
return jspb.Message.setProto3StringField(this, 10, value);
};

110
api/grpc-web/api/device_profile_pb.d.ts vendored
View File

@ -94,6 +94,72 @@ export class DeviceProfile extends jspb.Message {
getRegionConfigId(): string;
setRegionConfigId(value: string): DeviceProfile;
getIsRelay(): boolean;
setIsRelay(value: boolean): DeviceProfile;
getIsRelayEd(): boolean;
setIsRelayEd(value: boolean): DeviceProfile;
getRelayEdRelayOnly(): boolean;
setRelayEdRelayOnly(value: boolean): DeviceProfile;
getRelayEnabled(): boolean;
setRelayEnabled(value: boolean): DeviceProfile;
getRelayCadPeriodicity(): CadPeriodicity;
setRelayCadPeriodicity(value: CadPeriodicity): DeviceProfile;
getRelayDefaultChannelIndex(): number;
setRelayDefaultChannelIndex(value: number): DeviceProfile;
getRelaySecondChannelFreq(): number;
setRelaySecondChannelFreq(value: number): DeviceProfile;
getRelaySecondChannelDr(): number;
setRelaySecondChannelDr(value: number): DeviceProfile;
getRelaySecondChannelAckOffset(): SecondChAckOffset;
setRelaySecondChannelAckOffset(value: SecondChAckOffset): DeviceProfile;
getRelayEdActivationMode(): RelayModeActivation;
setRelayEdActivationMode(value: RelayModeActivation): DeviceProfile;
getRelayEdSmartEnableLevel(): number;
setRelayEdSmartEnableLevel(value: number): DeviceProfile;
getRelayEdBackOff(): number;
setRelayEdBackOff(value: number): DeviceProfile;
getRelayEdUplinkLimitBucketSize(): number;
setRelayEdUplinkLimitBucketSize(value: number): DeviceProfile;
getRelayEdUplinkLimitReloadRate(): number;
setRelayEdUplinkLimitReloadRate(value: number): DeviceProfile;
getRelayJoinReqLimitReloadRate(): number;
setRelayJoinReqLimitReloadRate(value: number): DeviceProfile;
getRelayNotifyLimitReloadRate(): number;
setRelayNotifyLimitReloadRate(value: number): DeviceProfile;
getRelayGlobalUplinkLimitReloadRate(): number;
setRelayGlobalUplinkLimitReloadRate(value: number): DeviceProfile;
getRelayOverallLimitReloadRate(): number;
setRelayOverallLimitReloadRate(value: number): DeviceProfile;
getRelayJoinReqLimitBucketSize(): number;
setRelayJoinReqLimitBucketSize(value: number): DeviceProfile;
getRelayNotifyLimitBucketSize(): number;
setRelayNotifyLimitBucketSize(value: number): DeviceProfile;
getRelayGlobalUplinkLimitBucketSize(): number;
setRelayGlobalUplinkLimitBucketSize(value: number): DeviceProfile;
getRelayOverallLimitBucketSize(): number;
setRelayOverallLimitBucketSize(value: number): DeviceProfile;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): DeviceProfile.AsObject;
static toObject(includeInstance: boolean, msg: DeviceProfile): DeviceProfile.AsObject;
@ -133,6 +199,28 @@ export namespace DeviceProfile {
measurementsMap: Array<[string, Measurement.AsObject]>,
autoDetectMeasurements: boolean,
regionConfigId: string,
isRelay: boolean,
isRelayEd: boolean,
relayEdRelayOnly: boolean,
relayEnabled: boolean,
relayCadPeriodicity: CadPeriodicity,
relayDefaultChannelIndex: number,
relaySecondChannelFreq: number,
relaySecondChannelDr: number,
relaySecondChannelAckOffset: SecondChAckOffset,
relayEdActivationMode: RelayModeActivation,
relayEdSmartEnableLevel: number,
relayEdBackOff: number,
relayEdUplinkLimitBucketSize: number,
relayEdUplinkLimitReloadRate: number,
relayJoinReqLimitReloadRate: number,
relayNotifyLimitReloadRate: number,
relayGlobalUplinkLimitReloadRate: number,
relayOverallLimitReloadRate: number,
relayJoinReqLimitBucketSize: number,
relayNotifyLimitBucketSize: number,
relayGlobalUplinkLimitBucketSize: number,
relayOverallLimitBucketSize: number,
}
}
@ -454,3 +542,25 @@ export enum MeasurementKind {
GAUGE = 3,
STRING = 4,
}
export enum CadPeriodicity {
SEC_1 = 0,
MS_500 = 1,
MS_250 = 2,
MS_100 = 3,
MS_50 = 4,
MS_20 = 5,
}
export enum SecondChAckOffset {
KHZ_0 = 0,
KHZ_200 = 1,
KHZ_400 = 2,
KHZ_800 = 3,
KHZ_1600 = 4,
KHZ_3200 = 5,
}
export enum RelayModeActivation {
DISABLE_RELAY_MODE = 0,
ENABLE_RELAY_MODE = 1,
DYNAMIC = 2,
END_DEVICE_CONTROLLED = 3,
}

699
api/grpc-web/api/device_profile_pb.js vendored
View File

@ -21,6 +21,7 @@ goog.object.extend(proto, google_protobuf_empty_pb);
var common_common_pb = require('../common/common_pb.js');
goog.object.extend(proto, common_common_pb);
goog.exportSymbol('proto.api.AdrAlgorithmListItem', null, global);
goog.exportSymbol('proto.api.CadPeriodicity', null, global);
goog.exportSymbol('proto.api.CodecRuntime', null, global);
goog.exportSymbol('proto.api.CreateDeviceProfileRequest', null, global);
goog.exportSymbol('proto.api.CreateDeviceProfileResponse', null, global);
@ -34,6 +35,8 @@ goog.exportSymbol('proto.api.ListDeviceProfilesRequest', null, global);
goog.exportSymbol('proto.api.ListDeviceProfilesResponse', null, global);
goog.exportSymbol('proto.api.Measurement', null, global);
goog.exportSymbol('proto.api.MeasurementKind', null, global);
goog.exportSymbol('proto.api.RelayModeActivation', null, global);
goog.exportSymbol('proto.api.SecondChAckOffset', null, global);
goog.exportSymbol('proto.api.UpdateDeviceProfileRequest', null, global);
/**
* Generated by JsPbCodeGenerator.
@ -368,7 +371,29 @@ proto.api.DeviceProfile.toObject = function(includeInstance, msg) {
tagsMap: (f = msg.getTagsMap()) ? f.toObject(includeInstance, undefined) : [],
measurementsMap: (f = msg.getMeasurementsMap()) ? f.toObject(includeInstance, proto.api.Measurement.toObject) : [],
autoDetectMeasurements: jspb.Message.getBooleanFieldWithDefault(msg, 28, false),
regionConfigId: jspb.Message.getFieldWithDefault(msg, 29, "")
regionConfigId: jspb.Message.getFieldWithDefault(msg, 29, ""),
isRelay: jspb.Message.getBooleanFieldWithDefault(msg, 30, false),
isRelayEd: jspb.Message.getBooleanFieldWithDefault(msg, 31, false),
relayEdRelayOnly: jspb.Message.getBooleanFieldWithDefault(msg, 32, false),
relayEnabled: jspb.Message.getBooleanFieldWithDefault(msg, 33, false),
relayCadPeriodicity: jspb.Message.getFieldWithDefault(msg, 34, 0),
relayDefaultChannelIndex: jspb.Message.getFieldWithDefault(msg, 35, 0),
relaySecondChannelFreq: jspb.Message.getFieldWithDefault(msg, 36, 0),
relaySecondChannelDr: jspb.Message.getFieldWithDefault(msg, 37, 0),
relaySecondChannelAckOffset: jspb.Message.getFieldWithDefault(msg, 38, 0),
relayEdActivationMode: jspb.Message.getFieldWithDefault(msg, 39, 0),
relayEdSmartEnableLevel: jspb.Message.getFieldWithDefault(msg, 40, 0),
relayEdBackOff: jspb.Message.getFieldWithDefault(msg, 41, 0),
relayEdUplinkLimitBucketSize: jspb.Message.getFieldWithDefault(msg, 42, 0),
relayEdUplinkLimitReloadRate: jspb.Message.getFieldWithDefault(msg, 43, 0),
relayJoinReqLimitReloadRate: jspb.Message.getFieldWithDefault(msg, 44, 0),
relayNotifyLimitReloadRate: jspb.Message.getFieldWithDefault(msg, 45, 0),
relayGlobalUplinkLimitReloadRate: jspb.Message.getFieldWithDefault(msg, 46, 0),
relayOverallLimitReloadRate: jspb.Message.getFieldWithDefault(msg, 47, 0),
relayJoinReqLimitBucketSize: jspb.Message.getFieldWithDefault(msg, 48, 0),
relayNotifyLimitBucketSize: jspb.Message.getFieldWithDefault(msg, 49, 0),
relayGlobalUplinkLimitBucketSize: jspb.Message.getFieldWithDefault(msg, 50, 0),
relayOverallLimitBucketSize: jspb.Message.getFieldWithDefault(msg, 51, 0)
};
if (includeInstance) {
@ -525,6 +550,94 @@ proto.api.DeviceProfile.deserializeBinaryFromReader = function(msg, reader) {
var value = /** @type {string} */ (reader.readString());
msg.setRegionConfigId(value);
break;
case 30:
var value = /** @type {boolean} */ (reader.readBool());
msg.setIsRelay(value);
break;
case 31:
var value = /** @type {boolean} */ (reader.readBool());
msg.setIsRelayEd(value);
break;
case 32:
var value = /** @type {boolean} */ (reader.readBool());
msg.setRelayEdRelayOnly(value);
break;
case 33:
var value = /** @type {boolean} */ (reader.readBool());
msg.setRelayEnabled(value);
break;
case 34:
var value = /** @type {!proto.api.CadPeriodicity} */ (reader.readEnum());
msg.setRelayCadPeriodicity(value);
break;
case 35:
var value = /** @type {number} */ (reader.readUint32());
msg.setRelayDefaultChannelIndex(value);
break;
case 36:
var value = /** @type {number} */ (reader.readUint32());
msg.setRelaySecondChannelFreq(value);
break;
case 37:
var value = /** @type {number} */ (reader.readUint32());
msg.setRelaySecondChannelDr(value);
break;
case 38:
var value = /** @type {!proto.api.SecondChAckOffset} */ (reader.readEnum());
msg.setRelaySecondChannelAckOffset(value);
break;
case 39:
var value = /** @type {!proto.api.RelayModeActivation} */ (reader.readEnum());
msg.setRelayEdActivationMode(value);
break;
case 40:
var value = /** @type {number} */ (reader.readUint32());
msg.setRelayEdSmartEnableLevel(value);
break;
case 41:
var value = /** @type {number} */ (reader.readUint32());
msg.setRelayEdBackOff(value);
break;
case 42:
var value = /** @type {number} */ (reader.readUint32());
msg.setRelayEdUplinkLimitBucketSize(value);
break;
case 43:
var value = /** @type {number} */ (reader.readUint32());
msg.setRelayEdUplinkLimitReloadRate(value);
break;
case 44:
var value = /** @type {number} */ (reader.readUint32());
msg.setRelayJoinReqLimitReloadRate(value);
break;
case 45:
var value = /** @type {number} */ (reader.readUint32());
msg.setRelayNotifyLimitReloadRate(value);
break;
case 46:
var value = /** @type {number} */ (reader.readUint32());
msg.setRelayGlobalUplinkLimitReloadRate(value);
break;
case 47:
var value = /** @type {number} */ (reader.readUint32());
msg.setRelayOverallLimitReloadRate(value);
break;
case 48:
var value = /** @type {number} */ (reader.readUint32());
msg.setRelayJoinReqLimitBucketSize(value);
break;
case 49:
var value = /** @type {number} */ (reader.readUint32());
msg.setRelayNotifyLimitBucketSize(value);
break;
case 50:
var value = /** @type {number} */ (reader.readUint32());
msg.setRelayGlobalUplinkLimitBucketSize(value);
break;
case 51:
var value = /** @type {number} */ (reader.readUint32());
msg.setRelayOverallLimitBucketSize(value);
break;
default:
reader.skipField();
break;
@ -751,6 +864,160 @@ proto.api.DeviceProfile.serializeBinaryToWriter = function(message, writer) {
f
);
}
f = message.getIsRelay();
if (f) {
writer.writeBool(
30,
f
);
}
f = message.getIsRelayEd();
if (f) {
writer.writeBool(
31,
f
);
}
f = message.getRelayEdRelayOnly();
if (f) {
writer.writeBool(
32,
f
);
}
f = message.getRelayEnabled();
if (f) {
writer.writeBool(
33,
f
);
}
f = message.getRelayCadPeriodicity();
if (f !== 0.0) {
writer.writeEnum(
34,
f
);
}
f = message.getRelayDefaultChannelIndex();
if (f !== 0) {
writer.writeUint32(
35,
f
);
}
f = message.getRelaySecondChannelFreq();
if (f !== 0) {
writer.writeUint32(
36,
f
);
}
f = message.getRelaySecondChannelDr();
if (f !== 0) {
writer.writeUint32(
37,
f
);
}
f = message.getRelaySecondChannelAckOffset();
if (f !== 0.0) {
writer.writeEnum(
38,
f
);
}
f = message.getRelayEdActivationMode();
if (f !== 0.0) {
writer.writeEnum(
39,
f
);
}
f = message.getRelayEdSmartEnableLevel();
if (f !== 0) {
writer.writeUint32(
40,
f
);
}
f = message.getRelayEdBackOff();
if (f !== 0) {
writer.writeUint32(
41,
f
);
}
f = message.getRelayEdUplinkLimitBucketSize();
if (f !== 0) {
writer.writeUint32(
42,
f
);
}
f = message.getRelayEdUplinkLimitReloadRate();
if (f !== 0) {
writer.writeUint32(
43,
f
);
}
f = message.getRelayJoinReqLimitReloadRate();
if (f !== 0) {
writer.writeUint32(
44,
f
);
}
f = message.getRelayNotifyLimitReloadRate();
if (f !== 0) {
writer.writeUint32(
45,
f
);
}
f = message.getRelayGlobalUplinkLimitReloadRate();
if (f !== 0) {
writer.writeUint32(
46,
f
);
}
f = message.getRelayOverallLimitReloadRate();
if (f !== 0) {
writer.writeUint32(
47,
f
);
}
f = message.getRelayJoinReqLimitBucketSize();
if (f !== 0) {
writer.writeUint32(
48,
f
);
}
f = message.getRelayNotifyLimitBucketSize();
if (f !== 0) {
writer.writeUint32(
49,
f
);
}
f = message.getRelayGlobalUplinkLimitBucketSize();
if (f !== 0) {
writer.writeUint32(
50,
f
);
}
f = message.getRelayOverallLimitBucketSize();
if (f !== 0) {
writer.writeUint32(
51,
f
);
}
};
@ -1284,6 +1551,402 @@ proto.api.DeviceProfile.prototype.setRegionConfigId = function(value) {
};
/**
* optional bool is_relay = 30;
* @return {boolean}
*/
proto.api.DeviceProfile.prototype.getIsRelay = function() {
return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 30, false));
};
/**
* @param {boolean} value
* @return {!proto.api.DeviceProfile} returns this
*/
proto.api.DeviceProfile.prototype.setIsRelay = function(value) {
return jspb.Message.setProto3BooleanField(this, 30, value);
};
/**
* optional bool is_relay_ed = 31;
* @return {boolean}
*/
proto.api.DeviceProfile.prototype.getIsRelayEd = function() {
return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 31, false));
};
/**
* @param {boolean} value
* @return {!proto.api.DeviceProfile} returns this
*/
proto.api.DeviceProfile.prototype.setIsRelayEd = function(value) {
return jspb.Message.setProto3BooleanField(this, 31, value);
};
/**
* optional bool relay_ed_relay_only = 32;
* @return {boolean}
*/
proto.api.DeviceProfile.prototype.getRelayEdRelayOnly = function() {
return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 32, false));
};
/**
* @param {boolean} value
* @return {!proto.api.DeviceProfile} returns this
*/
proto.api.DeviceProfile.prototype.setRelayEdRelayOnly = function(value) {
return jspb.Message.setProto3BooleanField(this, 32, value);
};
/**
* optional bool relay_enabled = 33;
* @return {boolean}
*/
proto.api.DeviceProfile.prototype.getRelayEnabled = function() {
return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 33, false));
};
/**
* @param {boolean} value
* @return {!proto.api.DeviceProfile} returns this
*/
proto.api.DeviceProfile.prototype.setRelayEnabled = function(value) {
return jspb.Message.setProto3BooleanField(this, 33, value);
};
/**
* optional CadPeriodicity relay_cad_periodicity = 34;
* @return {!proto.api.CadPeriodicity}
*/
proto.api.DeviceProfile.prototype.getRelayCadPeriodicity = function() {
return /** @type {!proto.api.CadPeriodicity} */ (jspb.Message.getFieldWithDefault(this, 34, 0));
};
/**
* @param {!proto.api.CadPeriodicity} value
* @return {!proto.api.DeviceProfile} returns this
*/
proto.api.DeviceProfile.prototype.setRelayCadPeriodicity = function(value) {
return jspb.Message.setProto3EnumField(this, 34, value);
};
/**
* optional uint32 relay_default_channel_index = 35;
* @return {number}
*/
proto.api.DeviceProfile.prototype.getRelayDefaultChannelIndex = function() {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 35, 0));
};
/**
* @param {number} value
* @return {!proto.api.DeviceProfile} returns this
*/
proto.api.DeviceProfile.prototype.setRelayDefaultChannelIndex = function(value) {
return jspb.Message.setProto3IntField(this, 35, value);
};
/**
* optional uint32 relay_second_channel_freq = 36;
* @return {number}
*/
proto.api.DeviceProfile.prototype.getRelaySecondChannelFreq = function() {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 36, 0));
};
/**
* @param {number} value
* @return {!proto.api.DeviceProfile} returns this
*/
proto.api.DeviceProfile.prototype.setRelaySecondChannelFreq = function(value) {
return jspb.Message.setProto3IntField(this, 36, value);
};
/**
* optional uint32 relay_second_channel_dr = 37;
* @return {number}
*/
proto.api.DeviceProfile.prototype.getRelaySecondChannelDr = function() {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 37, 0));
};
/**
* @param {number} value
* @return {!proto.api.DeviceProfile} returns this
*/
proto.api.DeviceProfile.prototype.setRelaySecondChannelDr = function(value) {
return jspb.Message.setProto3IntField(this, 37, value);
};
/**
* optional SecondChAckOffset relay_second_channel_ack_offset = 38;
* @return {!proto.api.SecondChAckOffset}
*/
proto.api.DeviceProfile.prototype.getRelaySecondChannelAckOffset = function() {
return /** @type {!proto.api.SecondChAckOffset} */ (jspb.Message.getFieldWithDefault(this, 38, 0));
};
/**
* @param {!proto.api.SecondChAckOffset} value
* @return {!proto.api.DeviceProfile} returns this
*/
proto.api.DeviceProfile.prototype.setRelaySecondChannelAckOffset = function(value) {
return jspb.Message.setProto3EnumField(this, 38, value);
};
/**
* optional RelayModeActivation relay_ed_activation_mode = 39;
* @return {!proto.api.RelayModeActivation}
*/
proto.api.DeviceProfile.prototype.getRelayEdActivationMode = function() {
return /** @type {!proto.api.RelayModeActivation} */ (jspb.Message.getFieldWithDefault(this, 39, 0));
};
/**
* @param {!proto.api.RelayModeActivation} value
* @return {!proto.api.DeviceProfile} returns this
*/
proto.api.DeviceProfile.prototype.setRelayEdActivationMode = function(value) {
return jspb.Message.setProto3EnumField(this, 39, value);
};
/**
* optional uint32 relay_ed_smart_enable_level = 40;
* @return {number}
*/
proto.api.DeviceProfile.prototype.getRelayEdSmartEnableLevel = function() {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 40, 0));
};
/**
* @param {number} value
* @return {!proto.api.DeviceProfile} returns this
*/
proto.api.DeviceProfile.prototype.setRelayEdSmartEnableLevel = function(value) {
return jspb.Message.setProto3IntField(this, 40, value);
};
/**
* optional uint32 relay_ed_back_off = 41;
* @return {number}
*/
proto.api.DeviceProfile.prototype.getRelayEdBackOff = function() {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 41, 0));
};
/**
* @param {number} value
* @return {!proto.api.DeviceProfile} returns this
*/
proto.api.DeviceProfile.prototype.setRelayEdBackOff = function(value) {
return jspb.Message.setProto3IntField(this, 41, value);
};
/**
* optional uint32 relay_ed_uplink_limit_bucket_size = 42;
* @return {number}
*/
proto.api.DeviceProfile.prototype.getRelayEdUplinkLimitBucketSize = function() {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 42, 0));
};
/**
* @param {number} value
* @return {!proto.api.DeviceProfile} returns this
*/
proto.api.DeviceProfile.prototype.setRelayEdUplinkLimitBucketSize = function(value) {
return jspb.Message.setProto3IntField(this, 42, value);
};
/**
* optional uint32 relay_ed_uplink_limit_reload_rate = 43;
* @return {number}
*/
proto.api.DeviceProfile.prototype.getRelayEdUplinkLimitReloadRate = function() {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 43, 0));
};
/**
* @param {number} value
* @return {!proto.api.DeviceProfile} returns this
*/
proto.api.DeviceProfile.prototype.setRelayEdUplinkLimitReloadRate = function(value) {
return jspb.Message.setProto3IntField(this, 43, value);
};
/**
* optional uint32 relay_join_req_limit_reload_rate = 44;
* @return {number}
*/
proto.api.DeviceProfile.prototype.getRelayJoinReqLimitReloadRate = function() {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 44, 0));
};
/**
* @param {number} value
* @return {!proto.api.DeviceProfile} returns this
*/
proto.api.DeviceProfile.prototype.setRelayJoinReqLimitReloadRate = function(value) {
return jspb.Message.setProto3IntField(this, 44, value);
};
/**
* optional uint32 relay_notify_limit_reload_rate = 45;
* @return {number}
*/
proto.api.DeviceProfile.prototype.getRelayNotifyLimitReloadRate = function() {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 45, 0));
};
/**
* @param {number} value
* @return {!proto.api.DeviceProfile} returns this
*/
proto.api.DeviceProfile.prototype.setRelayNotifyLimitReloadRate = function(value) {
return jspb.Message.setProto3IntField(this, 45, value);
};
/**
* optional uint32 relay_global_uplink_limit_reload_rate = 46;
* @return {number}
*/
proto.api.DeviceProfile.prototype.getRelayGlobalUplinkLimitReloadRate = function() {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 46, 0));
};
/**
* @param {number} value
* @return {!proto.api.DeviceProfile} returns this
*/
proto.api.DeviceProfile.prototype.setRelayGlobalUplinkLimitReloadRate = function(value) {
return jspb.Message.setProto3IntField(this, 46, value);
};
/**
* optional uint32 relay_overall_limit_reload_rate = 47;
* @return {number}
*/
proto.api.DeviceProfile.prototype.getRelayOverallLimitReloadRate = function() {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 47, 0));
};
/**
* @param {number} value
* @return {!proto.api.DeviceProfile} returns this
*/
proto.api.DeviceProfile.prototype.setRelayOverallLimitReloadRate = function(value) {
return jspb.Message.setProto3IntField(this, 47, value);
};
/**
* optional uint32 relay_join_req_limit_bucket_size = 48;
* @return {number}
*/
proto.api.DeviceProfile.prototype.getRelayJoinReqLimitBucketSize = function() {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 48, 0));
};
/**
* @param {number} value
* @return {!proto.api.DeviceProfile} returns this
*/
proto.api.DeviceProfile.prototype.setRelayJoinReqLimitBucketSize = function(value) {
return jspb.Message.setProto3IntField(this, 48, value);
};
/**
* optional uint32 relay_notify_limit_bucket_size = 49;
* @return {number}
*/
proto.api.DeviceProfile.prototype.getRelayNotifyLimitBucketSize = function() {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 49, 0));
};
/**
* @param {number} value
* @return {!proto.api.DeviceProfile} returns this
*/
proto.api.DeviceProfile.prototype.setRelayNotifyLimitBucketSize = function(value) {
return jspb.Message.setProto3IntField(this, 49, value);
};
/**
* optional uint32 relay_global_uplink_limit_bucket_size = 50;
* @return {number}
*/
proto.api.DeviceProfile.prototype.getRelayGlobalUplinkLimitBucketSize = function() {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 50, 0));
};
/**
* @param {number} value
* @return {!proto.api.DeviceProfile} returns this
*/
proto.api.DeviceProfile.prototype.setRelayGlobalUplinkLimitBucketSize = function(value) {
return jspb.Message.setProto3IntField(this, 50, value);
};
/**
* optional uint32 relay_overall_limit_bucket_size = 51;
* @return {number}
*/
proto.api.DeviceProfile.prototype.getRelayOverallLimitBucketSize = function() {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 51, 0));
};
/**
* @param {number} value
* @return {!proto.api.DeviceProfile} returns this
*/
proto.api.DeviceProfile.prototype.setRelayOverallLimitBucketSize = function(value) {
return jspb.Message.setProto3IntField(this, 51, value);
};
@ -3611,4 +4274,38 @@ proto.api.MeasurementKind = {
STRING: 4
};
/**
* @enum {number}
*/
proto.api.CadPeriodicity = {
SEC_1: 0,
MS_500: 1,
MS_250: 2,
MS_100: 3,
MS_50: 4,
MS_20: 5
};
/**
* @enum {number}
*/
proto.api.SecondChAckOffset = {
KHZ_0: 0,
KHZ_200: 1,
KHZ_400: 2,
KHZ_800: 3,
KHZ_1600: 4,
KHZ_3200: 5
};
/**
* @enum {number}
*/
proto.api.RelayModeActivation = {
DISABLE_RELAY_MODE: 0,
ENABLE_RELAY_MODE: 1,
DYNAMIC: 2,
END_DEVICE_CONTROLLED: 3
};
goog.object.extend(exports, proto.api);

20
api/grpc-web/api/frame_log_pb.d.ts vendored
View File

@ -35,8 +35,11 @@ export class UplinkFrameLog extends jspb.Message {
hasTime(): boolean;
clearTime(): UplinkFrameLog;
getPlaintextMacCommands(): boolean;
setPlaintextMacCommands(value: boolean): UplinkFrameLog;
getPlaintextFOpts(): boolean;
setPlaintextFOpts(value: boolean): UplinkFrameLog;
getPlaintextFrmPayload(): boolean;
setPlaintextFrmPayload(value: boolean): UplinkFrameLog;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): UplinkFrameLog.AsObject;
@ -55,7 +58,8 @@ export namespace UplinkFrameLog {
devAddr: string,
devEui: string,
time?: google_protobuf_timestamp_pb.Timestamp.AsObject,
plaintextMacCommands: boolean,
plaintextFOpts: boolean,
plaintextFrmPayload: boolean,
}
}
@ -90,8 +94,11 @@ export class DownlinkFrameLog extends jspb.Message {
getDevEui(): string;
setDevEui(value: string): DownlinkFrameLog;
getPlaintextMacCommands(): boolean;
setPlaintextMacCommands(value: boolean): DownlinkFrameLog;
getPlaintextFOpts(): boolean;
setPlaintextFOpts(value: boolean): DownlinkFrameLog;
getPlaintextFrmPayload(): boolean;
setPlaintextFrmPayload(value: boolean): DownlinkFrameLog;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): DownlinkFrameLog.AsObject;
@ -111,7 +118,8 @@ export namespace DownlinkFrameLog {
mType: common_common_pb.MType,
devAddr: string,
devEui: string,
plaintextMacCommands: boolean,
plaintextFOpts: boolean,
plaintextFrmPayload: boolean,
}
}

84
api/grpc-web/api/frame_log_pb.js vendored
View File

@ -109,7 +109,8 @@ proto.api.UplinkFrameLog.toObject = function(includeInstance, msg) {
devAddr: jspb.Message.getFieldWithDefault(msg, 5, ""),
devEui: jspb.Message.getFieldWithDefault(msg, 6, ""),
time: (f = msg.getTime()) && google_protobuf_timestamp_pb.Timestamp.toObject(includeInstance, f),
plaintextMacCommands: jspb.Message.getBooleanFieldWithDefault(msg, 8, false)
plaintextFOpts: jspb.Message.getBooleanFieldWithDefault(msg, 8, false),
plaintextFrmPayload: jspb.Message.getBooleanFieldWithDefault(msg, 9, false)
};
if (includeInstance) {
@ -179,7 +180,11 @@ proto.api.UplinkFrameLog.deserializeBinaryFromReader = function(msg, reader) {
break;
case 8:
var value = /** @type {boolean} */ (reader.readBool());
msg.setPlaintextMacCommands(value);
msg.setPlaintextFOpts(value);
break;
case 9:
var value = /** @type {boolean} */ (reader.readBool());
msg.setPlaintextFrmPayload(value);
break;
default:
reader.skipField();
@ -262,13 +267,20 @@ proto.api.UplinkFrameLog.serializeBinaryToWriter = function(message, writer) {
google_protobuf_timestamp_pb.Timestamp.serializeBinaryToWriter
);
}
f = message.getPlaintextMacCommands();
f = message.getPlaintextFOpts();
if (f) {
writer.writeBool(
8,
f
);
}
f = message.getPlaintextFrmPayload();
if (f) {
writer.writeBool(
9,
f
);
}
};
@ -481,10 +493,10 @@ proto.api.UplinkFrameLog.prototype.hasTime = function() {
/**
* optional bool plaintext_mac_commands = 8;
* optional bool plaintext_f_opts = 8;
* @return {boolean}
*/
proto.api.UplinkFrameLog.prototype.getPlaintextMacCommands = function() {
proto.api.UplinkFrameLog.prototype.getPlaintextFOpts = function() {
return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 8, false));
};
@ -493,11 +505,29 @@ proto.api.UplinkFrameLog.prototype.getPlaintextMacCommands = function() {
* @param {boolean} value
* @return {!proto.api.UplinkFrameLog} returns this
*/
proto.api.UplinkFrameLog.prototype.setPlaintextMacCommands = function(value) {
proto.api.UplinkFrameLog.prototype.setPlaintextFOpts = function(value) {
return jspb.Message.setProto3BooleanField(this, 8, value);
};
/**
* optional bool plaintext_frm_payload = 9;
* @return {boolean}
*/
proto.api.UplinkFrameLog.prototype.getPlaintextFrmPayload = function() {
return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 9, false));
};
/**
* @param {boolean} value
* @return {!proto.api.UplinkFrameLog} returns this
*/
proto.api.UplinkFrameLog.prototype.setPlaintextFrmPayload = function(value) {
return jspb.Message.setProto3BooleanField(this, 9, value);
};
@ -538,7 +568,8 @@ proto.api.DownlinkFrameLog.toObject = function(includeInstance, msg) {
mType: jspb.Message.getFieldWithDefault(msg, 6, 0),
devAddr: jspb.Message.getFieldWithDefault(msg, 7, ""),
devEui: jspb.Message.getFieldWithDefault(msg, 8, ""),
plaintextMacCommands: jspb.Message.getBooleanFieldWithDefault(msg, 9, false)
plaintextFOpts: jspb.Message.getBooleanFieldWithDefault(msg, 9, false),
plaintextFrmPayload: jspb.Message.getBooleanFieldWithDefault(msg, 10, false)
};
if (includeInstance) {
@ -611,7 +642,11 @@ proto.api.DownlinkFrameLog.deserializeBinaryFromReader = function(msg, reader) {
break;
case 9:
var value = /** @type {boolean} */ (reader.readBool());
msg.setPlaintextMacCommands(value);
msg.setPlaintextFOpts(value);
break;
case 10:
var value = /** @type {boolean} */ (reader.readBool());
msg.setPlaintextFrmPayload(value);
break;
default:
reader.skipField();
@ -700,13 +735,20 @@ proto.api.DownlinkFrameLog.serializeBinaryToWriter = function(message, writer) {
f
);
}
f = message.getPlaintextMacCommands();
f = message.getPlaintextFOpts();
if (f) {
writer.writeBool(
9,
f
);
}
f = message.getPlaintextFrmPayload();
if (f) {
writer.writeBool(
10,
f
);
}
};
@ -917,10 +959,10 @@ proto.api.DownlinkFrameLog.prototype.setDevEui = function(value) {
/**
* optional bool plaintext_mac_commands = 9;
* optional bool plaintext_f_opts = 9;
* @return {boolean}
*/
proto.api.DownlinkFrameLog.prototype.getPlaintextMacCommands = function() {
proto.api.DownlinkFrameLog.prototype.getPlaintextFOpts = function() {
return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 9, false));
};
@ -929,9 +971,27 @@ proto.api.DownlinkFrameLog.prototype.getPlaintextMacCommands = function() {
* @param {boolean} value
* @return {!proto.api.DownlinkFrameLog} returns this
*/
proto.api.DownlinkFrameLog.prototype.setPlaintextMacCommands = function(value) {
proto.api.DownlinkFrameLog.prototype.setPlaintextFOpts = function(value) {
return jspb.Message.setProto3BooleanField(this, 9, value);
};
/**
* optional bool plaintext_frm_payload = 10;
* @return {boolean}
*/
proto.api.DownlinkFrameLog.prototype.getPlaintextFrmPayload = function() {
return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 10, false));
};
/**
* @param {boolean} value
* @return {!proto.api.DownlinkFrameLog} returns this
*/
proto.api.DownlinkFrameLog.prototype.setPlaintextFrmPayload = function(value) {
return jspb.Message.setProto3BooleanField(this, 10, value);
};
goog.object.extend(exports, proto.api);

68
api/grpc-web/api/relay_grpc_web_pb.d.ts vendored Normal file
View File

@ -0,0 +1,68 @@
import * as grpcWeb from 'grpc-web';
import * as api_relay_pb from '../api/relay_pb';
import * as google_protobuf_empty_pb from 'google-protobuf/google/protobuf/empty_pb';
export class RelayServiceClient {
constructor (hostname: string,
credentials?: null | { [index: string]: string; },
options?: null | { [index: string]: any; });
list(
request: api_relay_pb.ListRelaysRequest,
metadata: grpcWeb.Metadata | undefined,
callback: (err: grpcWeb.RpcError,
response: api_relay_pb.ListRelaysResponse) => void
): grpcWeb.ClientReadableStream<api_relay_pb.ListRelaysResponse>;
addDevice(
request: api_relay_pb.AddRelayDeviceRequest,
metadata: grpcWeb.Metadata | undefined,
callback: (err: grpcWeb.RpcError,
response: google_protobuf_empty_pb.Empty) => void
): grpcWeb.ClientReadableStream<google_protobuf_empty_pb.Empty>;
removeDevice(
request: api_relay_pb.RemoveRelayDeviceRequest,
metadata: grpcWeb.Metadata | undefined,
callback: (err: grpcWeb.RpcError,
response: google_protobuf_empty_pb.Empty) => void
): grpcWeb.ClientReadableStream<google_protobuf_empty_pb.Empty>;
listDevices(
request: api_relay_pb.ListRelayDevicesRequest,
metadata: grpcWeb.Metadata | undefined,
callback: (err: grpcWeb.RpcError,
response: api_relay_pb.ListRelayDevicesResponse) => void
): grpcWeb.ClientReadableStream<api_relay_pb.ListRelayDevicesResponse>;
}
export class RelayServicePromiseClient {
constructor (hostname: string,
credentials?: null | { [index: string]: string; },
options?: null | { [index: string]: any; });
list(
request: api_relay_pb.ListRelaysRequest,
metadata?: grpcWeb.Metadata
): Promise<api_relay_pb.ListRelaysResponse>;
addDevice(
request: api_relay_pb.AddRelayDeviceRequest,
metadata?: grpcWeb.Metadata
): Promise<google_protobuf_empty_pb.Empty>;
removeDevice(
request: api_relay_pb.RemoveRelayDeviceRequest,
metadata?: grpcWeb.Metadata
): Promise<google_protobuf_empty_pb.Empty>;
listDevices(
request: api_relay_pb.ListRelayDevicesRequest,
metadata?: grpcWeb.Metadata
): Promise<api_relay_pb.ListRelayDevicesResponse>;
}

328
api/grpc-web/api/relay_grpc_web_pb.js vendored Normal file
View File

@ -0,0 +1,328 @@
/**
* @fileoverview gRPC-Web generated client stub for api
* @enhanceable
* @public
*/
// Code generated by protoc-gen-grpc-web. DO NOT EDIT.
// versions:
// protoc-gen-grpc-web v1.4.2
// protoc v3.12.4
// source: api/relay.proto
/* eslint-disable */
// @ts-nocheck
const grpc = {};
grpc.web = require('grpc-web');
var google_api_annotations_pb = require('../google/api/annotations_pb.js')
var google_protobuf_timestamp_pb = require('google-protobuf/google/protobuf/timestamp_pb.js')
var google_protobuf_empty_pb = require('google-protobuf/google/protobuf/empty_pb.js')
const proto = {};
proto.api = require('./relay_pb.js');
/**
* @param {string} hostname
* @param {?Object} credentials
* @param {?grpc.web.ClientOptions} options
* @constructor
* @struct
* @final
*/
proto.api.RelayServiceClient =
function(hostname, credentials, options) {
if (!options) options = {};
options.format = 'text';
/**
* @private @const {!grpc.web.GrpcWebClientBase} The client
*/
this.client_ = new grpc.web.GrpcWebClientBase(options);
/**
* @private @const {string} The hostname
*/
this.hostname_ = hostname.replace(/\/+$/, '');
};
/**
* @param {string} hostname
* @param {?Object} credentials
* @param {?grpc.web.ClientOptions} options
* @constructor
* @struct
* @final
*/
proto.api.RelayServicePromiseClient =
function(hostname, credentials, options) {
if (!options) options = {};
options.format = 'text';
/**
* @private @const {!grpc.web.GrpcWebClientBase} The client
*/
this.client_ = new grpc.web.GrpcWebClientBase(options);
/**
* @private @const {string} The hostname
*/
this.hostname_ = hostname.replace(/\/+$/, '');
};
/**
* @const
* @type {!grpc.web.MethodDescriptor<
* !proto.api.ListRelaysRequest,
* !proto.api.ListRelaysResponse>}
*/
const methodDescriptor_RelayService_List = new grpc.web.MethodDescriptor(
'/api.RelayService/List',
grpc.web.MethodType.UNARY,
proto.api.ListRelaysRequest,
proto.api.ListRelaysResponse,
/**
* @param {!proto.api.ListRelaysRequest} request
* @return {!Uint8Array}
*/
function(request) {
return request.serializeBinary();
},
proto.api.ListRelaysResponse.deserializeBinary
);
/**
* @param {!proto.api.ListRelaysRequest} request The
* request proto
* @param {?Object<string, string>} metadata User defined
* call metadata
* @param {function(?grpc.web.RpcError, ?proto.api.ListRelaysResponse)}
* callback The callback function(error, response)
* @return {!grpc.web.ClientReadableStream<!proto.api.ListRelaysResponse>|undefined}
* The XHR Node Readable Stream
*/
proto.api.RelayServiceClient.prototype.list =
function(request, metadata, callback) {
return this.client_.rpcCall(this.hostname_ +
'/api.RelayService/List',
request,
metadata || {},
methodDescriptor_RelayService_List,
callback);
};
/**
* @param {!proto.api.ListRelaysRequest} request The
* request proto
* @param {?Object<string, string>=} metadata User defined
* call metadata
* @return {!Promise<!proto.api.ListRelaysResponse>}
* Promise that resolves to the response
*/
proto.api.RelayServicePromiseClient.prototype.list =
function(request, metadata) {
return this.client_.unaryCall(this.hostname_ +
'/api.RelayService/List',
request,
metadata || {},
methodDescriptor_RelayService_List);
};
/**
* @const
* @type {!grpc.web.MethodDescriptor<
* !proto.api.AddRelayDeviceRequest,
* !proto.google.protobuf.Empty>}
*/
const methodDescriptor_RelayService_AddDevice = new grpc.web.MethodDescriptor(
'/api.RelayService/AddDevice',
grpc.web.MethodType.UNARY,
proto.api.AddRelayDeviceRequest,
google_protobuf_empty_pb.Empty,
/**
* @param {!proto.api.AddRelayDeviceRequest} request
* @return {!Uint8Array}
*/
function(request) {
return request.serializeBinary();
},
google_protobuf_empty_pb.Empty.deserializeBinary
);
/**
* @param {!proto.api.AddRelayDeviceRequest} request The
* request proto
* @param {?Object<string, string>} metadata User defined
* call metadata
* @param {function(?grpc.web.RpcError, ?proto.google.protobuf.Empty)}
* callback The callback function(error, response)
* @return {!grpc.web.ClientReadableStream<!proto.google.protobuf.Empty>|undefined}
* The XHR Node Readable Stream
*/
proto.api.RelayServiceClient.prototype.addDevice =
function(request, metadata, callback) {
return this.client_.rpcCall(this.hostname_ +
'/api.RelayService/AddDevice',
request,
metadata || {},
methodDescriptor_RelayService_AddDevice,
callback);
};
/**
* @param {!proto.api.AddRelayDeviceRequest} request The
* request proto
* @param {?Object<string, string>=} metadata User defined
* call metadata
* @return {!Promise<!proto.google.protobuf.Empty>}
* Promise that resolves to the response
*/
proto.api.RelayServicePromiseClient.prototype.addDevice =
function(request, metadata) {
return this.client_.unaryCall(this.hostname_ +
'/api.RelayService/AddDevice',
request,
metadata || {},
methodDescriptor_RelayService_AddDevice);
};
/**
* @const
* @type {!grpc.web.MethodDescriptor<
* !proto.api.RemoveRelayDeviceRequest,
* !proto.google.protobuf.Empty>}
*/
const methodDescriptor_RelayService_RemoveDevice = new grpc.web.MethodDescriptor(
'/api.RelayService/RemoveDevice',
grpc.web.MethodType.UNARY,
proto.api.RemoveRelayDeviceRequest,
google_protobuf_empty_pb.Empty,
/**
* @param {!proto.api.RemoveRelayDeviceRequest} request
* @return {!Uint8Array}
*/
function(request) {
return request.serializeBinary();
},
google_protobuf_empty_pb.Empty.deserializeBinary
);
/**
* @param {!proto.api.RemoveRelayDeviceRequest} request The
* request proto
* @param {?Object<string, string>} metadata User defined
* call metadata
* @param {function(?grpc.web.RpcError, ?proto.google.protobuf.Empty)}
* callback The callback function(error, response)
* @return {!grpc.web.ClientReadableStream<!proto.google.protobuf.Empty>|undefined}
* The XHR Node Readable Stream
*/
proto.api.RelayServiceClient.prototype.removeDevice =
function(request, metadata, callback) {
return this.client_.rpcCall(this.hostname_ +
'/api.RelayService/RemoveDevice',
request,
metadata || {},
methodDescriptor_RelayService_RemoveDevice,
callback);
};
/**
* @param {!proto.api.RemoveRelayDeviceRequest} request The
* request proto
* @param {?Object<string, string>=} metadata User defined
* call metadata
* @return {!Promise<!proto.google.protobuf.Empty>}
* Promise that resolves to the response
*/
proto.api.RelayServicePromiseClient.prototype.removeDevice =
function(request, metadata) {
return this.client_.unaryCall(this.hostname_ +
'/api.RelayService/RemoveDevice',
request,
metadata || {},
methodDescriptor_RelayService_RemoveDevice);
};
/**
* @const
* @type {!grpc.web.MethodDescriptor<
* !proto.api.ListRelayDevicesRequest,
* !proto.api.ListRelayDevicesResponse>}
*/
const methodDescriptor_RelayService_ListDevices = new grpc.web.MethodDescriptor(
'/api.RelayService/ListDevices',
grpc.web.MethodType.UNARY,
proto.api.ListRelayDevicesRequest,
proto.api.ListRelayDevicesResponse,
/**
* @param {!proto.api.ListRelayDevicesRequest} request
* @return {!Uint8Array}
*/
function(request) {
return request.serializeBinary();
},
proto.api.ListRelayDevicesResponse.deserializeBinary
);
/**
* @param {!proto.api.ListRelayDevicesRequest} request The
* request proto
* @param {?Object<string, string>} metadata User defined
* call metadata
* @param {function(?grpc.web.RpcError, ?proto.api.ListRelayDevicesResponse)}
* callback The callback function(error, response)
* @return {!grpc.web.ClientReadableStream<!proto.api.ListRelayDevicesResponse>|undefined}
* The XHR Node Readable Stream
*/
proto.api.RelayServiceClient.prototype.listDevices =
function(request, metadata, callback) {
return this.client_.rpcCall(this.hostname_ +
'/api.RelayService/ListDevices',
request,
metadata || {},
methodDescriptor_RelayService_ListDevices,
callback);
};
/**
* @param {!proto.api.ListRelayDevicesRequest} request The
* request proto
* @param {?Object<string, string>=} metadata User defined
* call metadata
* @return {!Promise<!proto.api.ListRelayDevicesResponse>}
* Promise that resolves to the response
*/
proto.api.RelayServicePromiseClient.prototype.listDevices =
function(request, metadata) {
return this.client_.unaryCall(this.hostname_ +
'/api.RelayService/ListDevices',
request,
metadata || {},
methodDescriptor_RelayService_ListDevices);
};
module.exports = proto.api;

201
api/grpc-web/api/relay_pb.d.ts vendored Normal file
View File

@ -0,0 +1,201 @@
import * as jspb from 'google-protobuf'
import * as google_api_annotations_pb from '../google/api/annotations_pb';
import * as google_protobuf_timestamp_pb from 'google-protobuf/google/protobuf/timestamp_pb';
import * as google_protobuf_empty_pb from 'google-protobuf/google/protobuf/empty_pb';
export class RelayListItem extends jspb.Message {
getDevEui(): string;
setDevEui(value: string): RelayListItem;
getName(): string;
setName(value: string): RelayListItem;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): RelayListItem.AsObject;
static toObject(includeInstance: boolean, msg: RelayListItem): RelayListItem.AsObject;
static serializeBinaryToWriter(message: RelayListItem, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): RelayListItem;
static deserializeBinaryFromReader(message: RelayListItem, reader: jspb.BinaryReader): RelayListItem;
}
export namespace RelayListItem {
export type AsObject = {
devEui: string,
name: string,
}
}
export class ListRelaysRequest extends jspb.Message {
getLimit(): number;
setLimit(value: number): ListRelaysRequest;
getOffset(): number;
setOffset(value: number): ListRelaysRequest;
getApplicationId(): string;
setApplicationId(value: string): ListRelaysRequest;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ListRelaysRequest.AsObject;
static toObject(includeInstance: boolean, msg: ListRelaysRequest): ListRelaysRequest.AsObject;
static serializeBinaryToWriter(message: ListRelaysRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ListRelaysRequest;
static deserializeBinaryFromReader(message: ListRelaysRequest, reader: jspb.BinaryReader): ListRelaysRequest;
}
export namespace ListRelaysRequest {
export type AsObject = {
limit: number,
offset: number,
applicationId: string,
}
}
export class ListRelaysResponse extends jspb.Message {
getTotalCount(): number;
setTotalCount(value: number): ListRelaysResponse;
getResultList(): Array<RelayListItem>;
setResultList(value: Array<RelayListItem>): ListRelaysResponse;
clearResultList(): ListRelaysResponse;
addResult(value?: RelayListItem, index?: number): RelayListItem;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ListRelaysResponse.AsObject;
static toObject(includeInstance: boolean, msg: ListRelaysResponse): ListRelaysResponse.AsObject;
static serializeBinaryToWriter(message: ListRelaysResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ListRelaysResponse;
static deserializeBinaryFromReader(message: ListRelaysResponse, reader: jspb.BinaryReader): ListRelaysResponse;
}
export namespace ListRelaysResponse {
export type AsObject = {
totalCount: number,
resultList: Array<RelayListItem.AsObject>,
}
}
export class AddRelayDeviceRequest extends jspb.Message {
getRelayDevEui(): string;
setRelayDevEui(value: string): AddRelayDeviceRequest;
getDeviceDevEui(): string;
setDeviceDevEui(value: string): AddRelayDeviceRequest;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): AddRelayDeviceRequest.AsObject;
static toObject(includeInstance: boolean, msg: AddRelayDeviceRequest): AddRelayDeviceRequest.AsObject;
static serializeBinaryToWriter(message: AddRelayDeviceRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): AddRelayDeviceRequest;
static deserializeBinaryFromReader(message: AddRelayDeviceRequest, reader: jspb.BinaryReader): AddRelayDeviceRequest;
}
export namespace AddRelayDeviceRequest {
export type AsObject = {
relayDevEui: string,
deviceDevEui: string,
}
}
export class RemoveRelayDeviceRequest extends jspb.Message {
getRelayDevEui(): string;
setRelayDevEui(value: string): RemoveRelayDeviceRequest;
getDeviceDevEui(): string;
setDeviceDevEui(value: string): RemoveRelayDeviceRequest;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): RemoveRelayDeviceRequest.AsObject;
static toObject(includeInstance: boolean, msg: RemoveRelayDeviceRequest): RemoveRelayDeviceRequest.AsObject;
static serializeBinaryToWriter(message: RemoveRelayDeviceRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): RemoveRelayDeviceRequest;
static deserializeBinaryFromReader(message: RemoveRelayDeviceRequest, reader: jspb.BinaryReader): RemoveRelayDeviceRequest;
}
export namespace RemoveRelayDeviceRequest {
export type AsObject = {
relayDevEui: string,
deviceDevEui: string,
}
}
export class ListRelayDevicesRequest extends jspb.Message {
getLimit(): number;
setLimit(value: number): ListRelayDevicesRequest;
getOffset(): number;
setOffset(value: number): ListRelayDevicesRequest;
getRelayDevEui(): string;
setRelayDevEui(value: string): ListRelayDevicesRequest;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ListRelayDevicesRequest.AsObject;
static toObject(includeInstance: boolean, msg: ListRelayDevicesRequest): ListRelayDevicesRequest.AsObject;
static serializeBinaryToWriter(message: ListRelayDevicesRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ListRelayDevicesRequest;
static deserializeBinaryFromReader(message: ListRelayDevicesRequest, reader: jspb.BinaryReader): ListRelayDevicesRequest;
}
export namespace ListRelayDevicesRequest {
export type AsObject = {
limit: number,
offset: number,
relayDevEui: string,
}
}
export class RelayDeviceListItem extends jspb.Message {
getDevEui(): string;
setDevEui(value: string): RelayDeviceListItem;
getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): RelayDeviceListItem;
hasCreatedAt(): boolean;
clearCreatedAt(): RelayDeviceListItem;
getName(): string;
setName(value: string): RelayDeviceListItem;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): RelayDeviceListItem.AsObject;
static toObject(includeInstance: boolean, msg: RelayDeviceListItem): RelayDeviceListItem.AsObject;
static serializeBinaryToWriter(message: RelayDeviceListItem, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): RelayDeviceListItem;
static deserializeBinaryFromReader(message: RelayDeviceListItem, reader: jspb.BinaryReader): RelayDeviceListItem;
}
export namespace RelayDeviceListItem {
export type AsObject = {
devEui: string,
createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
name: string,
}
}
export class ListRelayDevicesResponse extends jspb.Message {
getTotalCount(): number;
setTotalCount(value: number): ListRelayDevicesResponse;
getResultList(): Array<RelayDeviceListItem>;
setResultList(value: Array<RelayDeviceListItem>): ListRelayDevicesResponse;
clearResultList(): ListRelayDevicesResponse;
addResult(value?: RelayDeviceListItem, index?: number): RelayDeviceListItem;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ListRelayDevicesResponse.AsObject;
static toObject(includeInstance: boolean, msg: ListRelayDevicesResponse): ListRelayDevicesResponse.AsObject;
static serializeBinaryToWriter(message: ListRelayDevicesResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ListRelayDevicesResponse;
static deserializeBinaryFromReader(message: ListRelayDevicesResponse, reader: jspb.BinaryReader): ListRelayDevicesResponse;
}
export namespace ListRelayDevicesResponse {
export type AsObject = {
totalCount: number,
resultList: Array<RelayDeviceListItem.AsObject>,
}
}

1648
api/grpc-web/api/relay_pb.js vendored Normal file
View File

File diff suppressed because it is too large Load Diff