@iotize/device-com-ble.cordova 3.7.2 → 4.0.0-alpha.1

package/packages/common/converter/api/src/lib/encoder-decoder.interface.d.ts

@@ -0,0 +1,5 @@
+import { Encoder } from './encoder.interface';
+import { Decoder } from './decoder.interface';
+export interface EncoderDecoder<InputType, OutputType> extends Encoder<InputType, OutputType>, Decoder<OutputType, InputType> {
+}
+export type EncoderDecoderFct<InputType, OutputType> = (input: InputType) => OutputType;

package/packages/common/converter/api/src/lib/encoder.interface.d.ts

@@ -0,0 +1,4 @@
+export interface Encoder<InputType, OutputType> {
+    encode(type: InputType): OutputType;
+}
+export type EncoderFct<InputType, OutputType> = (type: InputType) => OutputType;

package/packages/common/converter/api/src/public_api.d.ts

@@ -0,0 +1,4 @@
+export * from './lib/decoder.interface';
+export * from './lib/encoder.interface';
+export * from './lib/converter.interface';
+export * from './lib/encoder-decoder.interface';

package/packages/common/debug/src/lib/debug.d.ts

@@ -0,0 +1,7 @@
+import createDebugger from 'debug';
+export declare function createLazyDebugger(tag: string): {
+    (cb: () => any[]): void;
+    enabled: boolean;
+    enable: (v: boolean) => void;
+};
+export { createDebugger };

package/packages/common/debug/src/public_api.d.ts

@@ -0,0 +1 @@
+export * from './lib/debug';

package/packages/common/error/src/lib/base-error.d.ts

@@ -0,0 +1,3 @@
+export declare class BaseError extends Error {
+    constructor(message: string);
+}

package/packages/common/error/src/lib/code-error.d.ts

@@ -0,0 +1,9 @@
+import { BaseError } from './base-error';
+/**
+ * Error class with code property
+ */
+export declare class CodeError<CodeType = string> extends BaseError {
+    code: CodeType;
+    constructor(msg: string, code: CodeType);
+}
+export declare function isCodeError<OError extends CodeError, CodeType = string>(code: CodeType, err: Error | OError | unknown): err is OError;

package/packages/common/error/src/public_api.d.ts

@@ -0,0 +1,2 @@
+export { CodeError, isCodeError } from './lib/code-error';
+export { BaseError } from './lib/base-error';

package/packages/common/promise/src/lib/promise-delay.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Resolve promise with value after the given delay
+ * @param value value to be resolved
+ * @param delay if delay <= 0, it will resolve immediatly
+ */
+export declare function promiseDelay<T>(value: T, delay: number): Promise<T>;

package/packages/common/promise/src/lib/promise-serial.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Run promise one after another (sequentially)
+ * @param tasks
+ * @param fn promise factory function. Will take task as parameter an returns a Promise
+ */
+export declare function promiseSerial<T = any>(tasks: T[], fn: (task: T, index: number) => Promise<any>): Promise<any>;

package/packages/common/promise/src/lib/promise-timeout.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns promise that will be rejected with Timeout error if not resolved in time
+ * @param ms timeout value in milliseconds. if <= 0, will be immediatly rejected
+ * @param promise
+ * @param errorFactory function to create the error when timeout occurs
+ */
+export declare function promiseTimeout<T>(ms: number, promise: Promise<T>, errorFactory?: (args: {
+    timeout: number;
+    startTime: Date;
+}) => Error): Promise<T>;

package/packages/common/promise/src/public_api.d.ts

@@ -0,0 +1,3 @@
+export * from './lib/promise-serial';
+export * from './lib/promise-timeout';
+export * from './lib/promise-delay';

package/packages/common/task-manager/src/lib/cancelable-task.d.ts

@@ -0,0 +1,22 @@
+import { Observable } from 'rxjs';
+import { TaskInterface } from './definitions';
+export declare class CancelableTask<T> implements TaskInterface<T> {
+    private operation;
+    private _canceled;
+    private _executed;
+    private _subject;
+    get isCanceled(): boolean;
+    constructor(operation: () => Observable<T>);
+    /**
+     * If canceled is called before the execute => do nothing
+     * otherwise reject pending request
+     * If canceled is called more than once, do nothing
+     */
+    cancel(withError?: Error): void;
+    /**
+     * If execute is called after cancel => return Operation cancelled exception
+     * If already executing, return the current execution promise
+     */
+    execute(): Observable<T>;
+    toObservable(): Observable<T>;
+}

package/packages/common/task-manager/src/lib/debug.d.ts

@@ -0,0 +1,2 @@
+import { createDebugger } from '@iotize/common/debug';
+export declare const debug: createDebugger.Debugger;

package/packages/common/task-manager/src/lib/definitions.d.ts

@@ -0,0 +1,16 @@
+import { Observable } from 'rxjs';
+export interface TaskInterface<T> {
+    cancel(withError?: Error): void;
+    execute(): Observable<T>;
+    toObservable(): Observable<T>;
+}
+export declare class TaskError extends Error {
+    code: TaskError.Code;
+    constructor(code: TaskError.Code, msg: string);
+    static operationCancelled(task: TaskInterface<any>): TaskError;
+}
+export declare namespace TaskError {
+    enum Code {
+        TASK_OPERATION_CANCELLED = "TASK_OPERATION_CANCELLED"
+    }
+}

package/packages/common/task-manager/src/lib/step-operations.d.ts

@@ -0,0 +1,112 @@
+import { Observable, Observer, Subject } from 'rxjs';
+/**
+ * Step operation execution manager
+ *
+ * Template type T: the event type. It's the return type of each operations
+ * Template type DataType: context additional DataType
+ * @experimental
+ */
+export declare class StepOperations<T, DataType extends Record<string, any>> {
+    private operationContainers;
+    private _state;
+    _taskErrorHandler?: StepOperations.ErrorHandler;
+    _currentExecutionEvents?: Subject<T>;
+    _events: Subject<any>;
+    get isCancelled(): boolean;
+    get isCompleted(): boolean;
+    get state(): StepOperations.State;
+    get events(): Observable<any>;
+    set taskErrorHandler(errorHandler: StepOperations.ErrorHandler | undefined);
+    get operations(): StepOperations.Operation<T, DataType>[];
+    constructor(operationContainers: StepOperations.OperationContainer<T, DataType>[]);
+    static createSequentialContainers<EventType, DataType extends Record<string, any> = any>(operations: StepOperations.OperationType<EventType, DataType>[]): StepOperations.OperationContainer<EventType, DataType>[];
+    static sequential<EventType, DataType extends Record<string, any> = any>(operations: StepOperations.OperationType<EventType, DataType>[]): StepOperations<EventType, DataType>;
+    runEvents(): Observable<T>;
+    /**
+     * Reset as if operations were never executed.
+     * Will call onReset callback for each Operation if defined.
+     * @returns this
+     */
+    reset(): this;
+    /**
+     * Will retry from the last failed operation.
+     * Call 'onRetry' callback for each Operation if definied.
+     *
+     * If all operations where successfully executed, it will do nothing.
+     *
+     * Call reset() first if you want to run operations again.
+     */
+    retry(): Observable<T>;
+    /**
+     * Execute operations
+     * If it already running, do nothing
+     *
+     */
+    run(): Observable<T>;
+    /**
+     * Cancel running operations
+     */
+    cancel(): void;
+    /**
+     * Transform this operation as an observable
+     * Subscribe to observable to run operation
+     * Unsubscribe to cancel operation
+     *
+     * Each time you call this method, a new observable is created
+     */
+    asObservable(): Observable<T>;
+    private checkIsCancelled;
+    private checkIsRunning;
+    private _onTaskError;
+    private _start;
+    private onComplete;
+    private onError;
+}
+export declare class StepOperationsError extends Error {
+    code: string;
+    constructor(code: string, msg: string);
+    static cancel(): StepOperationsError;
+    static unknown(msg: string): StepOperationsError;
+}
+export declare namespace StepOperationsError {
+    enum Code {
+        UNKNOWN_ERROR = "STEP_OPERATION_UNKNOWN_ERROR",
+        STEP_OPERATION_CANCEL = "STEP_OPERATION_CANCEL"
+    }
+}
+export declare namespace StepOperations {
+    interface OperationContainer<T, DataType extends Record<string, any>> {
+        index: number;
+        done?: boolean;
+        result?: T;
+        error?: Error;
+        operation: Operation<T, DataType>;
+    }
+    interface ErrorHandler {
+        handle(err: Error, context: Context): void;
+    }
+    type OperationFct<T, DataType extends Record<string, any> = any> = (observer: Observer<T>, context: Context<DataType>) => Promise<any>;
+    interface Operation<T, DataType extends Record<string, any> = any> {
+        alias?: string;
+        onRetry?: () => void;
+        onReset?: () => void;
+        perform(observer: Observer<T>, context: Context<DataType>): Promise<any>;
+    }
+    type OperationType<EventType, DataType extends Record<string, any> = any> = Operation<EventType, DataType> | OperationFct<EventType, DataType> | Observable<EventType>;
+    interface Context<DataType extends Record<string, any> = any> {
+        position: number;
+        total: number;
+        index: number;
+        prevOperation?: StepOperations.OperationContainer<any, DataType>;
+        data: DataType;
+    }
+    enum State {
+        PENDING = "PENDING",
+        RUNNING = "RUNNING",
+        COMPLETED = "COMPLETED",
+        CANCELED = "CANCELED",
+        ERRORED = "ERRORED"
+    }
+}
+export declare class IgnoreErrorStrategy {
+}

package/packages/common/task-manager/src/lib/task-queue.d.ts

@@ -0,0 +1,28 @@
+import { Observable } from 'rxjs';
+import { TaskInterface } from './definitions';
+/**
+ * Task queue is used to run async task sequentially
+ *
+ * Usage:
+ * ```typescript
+ * const taskQueue = new TaskQueue();
+ *
+ *  taskQueue.addExecutor(() => of('Task 1 finished').pipe(delay(100))).subscribe(console.log);
+ *  taskQueue.addExecutor(() => of('Task 2 finished').pipe(delay(1))).subscribe(console.log);
+ *
+ * // Will output
+ * Task 1 finished
+ * Task 2 finished
+ * ```
+ */
+export declare class TaskQueue {
+    tasks: TaskInterface<any>[];
+    private _subscription?;
+    private set workingState(value);
+    currentTask?: TaskInterface<any>;
+    constructor();
+    addExecutor(executor: () => Observable<any>): Observable<any>;
+    addTask(task: TaskInterface<any>): Observable<any>;
+    cancelAll(withError?: Error): void;
+    private processNext;
+}

package/packages/common/task-manager/src/public_api.d.ts

@@ -0,0 +1,4 @@
+export * from './lib/definitions';
+export * from './lib/step-operations';
+export * from './lib/task-queue';
+export * from './lib/cancelable-task';

package/packages/common/tlv/src/lib/debug.d.ts

@@ -0,0 +1,2 @@
+import { createDebugger } from '@iotize/common/debug';
+export declare const debug: createDebugger.Debugger;

package/packages/common/tlv/src/lib/tlv.d.ts

@@ -0,0 +1,65 @@
+import { KaitaiStreamWriter } from '@iotize/common/byte-stream';
+export declare namespace TLV {
+    interface TlvNode {
+        header: Header;
+        children?: Array<TlvNode>;
+        payload?: Uint8Array;
+    }
+    interface Schema {
+        validate: any;
+        resources: {
+            [key: string]: Resource;
+        };
+        id: {
+            [key: string]: any;
+        };
+    }
+    enum DataType {
+        String = "String",
+        Integer = "Integer",
+        Float = "Float",
+        Boolean = "Boolean",
+        Opaque = "Opaque",
+        Time = "Time",
+        Array = "Array"
+    }
+    interface Resource {
+        id: string;
+        type: DataType | Array<any>;
+    }
+    interface Header {
+        id: number;
+        len: number;
+        type: IdentifierType;
+    }
+    enum IdentifierType {
+        OBJECT_INSTANCE = 0,
+        RESOURCE_INSTANCE = 1,
+        MULTIPLE_RESOURCE = 2,
+        RESOURCE_VALUE = 3
+    }
+    function tlvType(type: number, id: number, len: number): number;
+    class Parser {
+        private buffer;
+        position: number;
+        schema?: Schema;
+        constructor(schema?: Schema);
+        /**
+         *
+         * @param buf
+         * @param offset
+         * @param tlv
+         */
+        readHeader(): Header;
+        readNextRecord(): TlvNode;
+        append(header: Header, type: DataType): any;
+        readAllRecords(endPosition: number): TlvNode[];
+        parse(data: Uint8Array): TlvNode;
+        private debug;
+    }
+    class Serializer {
+        serialize(obj: TLV.TlvNode, stream?: KaitaiStreamWriter): Uint8Array;
+        private writeHeader;
+        serializeObj(obj: Record<string, any>, schema?: Schema): Uint8Array;
+    }
+}

package/packages/common/tlv/src/public_api.d.ts

@@ -0,0 +1 @@
+export * from './lib/tlv';

package/packages/common/utility/src/lib/assert-error.d.ts

@@ -0,0 +1 @@
+export declare function assertError(msg: string): void;

package/packages/common/utility/src/lib/deep-copy.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Deep copy given object.
+ * It supports
+ *  - primitive types (number, string, array)
+ *  - Uint8Array
+ *  - objects
+ *  - Date
+ *
+ * It may loose type for others...
+ *
+ * @param T Generic type of target/copied value.
+ * @param target Target value to be copied.
+ */
+export declare const deepCopy: <T>(target: T, hash?: WeakMap<any, any>) => T;

package/packages/common/utility/src/lib/enum-util.d.ts

@@ -0,0 +1,23 @@
+export declare function safeEnumValue<T extends {
+    [key: string]: string | number;
+}>(enumData: T, key: string | keyof T): T[keyof T];
+/**
+ * List enum keys. It works for string and number enum where Object.keys will returns both key and values.
+ *
+ * ```typescript
+ * enum EnumString {
+ *  A = 'MyValueA',
+ *  B = 'MyValueB
+ * }
+ *
+ * expect(listEnumKeys(EnumString)).to.be.eq(['A', 'B']);
+ * expect(Object.keys(EnumString)).to.be.eq(['A', 'B', 'MyValueA', 'MyValueB']);
+ * ```
+ * @param enumType
+ */
+export declare function listEnumKeys<T>(enumType: T): string[];
+/**
+ * List enum values
+ * @param enumType
+ */
+export declare function listEnumValues<T>(enumType: T): (string | number)[];

package/packages/common/utility/src/lib/sleep.d.ts

@@ -0,0 +1 @@
+export declare function sleep(duration: number): Promise<void>;

package/packages/common/utility/src/lib/utility.d.ts

@@ -0,0 +1 @@
+export declare function deepEqual(x: any, y: any, hash?: WeakMap<any, boolean>): boolean;

package/packages/common/utility/src/public_api.d.ts

@@ -0,0 +1,5 @@
+export * from './lib/utility';
+export * from './lib/sleep';
+export * from './lib/enum-util';
+export * from './lib/assert-error';
+export { deepCopy } from './lib/deep-copy';

package/{lib → packages/device-com-ble.cordova/src/lib}/ble-com-protocol.d.ts

@@ -1,20 +1,20 @@
-import { ComProtocolConnectOptions, ComProtocolDisconnectOptions, ComProtocolOptions, ComProtocolSendOptions } from '@iotize/tap/protocol/api';
-import { QueueComProtocol } from '@iotize/tap/protocol/core';
-import { Observable } from 'rxjs';
-import { IoTizeBleCordovaPlugin } from './iotize-ble-cordova-plugin';
-export declare class BLEComProtocol extends QueueComProtocol {
-    private deviceId;
-    readonly cordovaInterfaceOverwrite?: IoTizeBleCordovaPlugin | undefined;
-    /**
-     * Lazy reference to iotizeBLE.
-     * We don't want to reference iotizeBLE in constructor as it may be referenced
-     * before cordova plugin is loaded
-     */
-    private get pluginInterface();
-    constructor(deviceId: string, comProtocolOptions?: ComProtocolOptions, cordovaInterfaceOverwrite?: IoTizeBleCordovaPlugin | undefined);
-    _connect(options?: ComProtocolConnectOptions): Observable<any>;
-    _disconnect(options?: ComProtocolDisconnectOptions): Observable<any>;
-    write(data: Uint8Array): Promise<any>;
-    read(): Promise<Uint8Array>;
-    send(data: Uint8Array, options?: ComProtocolSendOptions): Observable<Uint8Array>;
-}
+import { ComProtocolConnectOptions, ComProtocolDisconnectOptions, ComProtocolOptions, ComProtocolSendOptions } from '@iotize/tap/protocol/api';
+import { QueueComProtocol } from '@iotize/tap/protocol/core';
+import { Observable } from 'rxjs';
+import { IoTizeBleCordovaPlugin } from './iotize-ble-cordova-plugin';
+export declare class BLEComProtocol extends QueueComProtocol {
+    private deviceId;
+    readonly cordovaInterfaceOverwrite?: IoTizeBleCordovaPlugin | undefined;
+    /**
+     * Lazy reference to iotizeBLE.
+     * We don't want to reference iotizeBLE in constructor as it may be referenced
+     * before cordova plugin is loaded
+     */
+    private get pluginInterface();
+    constructor(deviceId: string, comProtocolOptions?: ComProtocolOptions, cordovaInterfaceOverwrite?: IoTizeBleCordovaPlugin | undefined);
+    _connect(options?: ComProtocolConnectOptions): Observable<any>;
+    _disconnect(options?: ComProtocolDisconnectOptions): Observable<any>;
+    write(data: Uint8Array): Promise<any>;
+    read(): Promise<Uint8Array>;
+    send(data: Uint8Array, options?: ComProtocolSendOptions): Observable<Uint8Array>;
+}

package/{lib → packages/device-com-ble.cordova/src/lib}/cordova-ble-error.d.ts

@@ -1,29 +1,29 @@
-import { CodeError } from '@iotize/common/error';
-export declare class CordovaBLEError extends CodeError {
-    static invalidErrorResult(errObject: {
-        code?: string | undefined;
-        message?: string | undefined;
-    }): CordovaBLEError;
-    static invalidErrorCode(errObject: {
-        code?: string | undefined;
-        message?: string | undefined;
-    }): CordovaBLEError;
-    static invalidNativeCallResult(result: any, cause: Error): CordovaBLEError;
-    static isValidErrorCode(code: string): code is keyof typeof CordovaBLEError.Code;
-    static iotizeBLEMissing(): CordovaBLEError;
-}
-export declare namespace CordovaBLEError {
-    enum Code {
-        InternalError = "CordovaBLEErrorInternalError",
-        IllegalArgument = "CordovaBLEErrorIllegalArgument",
-        BLENotAvailable = "CordovaBLEErrorBLENotAvailable",
-        InvalidMacAddress = "InvalidMacAddressInvalidMacAddress",
-        ConnectionError = "CordovaBLEErrorConnectionError",
-        RequestError = "CordovaBLEErrorRequestError",
-        LocationServiceDisabled = "CordovaBLEErrorLocationServiceDisabled",
-        DisconnectError = "CordovaBLEErrorDisconnectError",
-        IllegalAction = "CordovaBLEErrorIllegalAction",
-        NotConnectedError = "CordovaBLEErrorNotConnectedError",
-        StatusCodeError = "CordovaBLEErrorStatusCodeError"
-    }
-}
+import { CodeError } from '@iotize/common/error';
+export declare class CordovaBLEError extends CodeError {
+    static invalidErrorResult(errObject: {
+        code?: string | undefined;
+        message?: string | undefined;
+    }): CordovaBLEError;
+    static invalidErrorCode(errObject: {
+        code?: string | undefined;
+        message?: string | undefined;
+    }): CordovaBLEError;
+    static invalidNativeCallResult(result: any, cause: Error): CordovaBLEError;
+    static isValidErrorCode(code: string): code is keyof typeof CordovaBLEError.Code;
+    static iotizeBLEMissing(): CordovaBLEError;
+}
+export declare namespace CordovaBLEError {
+    enum Code {
+        InternalError = "CordovaBLEErrorInternalError",
+        IllegalArgument = "CordovaBLEErrorIllegalArgument",
+        BLENotAvailable = "CordovaBLEErrorBLENotAvailable",
+        InvalidMacAddress = "InvalidMacAddressInvalidMacAddress",
+        ConnectionError = "CordovaBLEErrorConnectionError",
+        RequestError = "CordovaBLEErrorRequestError",
+        LocationServiceDisabled = "CordovaBLEErrorLocationServiceDisabled",
+        DisconnectError = "CordovaBLEErrorDisconnectError",
+        IllegalAction = "CordovaBLEErrorIllegalAction",
+        NotConnectedError = "CordovaBLEErrorNotConnectedError",
+        StatusCodeError = "CordovaBLEErrorStatusCodeError"
+    }
+}

package/{lib → packages/device-com-ble.cordova/src/lib}/cordova-interface.d.ts

@@ -1,5 +1,5 @@
-export interface CordovaInterface {
-    exec<T>(success: SuccessCallback<T>, error: ErrorCallback, className: string, action: string, ...args: any[]): void;
-}
-export declare type ErrorCallback = (err: Error) => void;
-export declare type SuccessCallback<T> = (data: T) => void;
+export interface CordovaInterface {
+    exec<T>(success: SuccessCallback<T>, error: ErrorCallback, className: string, action: string, ...args: any[]): void;
+}
+export type ErrorCallback = (err: Error) => void;
+export type SuccessCallback<T> = (data: T) => void;

package/{lib → packages/device-com-ble.cordova/src/lib}/cordova-service-adapter.d.ts

@@ -1,58 +1,58 @@
-import { ConnectionState } from "@iotize/tap/protocol/api";
-import { CharacteristicAdapterInterface, PeripheralAdapterInterface, ServiceAdapterInterface, DescriptorAdapterInterface, CharacteristicProperties } from "@iotize/tap/protocol/ble/common";
-import { Observable } from "rxjs";
-import { CharacteristicDescription, DescriptorDescription, ServiceDescription } from "./definitions";
-import { IoTizeBleCordovaPlugin } from "./iotize-ble-cordova-plugin";
-export declare class CordovaPeripheralAdapter implements PeripheralAdapterInterface<CordovaServiceAdapter> {
-    readonly deviceId: string;
-    readonly cordovaPlugin: IoTizeBleCordovaPlugin;
-    private _stateChange;
-    private connectionStateSubscription?;
-    private serviceListCache?;
-    get stateChange(): Observable<ConnectionState>;
-    get name(): string;
-    get id(): string;
-    constructor(deviceId: string, cordovaPlugin?: IoTizeBleCordovaPlugin);
-    get state(): string;
-    discoverServices<Key extends string = string>(serviceUUIDs?: Key[]): Promise<Partial<Record<Key, CordovaServiceAdapter>>>;
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    close(): Promise<void>;
-    getService(uuid: string): Promise<CordovaServiceAdapter>;
-}
-export declare class CordovaServiceAdapter implements ServiceAdapterInterface {
-    private readonly config;
-    readonly peripheral: CordovaPeripheralAdapter;
-    get uuid(): string;
-    constructor(config: ServiceDescription, peripheral: CordovaPeripheralAdapter);
-    getCharacteristic(charcUUID: string): Promise<CordovaCharacteristicAdapter>;
-    getCharacteristics(): Promise<CordovaCharacteristicAdapter[]>;
-}
-export declare class CordovaCharacteristicAdapter implements CharacteristicAdapterInterface {
-    readonly service: CordovaServiceAdapter;
-    readonly config: CharacteristicDescription;
-    private _dataStream?;
-    get uuid(): string;
-    constructor(service: CordovaServiceAdapter, config: CharacteristicDescription);
-    get properties(): CharacteristicProperties;
-    get data(): Observable<{
-        data: Uint8Array;
-        isNotification: boolean;
-    }>;
-    protected get deviceId(): string;
-    protected get pluginInterface(): IoTizeBleCordovaPlugin;
-    read(): Promise<Uint8Array>;
-    getDescriptor(): Promise<CordovaDescriptorAdapter>;
-    getDescriptors(): Promise<DescriptorAdapterInterface[]>;
-    write(data: Uint8Array, writeWithoutResponse: boolean): Promise<Uint8Array>;
-    enableNotifications(enabled?: boolean): Promise<void>;
-    setupDataStreamIfRequired(): Observable<Uint8Array>;
-}
-export declare class CordovaDescriptorAdapter implements DescriptorAdapterInterface {
-    readonly config: DescriptorDescription;
-    readonly characteristic: CordovaCharacteristicAdapter;
-    get uuid(): string;
-    constructor(config: DescriptorDescription, characteristic: CordovaCharacteristicAdapter);
-    readValue(): Promise<Uint8Array>;
-    writeValue(data: Uint8Array): Promise<void>;
-}
+import { ConnectionState } from '@iotize/tap/protocol/api';
+import { CharacteristicAdapterInterface, PeripheralAdapterInterface, ServiceAdapterInterface, DescriptorAdapterInterface, CharacteristicProperties } from '@iotize/tap/protocol/ble/common';
+import { Observable } from 'rxjs';
+import { CharacteristicDescription, DescriptorDescription, ServiceDescription } from './definitions';
+import { IoTizeBleCordovaPlugin } from './iotize-ble-cordova-plugin';
+export declare class CordovaPeripheralAdapter implements PeripheralAdapterInterface<CordovaServiceAdapter> {
+    readonly deviceId: string;
+    readonly cordovaPlugin: IoTizeBleCordovaPlugin;
+    private _stateChange;
+    private connectionStateSubscription?;
+    private serviceListCache?;
+    get stateChange(): Observable<ConnectionState>;
+    get name(): string;
+    get id(): string;
+    constructor(deviceId: string, cordovaPlugin?: IoTizeBleCordovaPlugin);
+    get state(): string;
+    discoverServices<Key extends string = string>(serviceUUIDs?: Key[]): Promise<Partial<Record<Key, CordovaServiceAdapter>>>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    close(): Promise<void>;
+    getService(uuid: string): Promise<CordovaServiceAdapter>;
+}
+export declare class CordovaServiceAdapter implements ServiceAdapterInterface {
+    private readonly config;
+    readonly peripheral: CordovaPeripheralAdapter;
+    get uuid(): string;
+    constructor(config: ServiceDescription, peripheral: CordovaPeripheralAdapter);
+    getCharacteristic(charcUUID: string): Promise<CordovaCharacteristicAdapter>;
+    getCharacteristics(): Promise<CordovaCharacteristicAdapter[]>;
+}
+export declare class CordovaCharacteristicAdapter implements CharacteristicAdapterInterface {
+    readonly service: CordovaServiceAdapter;
+    readonly config: CharacteristicDescription;
+    private _dataStream?;
+    get uuid(): string;
+    constructor(service: CordovaServiceAdapter, config: CharacteristicDescription);
+    get properties(): CharacteristicProperties;
+    get data(): Observable<{
+        data: Uint8Array;
+        isNotification: boolean;
+    }>;
+    protected get deviceId(): string;
+    protected get pluginInterface(): IoTizeBleCordovaPlugin;
+    read(): Promise<Uint8Array>;
+    getDescriptor(): Promise<CordovaDescriptorAdapter>;
+    getDescriptors(): Promise<DescriptorAdapterInterface[]>;
+    write(data: Uint8Array, writeWithoutResponse: boolean): Promise<Uint8Array>;
+    enableNotifications(enabled?: boolean): Promise<void>;
+    setupDataStreamIfRequired(): Observable<Uint8Array<ArrayBuffer>>;
+}
+export declare class CordovaDescriptorAdapter implements DescriptorAdapterInterface {
+    readonly config: DescriptorDescription;
+    readonly characteristic: CordovaCharacteristicAdapter;
+    get uuid(): string;
+    constructor(config: DescriptorDescription, characteristic: CordovaCharacteristicAdapter);
+    readValue(): Promise<Uint8Array>;
+    writeValue(data: Uint8Array): Promise<void>;
+}