@corvina/device-client 1.0.10

package/CHANGELOG.md

@@ -0,0 +1 @@
+RELEASE 1.0.0

package/CONTRIBUTING.md

@@ -0,0 +1,31 @@
+# Contributing
+
+1. [Fork it](https://help.github.com/articles/fork-a-repo/)
+2. Install dependencies (`npm install`)
+3. Create your feature branch (`git checkout -b my-new-feature`)
+4. Commit your changes (`git commit -am 'Added some feature'`)
+5. Test your changes (`npm test`)
+6. Push to the branch (`git push origin my-new-feature`)
+7. [Create new Pull Request](https://help.github.com/articles/creating-a-pull-request/)
+
+## Testing
+
+We use [Jest](https://github.com/facebook/jest) to write tests. Run our test suite with this command:
+
+```
+npm test
+```
+
+## Code Style
+
+We use [Prettier](https://prettier.io/) and tslint to maintain code style and best practices.
+Please make sure your PR adheres to the guides by running:
+
+```
+npm run format
+```
+
+and
+```
+npm run lint
+```

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Arrigo Zanette
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,138 @@
+<h1 align="center">Corvina Device SDK</h1>
+
+## Installation
+
+Install the dependency:
+
+```shell
+yarn install @corvina/device-client
+```
+
+Run the device using the given runner:
+
+```ts
+import 'dotenv/config'
+import { DeviceRunnerService, DeviceService } from '@corvina/device-client';
+
+const devRunner = new DeviceRunnerService(new DeviceService());
+
+devRunner.run();
+```
+
+The `DeviceRunnerService` is responsible for translating the environment configuration to the JSON configuration to be used to init the class `DeviceService`.
+
+### Usage in a [Nestjs](https://nestjs.com) application
+
+In your app module, import the device client module:
+
+```ts
+import { DeviceClientModule } from '@corvina/device-client/device.module';
+
+@Module({
+  imports: [DeviceClientModule],
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule {}
+```
+
+In your `main.ts` you can start the device using the `DeviceRunner` service.
+This service reads the configuration from a `.env` file.
+
+```ts
+import { DeviceRunnerService } from '@corvina/device-client';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  await app.listen(3000);
+
+  app.get(DeviceRunnerService).run();
+}
+```
+
+### Sending data
+
+> The actual sending occurs according to the configuration received from the cloud. Posting a tag not configured from the cloud will result in an error.
+
+In order to send data the `DeviceClient` class exposes the `post` method.
+The method allow to post a list of data points.
+
+A data point is defined by:
+* a `tagName`, representing the device identifier of the data point
+* a `timestamp`, representing the UTC timestamp the value was originate
+* a `value`
+
+The `post` method accepts further options:
+* `qos`, the MQTT QoS required
+* `cb`, a function callback to catch sending errors or confirmations 
+* `forceImmediateSend`, to bypass the publish policies configured from the cloud and just send the data immediately
+* `recurseNotifyOnlyWholeObject`, when posting a full JSON, just post the full object not every single path
+
+#### Simulation
+
+The device can be set up using environment variables to simulate data sending.
+
+1. set the available tags to simulate (the list will also be published to the cloud):
+  
+  ```
+    AVAILABLE_TAGS=[{"name":"Tag1","type":"integer"},{"name":"Tag2","type":"integer"},{"name":"Tag3","type":"integer"},{"name":"PositionNow","type":"integer"},{"name":"InputTag","type":"integer"}]
+  ```
+2. enable simulation:
+  ```
+    SIMULATE_TAGS=1
+  ```
+
+The same can be done for alarms:
+
+1. set up the alarms to simulate:
+
+```
+  AVAILABLE_ALARMS=[{"name":"Alarm10","severity":1,"source":"Tag1","desc":{"en":"Tag above normal : [Tag1]"},"ack_required":true,"reset_required":true,"simulation":{"f":"{ return Math.random() > 0.5 }"}}]
+```
+2. enable simulation:
+  ```
+    SIMULATE_ALARMS=1
+  ```
+
+
+
+
+
+### Receiving data
+
+
+> In order to receive data on a tag the tag must be configured writable in the cloud mapping 
+
+When data is written from the cloud a `write` event is emitted and can be used to handle the write request.
+
+The event will report an object containing:
+*  `modelPath`: the written model path
+* `v`: the written value
+
+For example:
+
+```
+    app.get(DeviceService).on("write", (event) => {
+        console.log("Write event received", event);
+    });
+```
+
+## Environment variables
+
+See [envs.md](envs.md) for a detailed description of environment variables.
+
+<!-- ## Change Log
+
+See [Changelog](CHANGELOG.md) for more information.
+
+## Contributing
+
+Contributions welcome! See [Contributing](CONTRIBUTING.md). -->
+
+## Author
+
+**Arrigo Zanette**
+
+## License
+
+Licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/dist/common/types.d.ts

@@ -0,0 +1,89 @@
+import { Int32, Long, Binary } from "bson";
+export declare enum NoiseSimulationType {
+    ABSOLUTE = "abs",
+    PERCENT = "%"
+}
+export interface NoiseSimulationProperties {
+    type: NoiseSimulationType;
+    amplitude: number;
+}
+export interface NullableSimulationStateMachine {
+    nullifying: boolean;
+    start: number;
+    duration: number;
+}
+export interface NullableSimulationProperties {
+    probability: number;
+    dt_min: number;
+    dt_max: number;
+    state?: NullableSimulationStateMachine;
+}
+export declare enum SimulationType {
+    SINE = "sine",
+    STEP = "step",
+    CONST = "const",
+    FUNCTION = "function"
+}
+export interface SimulationDesc {
+    type: SimulationType;
+    noise: NoiseSimulationProperties;
+    nullable: NullableSimulationProperties;
+}
+export interface TagDesc {
+    name: string;
+    type: string;
+    simulation?: SimulationDesc;
+}
+export interface MultiLangString {
+    [languageCode: string]: string;
+}
+export interface AlarmDesc {
+    name: string;
+    desc: MultiLangString;
+    source: string;
+    severity: number;
+    ack_required: boolean;
+    reset_required: boolean;
+    enabled: boolean;
+    simulation: SimulationDesc;
+}
+export interface DataPoint {
+    tagName: string | undefined;
+    value: any;
+    timestamp: number;
+}
+export declare enum AlarmState {
+    ALARM_NONE = 0,
+    ALARM_ENABLED = 1,
+    ALARM_ACTIVE = 2,
+    ALARM_ACKED = 4,
+    ALARM_REQUIRES_ACK = 8,
+    ALARM_REQUIRES_RESET = 16
+}
+export interface AlarmData {
+    name: string;
+    desc: string;
+    ts: Date;
+    evTs: Date;
+    sev?: Int32;
+    state: number;
+    tag?: string;
+    v_d?: number;
+    v_i?: Int32;
+    v_b?: boolean;
+    v_s?: string;
+    v_l?: Long;
+    v_o?: Binary;
+}
+export interface AlarmCommand {
+    command: string;
+    comment: string;
+    evTs: number;
+    name: string;
+    user: string;
+}
+export declare enum PacketFormatEnum {
+    JSON = "json",
+    BSON = "bson"
+}
+export declare function castCorvinaType(value: any, topicType: string): any;

package/dist/common/types.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.castCorvinaType = exports.PacketFormatEnum = exports.AlarmState = exports.SimulationType = exports.NoiseSimulationType = void 0;
+var NoiseSimulationType;
+(function (NoiseSimulationType) {
+    NoiseSimulationType["ABSOLUTE"] = "abs";
+    NoiseSimulationType["PERCENT"] = "%";
+})(NoiseSimulationType = exports.NoiseSimulationType || (exports.NoiseSimulationType = {}));
+var SimulationType;
+(function (SimulationType) {
+    SimulationType["SINE"] = "sine";
+    SimulationType["STEP"] = "step";
+    SimulationType["CONST"] = "const";
+    SimulationType["FUNCTION"] = "function";
+})(SimulationType = exports.SimulationType || (exports.SimulationType = {}));
+var AlarmState;
+(function (AlarmState) {
+    AlarmState[AlarmState["ALARM_NONE"] = 0] = "ALARM_NONE";
+    AlarmState[AlarmState["ALARM_ENABLED"] = 1] = "ALARM_ENABLED";
+    AlarmState[AlarmState["ALARM_ACTIVE"] = 2] = "ALARM_ACTIVE";
+    AlarmState[AlarmState["ALARM_ACKED"] = 4] = "ALARM_ACKED";
+    AlarmState[AlarmState["ALARM_REQUIRES_ACK"] = 8] = "ALARM_REQUIRES_ACK";
+    AlarmState[AlarmState["ALARM_REQUIRES_RESET"] = 16] = "ALARM_REQUIRES_RESET";
+})(AlarmState = exports.AlarmState || (exports.AlarmState = {}));
+var PacketFormatEnum;
+(function (PacketFormatEnum) {
+    PacketFormatEnum["JSON"] = "json";
+    PacketFormatEnum["BSON"] = "bson";
+})(PacketFormatEnum = exports.PacketFormatEnum || (exports.PacketFormatEnum = {}));
+function castCorvinaType(value, topicType) {
+    if (value == undefined) {
+        return undefined;
+    }
+    if (value == null) {
+        return null;
+    }
+    switch (topicType) {
+        case "integer":
+            return ~~value;
+        case "boolean":
+            if (typeof value == "string") {
+                if (value == "true") {
+                    return true;
+                }
+                else if (value == "false") {
+                    return false;
+                }
+                else {
+                    return !!~~value;
+                }
+            }
+            return !!value;
+        case "string":
+            return "" + value;
+        case "double":
+            return parseFloat(value);
+        case "struct":
+            break;
+        default:
+            throw "Unsupported data type " + topicType;
+    }
+    return value;
+}
+exports.castCorvinaType = castCorvinaType;
+//# sourceMappingURL=types.js.map

package/dist/common/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/common/types.ts"],"names":[],"mappings":";;;AAEA,IAAY,mBAGX;AAHD,WAAY,mBAAmB;IAC3B,uCAAgB,CAAA;IAChB,oCAAa,CAAA;AACjB,CAAC,EAHW,mBAAmB,GAAnB,2BAAmB,KAAnB,2BAAmB,QAG9B;AAoBD,IAAY,cAKX;AALD,WAAY,cAAc;IACtB,+BAAa,CAAA;IACb,+BAAa,CAAA;IACb,iCAAe,CAAA;IACf,uCAAqB,CAAA;AACzB,CAAC,EALW,cAAc,GAAd,sBAAc,KAAd,sBAAc,QAKzB;AAsCD,IAAY,UAOX;AAPD,WAAY,UAAU;IAClB,uDAAc,CAAA;IACd,6DAAiB,CAAA;IACjB,2DAAgB,CAAA;IAChB,yDAAe,CAAA;IACf,uEAAsB,CAAA;IACtB,4EAAyB,CAAA;AAC7B,CAAC,EAPW,UAAU,GAAV,kBAAU,KAAV,kBAAU,QAOrB;AA0BD,IAAY,gBAGX;AAHD,WAAY,gBAAgB;IACxB,iCAAa,CAAA;IACb,iCAAa,CAAA;AACjB,CAAC,EAHW,gBAAgB,GAAhB,wBAAgB,KAAhB,wBAAgB,QAG3B;AAED,SAAgB,eAAe,CAAC,KAAU,EAAE,SAAiB;IACzD,IAAI,KAAK,IAAI,SAAS,EAAE;QACpB,OAAO,SAAS,CAAC;KACpB;IACD,IAAI,KAAK,IAAI,IAAI,EAAE;QACf,OAAO,IAAI,CAAC;KACf;IACD,QAAQ,SAAS,EAAE;QACf,KAAK,SAAS;YACV,OAAO,CAAC,CAAC,KAAK,CAAC;QACnB,KAAK,SAAS;YACV,IAAI,OAAO,KAAK,IAAI,QAAQ,EAAE;gBAC1B,IAAI,KAAK,IAAI,MAAM,EAAE;oBACjB,OAAO,IAAI,CAAC;iBACf;qBAAM,IAAI,KAAK,IAAI,OAAO,EAAE;oBACzB,OAAO,KAAK,CAAC;iBAChB;qBAAM;oBACH,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;iBACpB;aACJ;YACD,OAAO,CAAC,CAAC,KAAK,CAAC;QACnB,KAAK,QAAQ;YACT,OAAO,EAAE,GAAG,KAAK,CAAC;QACtB,KAAK,QAAQ;YACT,OAAO,UAAU,CAAC,KAAK,CAAC,CAAC;QAC7B,KAAK,QAAQ;YACT,MAAM;QACV;YACI,MAAM,wBAAwB,GAAG,SAAS,CAAC;KAClD;IACD,OAAO,KAAK,CAAC;AACjB,CAAC;AA/BD,0CA+BC"}

package/dist/device.module.d.ts

@@ -0,0 +1,2 @@
+export declare class DeviceClientModule {
+}

package/dist/device.module.js

@@ -0,0 +1,41 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceClientModule = void 0;
+const device_service_1 = require("./services/device.service");
+const common_1 = require("@nestjs/common");
+const devicerunner_service_1 = require("./services/devicerunner.service");
+const config_1 = require("@nestjs/config");
+const logger_service_1 = require("./services/logger.service");
+let DeviceClientModule = class DeviceClientModule {
+};
+DeviceClientModule = __decorate([
+    (0, common_1.Module)({
+        imports: [config_1.ConfigModule.forRoot()],
+        controllers: [],
+        providers: [
+            {
+                provide: device_service_1.DeviceService,
+                useFactory: () => {
+                    (0, logger_service_1.setLogger)(common_1.Logger);
+                    return new device_service_1.DeviceService();
+                },
+            },
+            {
+                provide: devicerunner_service_1.DeviceRunnerService,
+                useFactory: (deviceService) => {
+                    return new devicerunner_service_1.DeviceRunnerService(deviceService);
+                },
+                inject: [device_service_1.DeviceService],
+            },
+        ],
+        exports: [device_service_1.DeviceService, devicerunner_service_1.DeviceRunnerService],
+    })
+], DeviceClientModule);
+exports.DeviceClientModule = DeviceClientModule;
+//# sourceMappingURL=device.module.js.map

package/dist/device.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"device.module.js","sourceRoot":"","sources":["../src/device.module.ts"],"names":[],"mappings":";;;;;;;;;AAAA,8DAA0D;AAC1D,2CAAgD;AAChD,0EAAsE;AACtE,2CAA8C;AAC9C,8DAAsD;AAwBtD,IAAa,kBAAkB,GAA/B,MAAa,kBAAkB;CAAG,CAAA;AAArB,kBAAkB;IAtB9B,IAAA,eAAM,EAAC;QACJ,OAAO,EAAE,CAAC,qBAAY,CAAC,OAAO,EAAE,CAAC;QACjC,WAAW,EAAE,EAAE;QACf,SAAS,EAAE;YACP;gBACI,OAAO,EAAE,8BAAa;gBACtB,UAAU,EAAE,GAAG,EAAE;oBAEb,IAAA,0BAAS,EAAC,eAAM,CAAC,CAAC;oBAClB,OAAO,IAAI,8BAAa,EAAE,CAAC;gBAC/B,CAAC;aACJ;YACD;gBACI,OAAO,EAAE,0CAAmB;gBAC5B,UAAU,EAAE,CAAC,aAA4B,EAAE,EAAE;oBACzC,OAAO,IAAI,0CAAmB,CAAC,aAAa,CAAC,CAAC;gBAClD,CAAC;gBACD,MAAM,EAAE,CAAC,8BAAa,CAAC;aAC1B;SACJ;QACD,OAAO,EAAE,CAAC,8BAAa,EAAE,0CAAmB,CAAC;KAChD,CAAC;GACW,kBAAkB,CAAG;AAArB,gDAAkB"}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./services/device.service";
+export * from "./services/devicerunner.service";
+export * from "./services/messagesender";
+export * from "./services/corvinadatainterface";
+export * from "./common/types";
+export { LicenseData } from "./services/licensesaxiosinstance";

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./services/device.service"), exports);
+__exportStar(require("./services/devicerunner.service"), exports);
+__exportStar(require("./services/messagesender"), exports);
+__exportStar(require("./services/corvinadatainterface"), exports);
+__exportStar(require("./common/types"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,4DAA0C;AAC1C,kEAAgD;AAChD,2DAAyC;AACzC,kEAAgD;AAChD,iDAA+B"}

package/dist/services/configparser.d.ts

@@ -0,0 +1,232 @@
+import { MessagePublisher } from "./messagepublisher";
+import { MessageSubscriber } from "./messagesubscriber";
+import { MessagePublisherPolicy, LevelMode } from "./messagepublisherpolicies";
+export declare type TypedObject<T> = {
+    [key: string]: T;
+};
+export declare type ConfigurationType = "datamodel";
+export declare type PolicyType = "send" | "history";
+export declare type PlatformConfigurationInterfaceType = "properties" | "datastream";
+export declare type PlatformAggregationType = "object" | "individual";
+export declare type OwnershipType = "device" | "server";
+export declare type ModelBasicType = "integer" | "double" | "string" | "boolean" | "bytestring" | "integerarray" | "doublearray" | "booleanarray" | "binaryblob";
+export declare type ModelObjectType = "object";
+export declare type ModelArrayType = "array";
+export declare type ModelStructType = "struct";
+export declare type MappingModeType = "R" | "RW";
+export interface ModelBasic {
+    type: ModelBasicType;
+    description?: string;
+    label?: string;
+    unit?: string;
+    tags?: string[];
+    version?: string;
+    deprecated?: boolean;
+}
+export interface ModelArray {
+    UUID?: string;
+    type: ModelArrayType;
+    length: number;
+    item: ModelObject;
+    description?: string;
+    label?: string;
+    unit?: string;
+    tags?: string[];
+    version?: string;
+    deprecated?: boolean;
+}
+export interface ModelObject {
+    UUID?: string;
+    type: ModelObjectType;
+    instanceOf: string;
+    properties: TypedObject<ModelNode>;
+    description?: string;
+    label?: string;
+    unit?: string;
+    tags?: string[];
+    version?: string;
+    deprecated?: boolean;
+}
+export interface ModelStruct {
+    UUID?: string;
+    type: ModelStructType;
+    instanceOf: string;
+    properties: TypedObject<ModelBasic>;
+    description?: string;
+    label?: string;
+    unit?: string;
+    tags?: string[];
+    version?: string;
+    deprecated?: boolean;
+}
+export interface ModelMetadata {
+    path: string;
+    label?: string;
+    description?: string;
+    unit?: string;
+    tags?: string[];
+    type?: ModelType;
+    version?: string;
+    instanceOf?: string;
+}
+export declare type ModelNode = ModelBasic | ModelArray | ModelInterfaceCreatable;
+export declare type ModelInterfaceCreatable = ModelObject | ModelStruct;
+export declare type ModelType = ModelBasicType | ModelObjectType | ModelArrayType | ModelStructType;
+export interface BasePolicyData {
+    type: PolicyType;
+    instanceOf?: string;
+    [key: string]: any;
+}
+export interface MappingData {
+    device_endpoint: string;
+    server_endpoint?: string;
+}
+export interface MappingHistoryPolicy {
+    enabled: boolean;
+    limit?: string;
+    compressionStrategy?: string;
+}
+export interface MappingSendPolicyTrigger {
+    type: "timer" | "onchange" | "onlevel" | "fieldchange" | "fieldlevel";
+    [key: string]: any;
+}
+export interface OnChangeTrigger extends MappingSendPolicyTrigger {
+    minIntervalMs?: number;
+    tagName?: string;
+    skipFirstNChanges?: number;
+    deadband?: number;
+    deadbandPercent?: number;
+    changeMask?: "value" | "timestamp" | "value|timestamp";
+}
+export interface IntervalTrigger extends MappingSendPolicyTrigger {
+    intervalMs: number;
+    type: "timer";
+}
+export interface OnLevelTrigger extends MappingSendPolicyTrigger {
+    minIntervalMs?: number;
+    tagName?: string;
+    skipFirstNChanges?: number;
+    level?: number;
+    levelString?: string;
+    mode?: LevelMode;
+    deadband?: number;
+    deadbandPercent?: number;
+    changeMask?: "value" | "timestamp" | "value|timestamp";
+    type: "onlevel";
+}
+export interface OnFieldChangeTrigger extends MappingSendPolicyTrigger {
+    minIntervalMs?: number;
+    tagName?: string;
+    fieldName?: string;
+    skipFirstNChanges?: number;
+    deadband?: number;
+    deadbandPercent?: number;
+    changeMask?: "value" | "timestamp" | "value|timestamp";
+    type: "fieldchange";
+}
+export interface OnFieldLevelTrigger extends MappingSendPolicyTrigger {
+    minIntervalMs?: number;
+    fieldName?: string;
+    skipFirstNChanges?: number;
+    level?: number;
+    levelString?: string;
+    mode?: LevelMode;
+    deadband?: number;
+    deadbandPercent?: number;
+    changeMask?: "value" | "timestamp" | "value|timestamp";
+    type: "fieldlevel";
+}
+export interface MappingSendPolicyCondition {
+    type: "and" | "or" | "inband" | "outband";
+}
+export interface LogicCondition extends MappingSendPolicyCondition {
+    type: "and" | "or";
+    operands: MappingSendPolicyCondition[];
+}
+export interface InOutBandCondition extends MappingSendPolicyCondition {
+    type: "inband" | "outband";
+    low: number;
+    high: number;
+    tagName: string;
+}
+export interface MappingSendPolicy {
+    triggers: MappingSendPolicyTrigger[];
+    conditions?: MappingSendPolicyCondition;
+}
+export interface SendPolicyData extends BasePolicyData, MappingSendPolicy {
+}
+export interface HistoryPolicyData extends BasePolicyData, MappingHistoryPolicy {
+}
+export declare type PolicyData = SendPolicyData | HistoryPolicyData;
+export interface MappingDatalink {
+    source: string;
+}
+export interface MappingAdditionalInfo {
+    mode?: MappingModeType;
+    historyPolicy?: MappingHistoryPolicy;
+    sendPolicy?: MappingSendPolicy;
+    datalink?: MappingDatalink;
+}
+export interface MappingInfo {
+    mapping?: MappingData;
+}
+export interface MappingBasic extends ModelBasic, MappingAdditionalInfo {
+}
+export interface MappingObject extends ModelObject, MappingAdditionalInfo {
+    properties: TypedObject<MappingNode>;
+}
+export interface MappingArray extends ModelArray, MappingAdditionalInfo {
+    item: MappingObject;
+}
+export interface MappingStruct extends ModelStruct, MappingAdditionalInfo {
+    properties: TypedObject<MappingBasic>;
+}
+export declare type MappingNode = MappingBasic | MappingArray | MappingInterfaceCreatable;
+export declare type MappingInterfaceCreatable = MappingObject | MappingStruct;
+export interface DeviceConfigurationBasic extends MappingBasic, MappingInfo {
+}
+export interface DeviceConfigurationArray extends MappingArray, MappingInfo {
+    item: DeviceConfigurationObject;
+}
+export interface DeviceConfigurationObject extends MappingObject, MappingInfo {
+    properties: TypedObject<DeviceConfigurationNode>;
+}
+export interface DeviceConfigurationStruct extends MappingStruct, MappingInfo {
+    properties: TypedObject<DeviceConfigurationBasic>;
+}
+export declare type DeviceConfigurationWithProperties = DeviceConfigurationObject | DeviceConfigurationStruct;
+export declare type DeviceConfigurationNode = DeviceConfigurationBasic | DeviceConfigurationArray | DeviceConfigurationWithProperties;
+export interface MappingsData {
+    endpoint: string;
+    type: ModelBasicType | ModelStructType;
+    explicit_timestamp?: boolean;
+}
+export interface InterfaceData {
+    interface_name: string;
+    version_major: number;
+    version_minor: number;
+    type: PlatformConfigurationInterfaceType;
+    ownership: OwnershipType;
+    aggregation?: PlatformAggregationType;
+    mappings: MappingsData[];
+}
+export interface ConfigurationData {
+    UUID: string;
+    type: ModelObjectType;
+    instanceOf: string;
+    policies?: TypedObject<PolicyData>;
+    interfaces: InterfaceData[];
+    properties: TypedObject<DeviceConfigurationNode>;
+}
+export interface DeviceConfigurationData {
+    type: ConfigurationType;
+    properties: TypedObject<ConfigurationData>;
+}
+export declare function indexTemplateApply(templateString: string, values: number[]): string;
+export interface DeviceConfiguration {
+    interfaceNames: string[];
+    tagPublishers: Map<string, Set<MessagePublisher>>;
+    namedPolicies: Map<string, MessagePublisherPolicy>;
+    subscribedTopics: Map<string, MessageSubscriber>;
+}
+export default function parseDeviceConfig(config: DeviceConfigurationData): DeviceConfiguration;