@autorunify/capacitor-nrfmesh 0.0.1

package/dist/esm/definitions.d.ts

@@ -0,0 +1,343 @@
+import type { PluginListenerHandle } from '@capacitor/core';
+type PartialAny<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type PermissionState = 'denied' | 'granted';
+export type PermissionKey = "android.permission.BLUETOOTH" | "android.permission.BLUETOOTH_ADMIN" | "android.permission.ACCESS_COARSE_LOCATION" | "android.permission.ACCESS_FINE_LOCATION" | "android.permission.BLUETOOTH_SCAN" | "android.permission.BLUETOOTH_CONNECT";
+export type Permissions = {
+    [key in PermissionKey]: PermissionState;
+};
+export interface BluetoothState {
+    enabled: boolean;
+}
+export interface TimeoutOptions {
+    timeout?: number;
+}
+export interface ConnectionState {
+    connected: boolean;
+}
+export interface NetKey {
+    index: number;
+    key: string;
+    minSecurity: string;
+    name: string;
+    phase: number;
+    timestamp: string;
+    oldKey?: string;
+}
+export interface AppKey {
+    index: number;
+    boundNetKey: number;
+    key: string;
+    name: string;
+}
+export interface MeshGroup {
+    name: string;
+    address: number;
+    addressHex: string;
+}
+export interface MeshNode {
+    name: string;
+    deviceKey: string;
+    unicastAddress: number;
+    security: string;
+    ttl: number;
+    netkeys: Array<{
+        index: number;
+        updated: boolean;
+    }>;
+    appkeys: Array<{
+        index: number;
+        updated: boolean;
+    }>;
+    elements: Array<{
+        name: string;
+        elementAddress: number;
+        models: Array<{
+            modelId: number;
+            appkeys: Array<number>;
+            subscriptions: Array<number>;
+            publication?: number;
+        }>;
+    }>;
+    features?: {
+        friend: number;
+        lowPower: number;
+        proxy: number;
+        relay: number;
+    };
+    networkTransmit?: {
+        count: number;
+        interval: number;
+        steps: number;
+    };
+}
+export interface OnOffModel {
+    state: boolean;
+}
+export interface SensorRawValue {
+    propertyId: number;
+    bytes: Array<number>;
+}
+export interface SensorModel {
+    values: Array<SensorRawValue>;
+}
+export interface SensorPropertiesModel {
+    properties: Array<Omit<SensorRawValue, 'bytes'>>;
+}
+export interface NetKeysResults {
+    netkeys: Array<NetKey>;
+}
+export interface NetKeyOptions {
+    add?: Omit<NetKey, 'index' | 'key' | 'minSecurity' | 'name' | 'phase' | 'timestamp' | 'oldKey'>;
+    del?: Omit<NetKey, 'key' | 'minSecurity' | 'name' | 'phase' | 'timestamp' | 'oldKey'>;
+    get?: Omit<NetKey, 'key' | 'minSecurity' | 'name' | 'phase' | 'timestamp' | 'oldKey'>;
+}
+export interface AppKeysOptions {
+    boundNetKey: number;
+}
+export interface AppKeysResults {
+    appkeys: Array<AppKey>;
+}
+export interface AppKeyOptions {
+    add?: Partial<Omit<AppKey, 'index' | 'key' | 'name'>>;
+    del?: Omit<AppKey, 'boundNetKey' | 'key' | 'name'>;
+    get?: Omit<AppKey, 'boundNetKey' | 'key' | 'name'>;
+}
+export interface GroupsResults {
+    groups: Array<MeshGroup>;
+}
+export interface GroupOptions {
+    add?: Omit<MeshGroup, 'name' | 'addressHex'>;
+    del?: Omit<MeshGroup, 'name' | 'addressHex'>;
+    get?: Omit<MeshGroup, 'name' | 'addressHex'>;
+}
+export interface NodesResults {
+    nodes: Array<MeshNode>;
+}
+export interface NodeDefaultTTL {
+    ttl: number;
+}
+export interface NodeNetworkTransmit {
+    count: number;
+    intervalSteps: number;
+}
+export interface NodeNetkey {
+    netkeyIndex: number;
+}
+export interface NodeNetkeys {
+    netkeyIndexes: Array<number>;
+}
+export interface NodeAppkey {
+    netkeyIndex: number;
+    appkeyIndex: number;
+}
+export interface NodeAppkeys {
+    netkeyIndex: number;
+    appkeyIndexes: Array<number>;
+}
+export interface ModelAppkey {
+    elementAddress: number;
+    modelId: number;
+    appkeyIndex: number;
+}
+export interface ModelAppkeys {
+    elementAddress: number;
+    modelId: number;
+    appkeyIndexs: Array<number>;
+}
+export interface HeartbeatPub {
+    address: number;
+    count: number;
+    period: number;
+    ttl: number;
+    netkeyIndex: number;
+    features: {
+        friend: number;
+        proxy: number;
+        relay: number;
+        lowPower: number;
+    };
+}
+export interface HeartbeatSub {
+    srcAddress: number;
+    dstAddress: number;
+    period: number;
+    count: number;
+    minHops: number;
+    maxHops: number;
+}
+export interface NodeOptions extends TimeoutOptions {
+    unicastAddress: number;
+    get?: Object;
+    defaultTTL?: {
+        set?: NodeDefaultTTL;
+    };
+    networkTransmit?: {
+        set?: NodeNetworkTransmit;
+    };
+    netkey?: {
+        add?: NodeNetkey;
+        del?: NodeNetkey;
+        get?: Omit<NodeNetkeys, 'netkeyIndexes'>;
+    };
+    appkey?: {
+        add?: Omit<NodeAppkey, 'netkeyIndex'>;
+        del?: Omit<NodeAppkey, 'netkeyIndex'>;
+        get?: Partial<Omit<NodeAppkeys, 'appkeyIndexes'>>;
+    };
+    heartbeat?: {
+        pub?: {
+            set?: PartialAny<Omit<HeartbeatPub, 'features'>, 'address' | 'count' | 'netkeyIndex'>;
+        };
+        sub?: {
+            set?: Omit<HeartbeatSub, 'count' | 'minHops' | 'maxHops'>;
+        };
+    };
+    bind?: {
+        add?: ModelAppkey;
+        del?: ModelAppkey;
+        get?: Omit<ModelAppkeys, "appkeyIndexs">;
+    };
+}
+export interface NodeResults {
+    get?: MeshNode;
+    defaultTTL?: NodeDefaultTTL;
+    networkTransmit?: NodeNetworkTransmit;
+    netkey?: {
+        add?: NodeNetkey;
+        del?: NodeNetkey;
+        get?: NodeNetkeys;
+    };
+    appkey?: {
+        add?: NodeAppkey;
+        del?: NodeAppkey;
+        get?: NodeAppkeys;
+    };
+    heartbeat?: {
+        pub?: HeartbeatPub;
+        sub?: HeartbeatSub;
+    };
+    bind?: {
+        add?: ModelAppkey;
+        del?: ModelAppkey;
+        get?: ModelAppkeys;
+    };
+}
+export interface ModelOptions extends TimeoutOptions {
+    elementAddress: number;
+    appkeyIndex: number;
+    onoff?: {
+        set?: OnOffModel;
+    };
+    sensor?: {
+        propertyId: number;
+        get?: Omit<SensorModel, 'values'>;
+        property?: PartialAny<SensorRawValue, 'bytes'>;
+        properties?: SensorPropertiesModel;
+    };
+}
+export interface ModelResults {
+    onoff?: OnOffModel;
+    sensor?: {
+        get?: SensorModel;
+        property?: SensorRawValue;
+        properties?: SensorPropertiesModel;
+    };
+}
+export interface MeshDevice {
+    address: string;
+    name: string;
+    provisioned: boolean;
+    rssi: number;
+    uuid?: string;
+}
+export interface ScanOptions extends TimeoutOptions {
+    filter?: 'all' | 'provisioned' | 'unprovisioned';
+}
+export interface ScanResults {
+    devices: Array<MeshDevice>;
+}
+export interface IdentifyOptions extends TimeoutOptions {
+    address: string;
+    uuid: string;
+}
+export interface IdentifyResults {
+    numberOfElements: number;
+    availableOOBTypes: Array<string>;
+    algorithms: number;
+    publicKeyType: number;
+    staticOobTypes: number;
+    outputOobSize: number;
+    outputOobActions: number;
+    inputOobSize: number;
+    inputOobActions: number;
+}
+export interface ProvisionOptions extends TimeoutOptions {
+    address: string;
+    uuid: string;
+}
+export interface ProvisionResults {
+    completed: boolean;
+    uuid: string;
+    unicastAddress?: number;
+}
+export interface CompositionOptions extends TimeoutOptions {
+    unicastAddress: number;
+}
+export interface CompositionResults {
+    companyIdentifier: string;
+    productIdentifier: string;
+    productVersion: string;
+    nodeFeaturesSupported: {
+        relay: boolean;
+        proxy: boolean;
+        friend: boolean;
+        lowPower: boolean;
+    };
+    elements: Array<{
+        name: string;
+        elementAddress: number;
+        sigModelCount: number;
+        vendorModelCount: number;
+        location: number;
+        models: Array<{
+            modelId: number;
+            modelName: string;
+            boundAppKeyIndexes: Array<number>;
+        }>;
+    }>;
+}
+export interface OnStateChangeEvent {
+    action: 'enabled' | 'connected';
+    state: boolean;
+}
+export interface OnNodeChangeEvent {
+    action: 'del' | 'add' | 'heartbeat';
+    unicastAddress: number;
+}
+export interface NrfMeshPlugin {
+    checkPermissions(): Promise<Permissions>;
+    requestPermissions(): Promise<Permissions>;
+    isBluetoothEnabled(): Promise<BluetoothState>;
+    isConnected(): Promise<ConnectionState>;
+    connect(options?: TimeoutOptions): Promise<void>;
+    disconnect(options?: TimeoutOptions): Promise<void>;
+    export(): Promise<any>;
+    import(options: any): Promise<void>;
+    netkeys(): Promise<NetKeysResults>;
+    netkey(options: NetKeyOptions): Promise<NetKey>;
+    appkeys(options?: AppKeysOptions): Promise<AppKeysResults>;
+    appkey(options: AppKeyOptions): Promise<AppKey>;
+    groups(): Promise<GroupsResults>;
+    group(options: GroupOptions): Promise<MeshGroup>;
+    nodes(): Promise<NodesResults>;
+    node(options: NodeOptions): Promise<NodeResults>;
+    model(options: ModelOptions): Promise<ModelResults>;
+    init(): Promise<any>;
+    devices(options?: ScanOptions): Promise<ScanResults>;
+    identify(options: IdentifyOptions): Promise<IdentifyResults>;
+    provision(options: ProvisionOptions): Promise<ProvisionResults>;
+    composition(options: CompositionOptions): Promise<CompositionResults>;
+    addListener(event: 'state', callback: (e: OnStateChangeEvent) => void): Promise<PluginListenerHandle>;
+    addListener(event: 'node', callback: (e: OnNodeChangeEvent) => void): Promise<PluginListenerHandle>;
+}
+export {};

package/dist/esm/definitions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=definitions.js.map

package/dist/esm/definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"","sourcesContent":["import type { PluginListenerHandle } from '@capacitor/core'\n\ntype PartialAny<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;\n\nexport type PermissionState = 'denied' | 'granted'\n\nexport type PermissionKey =\n  \"android.permission.BLUETOOTH\" |\n  \"android.permission.BLUETOOTH_ADMIN\" |\n  \"android.permission.ACCESS_COARSE_LOCATION\" |\n  \"android.permission.ACCESS_FINE_LOCATION\" |\n  \"android.permission.BLUETOOTH_SCAN\" |\n  \"android.permission.BLUETOOTH_CONNECT\"\n\n\nexport type Permissions = {\n  [key in PermissionKey]: PermissionState;\n}\n\nexport interface BluetoothState {\n  enabled: boolean;\n}\n\nexport interface TimeoutOptions {\n  timeout?: number\n}\n\nexport interface ConnectionState {\n  connected: boolean\n}\n\nexport interface NetKey {\n  index: number;\n  key: string;\n  minSecurity: string;\n  name: string;\n  phase: number;\n  timestamp: string;\n  oldKey?: string;\n}\n\nexport interface AppKey {\n  index: number\n  boundNetKey: number\n  key: string\n  name: string\n}\n\nexport interface MeshGroup {\n  name: string\n  address: number\n  addressHex: string\n}\n\nexport interface MeshNode {\n  name: string\n  deviceKey: string\n  unicastAddress: number\n  security: string\n  ttl: number\n  netkeys: Array<{ index: number, updated: boolean }>\n  appkeys: Array<{ index: number, updated: boolean }>\n  elements: Array<{\n    name: string\n    elementAddress: number\n    models: Array<{\n      modelId: number\n      appkeys: Array<number>\n      subscriptions: Array<number>\n      publication?: number\n    }>\n  }>\n  features?: {\n    friend: number\n    lowPower: number\n    proxy: number\n    relay: number\n  }\n  networkTransmit?: {\n    count: number\n    interval: number\n    steps: number\n  }\n}\n\nexport interface OnOffModel {\n  state: boolean\n}\n\nexport interface SensorRawValue {\n  propertyId: number\n  bytes: Array<number>\n}\n\nexport interface SensorModel {\n  values: Array<SensorRawValue>\n}\n\nexport interface SensorPropertiesModel {\n  properties: Array<Omit<SensorRawValue, 'bytes'>>\n}\n\nexport interface NetKeysResults {\n  netkeys: Array<NetKey>\n}\n\nexport interface NetKeyOptions {\n  add?: Omit<NetKey, 'index' | 'key' | 'minSecurity' | 'name' | 'phase' | 'timestamp' | 'oldKey'>\n  del?: Omit<NetKey, 'key' | 'minSecurity' | 'name' | 'phase' | 'timestamp' | 'oldKey'>\n  get?: Omit<NetKey, 'key' | 'minSecurity' | 'name' | 'phase' | 'timestamp' | 'oldKey'>\n}\n\nexport interface AppKeysOptions {\n  boundNetKey: number\n}\n\nexport interface AppKeysResults {\n  appkeys: Array<AppKey>\n}\n\nexport interface AppKeyOptions {\n  add?: Partial<Omit<AppKey, 'index' | 'key' | 'name'>>\n  del?: Omit<AppKey, 'boundNetKey' | 'key' | 'name'>\n  get?: Omit<AppKey, 'boundNetKey' | 'key' | 'name'>\n}\n\nexport interface GroupsResults {\n  groups: Array<MeshGroup>\n}\n\nexport interface GroupOptions {\n  add?: Omit<MeshGroup, 'name' | 'addressHex'>\n  del?: Omit<MeshGroup, 'name' | 'addressHex'>\n  get?: Omit<MeshGroup, 'name' | 'addressHex'>\n}\n\nexport interface NodesResults {\n  nodes: Array<MeshNode>\n}\n\nexport interface NodeDefaultTTL {\n  ttl: number;\n}\n\nexport interface NodeNetworkTransmit {\n  count: number\n  intervalSteps: number\n}\n\nexport interface NodeNetkey {\n  netkeyIndex: number\n}\n\nexport interface NodeNetkeys {\n  netkeyIndexes: Array<number>\n}\n\nexport interface NodeAppkey {\n  netkeyIndex: number\n  appkeyIndex: number\n}\n\nexport interface NodeAppkeys {\n  netkeyIndex: number\n  appkeyIndexes: Array<number>\n}\n\nexport interface ModelAppkey {\n  elementAddress: number;\n  modelId: number;\n  appkeyIndex: number;\n}\n\nexport interface ModelAppkeys {\n  elementAddress: number;\n  modelId: number;\n  appkeyIndexs: Array<number>;\n}\n\nexport interface HeartbeatPub {\n  address: number\n  count: number\n  period: number\n  ttl: number\n  netkeyIndex: number\n  features: {\n    friend: number\n    proxy: number\n    relay: number\n    lowPower: number\n  }\n}\n\nexport interface HeartbeatSub {\n  srcAddress: number\n  dstAddress: number\n  period: number\n  count: number\n  minHops: number\n  maxHops: number\n}\n\nexport interface NodeOptions extends TimeoutOptions {\n  unicastAddress: number\n  get?: Object\n  defaultTTL?: { set?: NodeDefaultTTL }\n  networkTransmit?: { set?: NodeNetworkTransmit }\n  netkey?: {\n    add?: NodeNetkey\n    del?: NodeNetkey\n    get?: Omit<NodeNetkeys, 'netkeyIndexes'>\n  }\n  appkey?: {\n    add?: Omit<NodeAppkey, 'netkeyIndex'>\n    del?: Omit<NodeAppkey, 'netkeyIndex'>\n    get?: Partial<Omit<NodeAppkeys, 'appkeyIndexes'>>\n  },\n  heartbeat?: {\n    pub?: { set?: PartialAny<Omit<HeartbeatPub, 'features'>, 'address' | 'count' | 'netkeyIndex'> }\n    sub?: { set?: Omit<HeartbeatSub, 'count' | 'minHops' | 'maxHops'> }\n  },\n  bind?: {\n    add?: ModelAppkey\n    del?: ModelAppkey\n    get?: Omit<ModelAppkeys, \"appkeyIndexs\">\n  }\n}\n\nexport interface NodeResults {\n  get?: MeshNode\n  defaultTTL?: NodeDefaultTTL\n  networkTransmit?: NodeNetworkTransmit\n  netkey?: {\n    add?: NodeNetkey\n    del?: NodeNetkey\n    get?: NodeNetkeys\n  }\n  appkey?: {\n    add?: NodeAppkey\n    del?: NodeAppkey\n    get?: NodeAppkeys\n  },\n  heartbeat?: {\n    pub?: HeartbeatPub\n    sub?: HeartbeatSub\n  },\n  bind?: {\n    add?: ModelAppkey\n    del?: ModelAppkey\n    get?: ModelAppkeys\n  }\n}\n\nexport interface ModelOptions extends TimeoutOptions {\n  elementAddress: number\n  appkeyIndex: number\n  onoff?: {\n    set?: OnOffModel\n  },\n  sensor?: {\n    propertyId: number\n    get?: Omit<SensorModel, 'values'>\n    property?: PartialAny<SensorRawValue, 'bytes'>\n    properties?: SensorPropertiesModel\n  }\n}\n\nexport interface ModelResults {\n  onoff?: OnOffModel,\n  sensor?: {\n    get?: SensorModel\n    property?: SensorRawValue\n    properties?: SensorPropertiesModel\n  }\n}\n\nexport interface MeshDevice {\n  address: string\n  name: string\n  provisioned: boolean\n  rssi: number\n  uuid?: string\n}\n\nexport interface ScanOptions extends TimeoutOptions {\n  filter?: 'all' | 'provisioned' | 'unprovisioned'\n}\n\nexport interface ScanResults {\n  devices: Array<MeshDevice>\n}\n\nexport interface IdentifyOptions extends TimeoutOptions {\n  address: string;\n  uuid: string;\n}\n\nexport interface IdentifyResults {\n  numberOfElements: number;\n  availableOOBTypes: Array<string>;\n  algorithms: number;\n  publicKeyType: number;\n  staticOobTypes: number;\n  outputOobSize: number;\n  outputOobActions: number;\n  inputOobSize: number;\n  inputOobActions: number;\n}\n\nexport interface ProvisionOptions extends TimeoutOptions {\n  address: string;\n  uuid: string;\n}\n\nexport interface ProvisionResults {\n  completed: boolean;\n  uuid: string;\n  unicastAddress?: number;\n}\n\nexport interface CompositionOptions extends TimeoutOptions {\n  unicastAddress: number\n}\n\nexport interface CompositionResults {\n  companyIdentifier: string;\n  productIdentifier: string;\n  productVersion: string;\n  nodeFeaturesSupported: {\n    relay: boolean;\n    proxy: boolean;\n    friend: boolean;\n    lowPower: boolean;\n  };\n  elements: Array<{\n    name: string;\n    elementAddress: number;\n    sigModelCount: number;\n    vendorModelCount: number;\n    location: number;\n    models: Array<{\n      modelId: number;\n      modelName: string;\n      boundAppKeyIndexes: Array<number>;\n    }>;\n  }>;\n}\n\nexport interface OnStateChangeEvent {\n  action: 'enabled' | 'connected'\n  state: boolean\n}\n\nexport interface OnNodeChangeEvent {\n  action: 'del' | 'add' | 'heartbeat'\n  unicastAddress: number\n}\n\nexport interface NrfMeshPlugin {\n  checkPermissions(): Promise<Permissions>;\n  requestPermissions(): Promise<Permissions>;\n  isBluetoothEnabled(): Promise<BluetoothState>;\n\n  isConnected(): Promise<ConnectionState>;\n  connect(options?: TimeoutOptions): Promise<void>;\n  disconnect(options?: TimeoutOptions): Promise<void>;\n\n  export(): Promise<any>\n  import(options: any): Promise<void>\n\n  netkeys(): Promise<NetKeysResults>\n  netkey(options: NetKeyOptions): Promise<NetKey>\n\n  appkeys(options?: AppKeysOptions): Promise<AppKeysResults>\n  appkey(options: AppKeyOptions): Promise<AppKey>\n\n  groups(): Promise<GroupsResults>\n  group(options: GroupOptions): Promise<MeshGroup>\n\n  nodes(): Promise<NodesResults>\n  node(options: NodeOptions): Promise<NodeResults>\n\n  model(options: ModelOptions): Promise<ModelResults>\n\n  init(): Promise<any>;\n  devices(options?: ScanOptions): Promise<ScanResults>;\n  identify(options: IdentifyOptions): Promise<IdentifyResults>;\n  provision(options: ProvisionOptions): Promise<ProvisionResults>;\n  composition(options: CompositionOptions): Promise<CompositionResults>;\n\n  addListener(\n    event: 'state',\n    callback: (e: OnStateChangeEvent) => void,\n  ): Promise<PluginListenerHandle>;\n  addListener(\n    event: 'node',\n    callback: (e: OnNodeChangeEvent) => void,\n  ): Promise<PluginListenerHandle>;\n}\n"]}

package/dist/esm/index.d.ts

@@ -0,0 +1,5 @@
+import type { NrfMeshPlugin } from './definitions';
+declare const NrfMesh: NrfMeshPlugin;
+export * from './definitions';
+export * from './sensor';
+export { NrfMesh };

package/dist/esm/index.js

@@ -0,0 +1,8 @@
+import { registerPlugin } from '@capacitor/core';
+const NrfMesh = registerPlugin('NrfMesh', {
+    web: () => import('./web').then((m) => new m.NrfMeshWeb()),
+});
+export * from './definitions';
+export * from './sensor';
+export { NrfMesh };
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAIjD,MAAM,OAAO,GAAG,cAAc,CAAgB,SAAS,EAAE;IACvD,GAAG,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,CAAC;CAC3D,CAAC,CAAC;AAEH,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAA;AACxB,OAAO,EAAE,OAAO,EAAE,CAAC","sourcesContent":["import { registerPlugin } from '@capacitor/core';\n\nimport type { NrfMeshPlugin } from './definitions';\n\nconst NrfMesh = registerPlugin<NrfMeshPlugin>('NrfMesh', {\n  web: () => import('./web').then((m) => new m.NrfMeshWeb()),\n});\n\nexport * from './definitions';\nexport * from './sensor'\nexport { NrfMesh };\n"]}

package/dist/esm/sensor.d.ts

@@ -0,0 +1,185 @@
+import { SensorRawValue } from './definitions';
+export declare function unsignedToSigned(unsigned: number, size: number): number;
+export declare function signedToUnsigned(signed: number, size: number): number;
+export type SensorValueType = boolean | number | Date | string | Uint8Array;
+export interface SensorValueConstructor {
+    new (propertyId: number, ...args: any): SensorValue<SensorValueType>;
+}
+export declare abstract class SensorValue<T extends SensorValueType> {
+    private static types;
+    static register(propertyId: number, cls: SensorValueConstructor, ...args: any): void;
+    static from(src: SensorRawValue | number): SensorValue<SensorValueType>;
+    private _propertyId;
+    protected _value: T | null;
+    get propertyId(): number;
+    get value(): T | null;
+    protected constructor(propertyId: number);
+    protected isLittleEndian(): boolean;
+    abstract setValue(value: T | Uint8Array): void;
+    abstract toBytes(): Uint8Array;
+    toRawValue(): SensorRawValue;
+}
+export declare class Bool extends SensorValue<boolean> {
+    constructor(propertyId: number);
+    setValue(value: boolean | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class Percentage8 extends SensorValue<number> {
+    constructor(propertyId: number);
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class Temperature extends SensorValue<number> {
+    private _type;
+    get type(): "Celsius" | "Fahrenheit";
+    constructor(propertyId: number, type?: 'Celsius' | 'Fahrenheit');
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class Count extends SensorValue<number> {
+    constructor(propertyId: number);
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class Humidity extends SensorValue<number> {
+    constructor(propertyId: number);
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class PerceivedLightness extends SensorValue<number> {
+    constructor(propertyId: number);
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class TimeSecond extends SensorValue<number> {
+    constructor(propertyId: number);
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class Illuminance extends SensorValue<number> {
+    constructor(propertyId: number);
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class TimeHour24 extends SensorValue<number> {
+    constructor(propertyId: number);
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class TimeMillisecond24 extends SensorValue<number> {
+    constructor(propertyId: number);
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class DateUtc extends SensorValue<Date> {
+    constructor(propertyId: number);
+    setValue(value: Date | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class Pressure extends SensorValue<number> {
+    constructor(propertyId: number);
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class Coefficient extends SensorValue<number> {
+    constructor(propertyId: number);
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class FixedString extends SensorValue<string> {
+    constructor(propertyId: number);
+    setValue(value: string | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class Energy32 extends SensorValue<number> {
+    constructor(propertyId: number);
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class Power extends SensorValue<number> {
+    constructor(propertyId: number);
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class ElectricCurrent extends SensorValue<number> {
+    constructor(propertyId: number);
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class Unknown extends SensorValue<Uint8Array> {
+    constructor(propertyId: number);
+    setValue(value: Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class Uint8 extends SensorValue<number> {
+    constructor(propertyId: number);
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class Uint16 extends SensorValue<number> {
+    constructor(propertyId: number);
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class Uint32 extends SensorValue<number> {
+    constructor(propertyId: number);
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class Int8 extends SensorValue<number> {
+    constructor(propertyId: number);
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class Int16 extends SensorValue<number> {
+    constructor(propertyId: number);
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class Int32 extends SensorValue<number> {
+    constructor(propertyId: number);
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class Uint16Value extends SensorValue<number> {
+    private _exponent;
+    get exponent(): number;
+    constructor(propertyId: number, exponent?: number);
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class Uint24Value extends SensorValue<number> {
+    private _exponent;
+    get exponent(): number;
+    constructor(propertyId: number, exponent?: number);
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class Uint32Value extends SensorValue<number> {
+    private _exponent;
+    get exponent(): number;
+    constructor(propertyId: number, exponent?: number);
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class Int16Value extends SensorValue<number> {
+    private _exponent;
+    get exponent(): number;
+    constructor(propertyId: number, exponent?: number);
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class Int24Value extends SensorValue<number> {
+    private _exponent;
+    get exponent(): number;
+    constructor(propertyId: number, exponent?: number);
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}
+export declare class Int32Value extends SensorValue<number> {
+    private _exponent;
+    get exponent(): number;
+    constructor(propertyId: number, exponent?: number);
+    setValue(value: number | Uint8Array): void;
+    toBytes(): Uint8Array;
+}