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

package/packages/tap/client/impl/src/lib/converter/body/array-converter.d.ts

@@ -0,0 +1,15 @@
+import { BodyConverter } from '@iotize/tap/client/api';
+export interface ArrayConverterOptions {
+    /**
+     * Size of one item in byte
+     */
+    sizeOfItem: number;
+}
+export declare class ArrayConverter<ItemType> implements BodyConverter<ItemType[]> {
+    protected _itemConverter: BodyConverter<ItemType>;
+    protected options: ArrayConverterOptions;
+    constructor(_itemConverter: BodyConverter<ItemType>, options: ArrayConverterOptions);
+    get itemConverter(): BodyConverter<ItemType>;
+    decode(bytes: Uint8Array): ItemType[];
+    encode(items: ItemType[]): Uint8Array<ArrayBuffer>;
+}

package/packages/tap/client/impl/src/lib/converter/body/boolean-decoder.d.ts

@@ -0,0 +1,12 @@
+import { BodyDecoder } from '@iotize/tap/client/api';
+import { BodyEncoder } from '@iotize/tap/client/api';
+export declare class BooleanConverter implements BodyEncoder<boolean>, BodyDecoder<boolean> {
+    protected _mask: number;
+    static IS_LEAST_SIGNIFICANT_BIT_FIRST: boolean;
+    static _instance?: BooleanConverter;
+    constructor(_mask?: number);
+    decode(data: Uint8Array): boolean;
+    encode(value: boolean): Uint8Array;
+    static decodeFromNumber(mask: number, value: number): boolean;
+    static instanceBit0(): BooleanConverter;
+}

package/packages/tap/client/impl/src/lib/converter/body/byte-swap-converter.d.ts

@@ -0,0 +1,26 @@
+import { EncoderDecoder } from '@iotize/common/converter/api';
+export declare const BYTE_SWAP_ORDER_REGEX: RegExp;
+export declare class ByteSwapConverter implements EncoderDecoder<Uint8Array, Uint8Array> {
+    order: string;
+    constructor(order: string);
+    encode(input: Uint8Array): Uint8Array;
+    decode(input: Uint8Array): Uint8Array;
+}
+/**
+ * Swap byte position
+ * B0 represents the first byte from the right
+ * BN represents the N byte from the right
+ *
+ * This function is symetric
+ *
+ * Example:
+ * ```typescript
+ * const input = Uint8Array.from([1,2,3,4]);
+ * expect(swapBytes(input, 'B2_B3_B0_B1')).to.be.deep.eq(Uint8Array.from([2,1,4,3]));
+ * ```
+ *
+ * @param input array
+ * @param order string that defined how to swap bytes
+ * @return a new array with byte swap
+ */
+export declare function swapBytes(input: Uint8Array, order: string): Uint8Array;

package/packages/tap/client/impl/src/lib/converter/body/enum-converter.d.ts

@@ -0,0 +1,23 @@
+import { BodyConverter } from '@iotize/tap/client/api';
+export declare abstract class EnumConverter<T> implements BodyConverter<T> {
+    mapping: T;
+    constructor(mapping: T);
+    decode(value: Uint8Array): T;
+    encode(value: T): Uint8Array;
+    abstract decodeToLiteral(value: Uint8Array): number;
+    abstract encodeToLiteral(value: number): Uint8Array;
+}
+export declare class FixedSizeEnumConverter<T> extends EnumConverter<T> {
+    size: number;
+    constructor(mapping: T, size?: number);
+    decodeToLiteral(value: Uint8Array): number;
+    encodeToLiteral(value: number): Uint8Array;
+}
+export declare class EnumListConverter<T> implements BodyConverter<T[]> {
+    size: number;
+    mapping: T;
+    constructor(size: number, mapping: T);
+    decode(value: Uint8Array): T[];
+    encode(values: T[]): Uint8Array;
+    private decodeToLiteral;
+}

package/packages/tap/client/impl/src/lib/converter/body/float-converter.d.ts

@@ -0,0 +1,20 @@
+import { BodyDecoder } from '@iotize/tap/client/api';
+import { BodyEncoder } from '@iotize/tap/client/api';
+export interface FloatConverterOptions {
+}
+export declare class FloatConverter implements BodyEncoder<number>, BodyDecoder<number> {
+    options?: FloatConverterOptions | undefined;
+    private static _instance32?;
+    constructor(options?: FloatConverterOptions | undefined);
+    encode(value: number): Uint8Array;
+    decode(body: Uint8Array): number;
+    /**
+     *
+     * @see https://stackoverflow.com/questions/3096646/how-to-convert-a-floating-point-number-to-its-binary-representation-ieee-754-i
+     * @param number
+     */
+    static toArray(number: number): number;
+    static toFloat(val: Uint8Array): number;
+    static numberToFloat(val: number): number;
+    static instance32(): FloatConverter;
+}

package/packages/tap/client/impl/src/lib/converter/body/hex-string.d.ts

@@ -0,0 +1,8 @@
+import { BodyDecoder } from '@iotize/tap/client/api';
+import { BodyEncoder } from '@iotize/tap/client/api';
+export declare class HexStringConverter implements BodyEncoder<string>, BodyDecoder<string> {
+    static _instance?: HexStringConverter;
+    decode(value: Uint8Array): string;
+    encode(value: string): Uint8Array;
+    static instance(): HexStringConverter;
+}

package/packages/tap/client/impl/src/lib/converter/body/ipv4-string-decoder.d.ts

@@ -0,0 +1,8 @@
+import { BodyDecoder } from '@iotize/tap/client/api';
+import { BodyEncoder } from '@iotize/tap/client/api';
+export declare class Ipv4StringConverter implements BodyDecoder<string>, BodyEncoder<string> {
+    protected static _instance?: Ipv4StringConverter;
+    decode(body: Uint8Array): string;
+    encode(ip: string): Uint8Array;
+    static instance(): Ipv4StringConverter;
+}

package/packages/tap/client/impl/src/lib/converter/body/mac-address-string-decoder.d.ts

@@ -0,0 +1,7 @@
+import { BodyDecoder, BodyEncoder } from '@iotize/tap/client/api';
+export declare class MacAddressStringConverter implements BodyEncoder<string>, BodyDecoder<string> {
+    protected static _instance?: MacAddressStringConverter;
+    decode(body: Uint8Array): string;
+    encode(value: string): Uint8Array;
+    static instance(): MacAddressStringConverter;
+}

package/packages/tap/client/impl/src/lib/converter/body/multiple-mask-decoder.d.ts

@@ -0,0 +1,15 @@
+import { BodyDecoder, BodyEncoder } from '@iotize/tap/client/api';
+export declare class MultipleMaskConverter<OutputType> implements BodyEncoder<OutputType[]>, BodyDecoder<OutputType[]> {
+    protected _mapping: {
+        [key: number]: OutputType;
+    };
+    constructor(mapping: any);
+    decode(body: Uint8Array): OutputType[];
+    /**
+     * TODO check that not use more than the first 7 bits
+     * @param types
+     */
+    encode(types: OutputType[]): Uint8Array;
+    static encodeAll<T>(values: T[], mapping: any): Uint8Array;
+    static decodeAll<T>(value: Uint8Array | number, mapping: any): T[];
+}

package/packages/tap/client/impl/src/lib/converter/body/number-converter.d.ts

@@ -0,0 +1,54 @@
+import { BodyDecoder, BodyEncoder } from '@iotize/tap/client/api';
+export interface NumberDecoderOptions {
+    signed: boolean;
+    /**
+     * Size of number if bits
+     */
+    sizeOf: 8 | 16 | 32;
+    leastSignificantBitFirst: boolean;
+}
+export interface Newable<T> {
+    new (...args: any[]): T;
+}
+export declare class NumberConverter implements BodyEncoder<number>, BodyDecoder<number> {
+    options: NumberDecoderOptions;
+    constructor(options: NumberDecoderOptions);
+    /**
+     * Number as unsigned 8 bits converter
+     * @param lsb true for least significant bit first
+     */
+    static uint8(lsb?: boolean): NumberConverter;
+    /**
+     * Number as unsigned 16 bits converter
+     * @param lsb true for least significant bit first
+     */
+    static uint16(lsb?: boolean): NumberConverter;
+    /**
+     * Number as unsigned 32 bits converter
+     * @param lsb true for least significant bit first
+     */
+    static uint32(lsb?: boolean): NumberConverter;
+    /**
+     * Number as signed 8 bits converter
+     * @param lsb  true for least significant bit first
+     */
+    static int8(lsb?: boolean): NumberConverter;
+    /**
+     * Number as signed 16 bits converter
+     * @param lsb  true for least significant bit first
+     */
+    static int16(lsb?: boolean): NumberConverter;
+    /**
+     * Number as signed 32 bits converter
+     * @param lsb  true for least significant bit first
+     */
+    static int32(lsb?: boolean): NumberConverter;
+    decode(body: Uint8Array): number;
+    encode(value: number): Uint8Array;
+    static toOpaqueMsb(input: number, sizeOf: 8 | 16 | 32 | number): Uint8Array;
+    static fromOpaqueMsb(data: Uint8Array, sizeOf?: number): number;
+    /**
+     * @param size size in bytes
+     */
+    static fromBytes(data: Uint8Array, size: number, signed: boolean, lsb: boolean): number;
+}

package/packages/tap/client/impl/src/lib/converter/body/pipe-converter.d.ts

@@ -0,0 +1,29 @@
+import { EncoderDecoder, EncoderDecoderFct } from '@iotize/common/converter/api';
+import { BodyDecoder } from '@iotize/tap/client/api';
+type PipeConverterType<InputType, OutputType> = EncoderDecoder<OutputType, InputType> | EncoderDecoderFct<InputType, InputType>;
+export declare class PipeConverterBuilder {
+    aliases: {
+        [key: string]: PipeConverterType<any, any>;
+    };
+    constructor(aliases?: {
+        [key: string]: PipeConverterType<any, any>;
+    });
+    pipe<T>(converter: PipeConverterType<Uint8Array, T> | string): PipeConverter<T>;
+}
+/**
+ * Pipe multiple converter one after another
+ */
+export declare class PipeConverter<T> implements BodyDecoder<T> {
+    converters: PipeConverterType<any, any>[];
+    aliases: {
+        [key: string]: PipeConverterType<any, any>;
+    };
+    constructor(converters: PipeConverterType<any, any>[], aliases?: {
+        [key: string]: PipeConverterType<any, any>;
+    });
+    decode(body: Uint8Array): T;
+    encode(value: T): Uint8Array;
+    pipe<OutputType>(converter: PipeConverterType<T, OutputType> | string): PipeConverter<OutputType>;
+    static pipe<T>(converter: PipeConverterType<Uint8Array, T>): PipeConverter<T>;
+}
+export {};

package/packages/tap/client/impl/src/lib/converter/body/string-converter.d.ts

@@ -0,0 +1,44 @@
+import { BodyEncoder } from '@iotize/tap/client/api';
+type TranscodeEncoding = 'ascii' | 'utf8' | 'utf-8' | 'utf16le' | 'utf-16le' | 'ucs2' | 'ucs-2' | 'latin1' | 'binary';
+export declare class StringConverter implements BodyEncoder<string>, BodyEncoder<string> {
+    encoding: TranscodeEncoding;
+    options: {
+        /**
+         * Returns string without content after the end of string character '\0'
+         * 'Hello World!\u0001\u0001\u0001' will returns 'Hello World!'
+         */
+        stripEndOfStringCharacter?: boolean;
+        /**
+         * Replace empty string with '\0'
+         */
+        replaceEmptyStringWithEndOfLineChar?: boolean;
+        /**
+         * true if end of string character should be added when encoding value
+         */
+        addEndOfStringCharacter?: boolean;
+    };
+    private static _ascii?;
+    constructor(encoding?: TranscodeEncoding, options?: {
+        /**
+         * Returns string without content after the end of string character '\0'
+         * 'Hello World!\u0001\u0001\u0001' will returns 'Hello World!'
+         */
+        stripEndOfStringCharacter?: boolean;
+        /**
+         * Replace empty string with '\0'
+         */
+        replaceEmptyStringWithEndOfLineChar?: boolean;
+        /**
+         * true if end of string character should be added when encoding value
+         */
+        addEndOfStringCharacter?: boolean;
+    });
+    encode(value: string): Uint8Array;
+    decode(value: Uint8Array): string;
+    /**
+     * Get ascii instance
+     * @deprecated use constructor instead
+     */
+    static ascii(): StringConverter;
+}
+export {};

package/packages/tap/client/impl/src/lib/converter/body/string-version-converter.d.ts

@@ -0,0 +1,6 @@
+import { BodyConverter } from '@iotize/tap/client/api';
+import { TapStreamReader, TapStreamWriter } from '../../frame/tap-stream-core';
+export declare class StringVersionConverter implements BodyConverter<string> {
+    encode(version: string, stream?: TapStreamWriter): Uint8Array;
+    decode(data: TapStreamReader | Uint8Array): string;
+}

package/packages/tap/client/impl/src/lib/converter/body/tlv-bundle-converter.d.ts

@@ -0,0 +1,22 @@
+import { EncoderDecoder } from '@iotize/common/converter/api';
+import { TLV } from '@iotize/common/tlv';
+import { BodyConverter } from '@iotize/tap/client/api';
+import { TLVConverter } from '../tlv-converter';
+interface VariableMeta {
+    id: number;
+    converter?: EncoderDecoder<any, Uint8Array>;
+    name?: string;
+}
+export declare class TlvBundleConverter<DataType = Record<string, Uint8Array>> implements BodyConverter<DataType> {
+    protected variables: VariableMeta[];
+    protected tlvConverter: TLVConverter;
+    bundleId: number;
+    constructor(variables?: VariableMeta[], tlvConverter?: TLVConverter);
+    decode(data: Uint8Array | TLV.TlvNode, context?: any): DataType;
+    encode(data: DataType): Uint8Array;
+    /**
+     * Converter tlv tree to variable name => value
+     */
+    private _convertFromTlvTree;
+}
+export {};

package/packages/tap/client/impl/src/lib/converter/body/uniq-mask-decoder.d.ts

@@ -0,0 +1,29 @@
+import { BodyDecoder, BodyEncoder } from '@iotize/tap/client/api';
+/**
+ * TODO improv it . We don't know the size of input buffer...
+ */
+export declare class UniqMaskConverter<OutputType> implements BodyEncoder<OutputType>, BodyDecoder<OutputType> {
+    protected _mapping: {
+        [key: number]: OutputType;
+    };
+    constructor(mapping: any);
+    decode(body: Uint8Array): OutputType;
+    encode(value: OutputType): Uint8Array;
+    static decodeOneExact<OutputType>(data: Uint8Array | number, mapping: {
+        [key: number]: OutputType;
+    }): OutputType;
+    static decodeOne<OutputType>(data: Uint8Array | number, mapping: {
+        [key: number]: OutputType;
+    }): OutputType;
+    static encodeOneAsNumber<OutputType>(data: OutputType, mapping: {
+        [key: number]: OutputType;
+    }): number;
+    static encodeOneAsBuffer<OutputType>(data: OutputType, mapping: {
+        [key: number]: OutputType;
+    }): Uint8Array;
+    static swapKeyValue(input: {
+        [key: string]: any;
+    }): {
+        [key: string]: any;
+    };
+}

package/packages/tap/client/impl/src/lib/converter/crypted-frame-converter.d.ts

@@ -0,0 +1,13 @@
+import { Decoder, Encoder } from '@iotize/common/converter/api';
+export interface CryptoFrameIdGenerator {
+    next(): number;
+}
+/**
+ *
+ */
+export declare class CryptedFrameConverter implements Encoder<Uint8Array, Uint8Array>, Decoder<Uint8Array, Uint8Array> {
+    frameIdGenerator: CryptoFrameIdGenerator;
+    constructor(frameIdGenerator: CryptoFrameIdGenerator);
+    encode(data: Uint8Array): Uint8Array;
+    decode(frame: Uint8Array): Uint8Array;
+}

package/packages/tap/client/impl/src/lib/converter/error.d.ts

@@ -0,0 +1,15 @@
+import { CodeError } from '@iotize/common/error';
+export declare class ConverterError extends CodeError<ConverterError.Code> {
+    cause?: Error | undefined;
+    constructor(code: ConverterError.Code, msg: string, cause?: Error | undefined);
+    static unexpectedBufferSize(expected: number, buffer: Uint8Array): ConverterError;
+    static nullBufferError(msg: string): ConverterError;
+    static valueTooBigError(value: number, maxValue: number): ConverterError;
+}
+export declare namespace ConverterError {
+    enum Code {
+        UnexpectedBufferSizeError = "UnexpectedBufferSizeError",
+        NullBufferError = "NullBufferError",
+        ValueTooBigError = "ConverterErrorValueTooBigError"
+    }
+}

package/packages/tap/client/impl/src/lib/converter/tlv-converter.d.ts

@@ -0,0 +1,9 @@
+import { EncoderDecoder } from '@iotize/common/converter/api';
+import { TLV } from '@iotize/common/tlv';
+export declare class TLVConverter implements EncoderDecoder<TLV.TlvNode, Uint8Array> {
+    serializer: TLV.Serializer;
+    parser: TLV.Parser;
+    constructor();
+    encode(data: TLV.TlvNode): Uint8Array;
+    decode(data: Uint8Array): TLV.TlvNode;
+}

package/packages/tap/client/impl/src/lib/converters.d.ts

@@ -0,0 +1,13 @@
+import { EncoderDecoder } from '@iotize/common/converter/api';
+import { TapRequestFrame, TapResponseFrame } from '@iotize/tap/client/api';
+import { TapStreamReader } from './frame/import-adapter';
+export declare class TapApduRequestConverter implements EncoderDecoder<TapRequestFrame, Uint8Array> {
+    encode(tapRequest: TapRequestFrame): Uint8Array<ArrayBuffer>;
+    decode(bufferData: Uint8Array | TapStreamReader): TapRequestFrame;
+}
+export declare class TapApduResponseConverter implements EncoderDecoder<TapResponseFrame, Uint8Array> {
+    encode(tapResponseFrame: TapResponseFrame): Uint8Array<ArrayBuffer>;
+    decode(bufferData: Uint8Array | TapStreamReader): TapResponseFrame;
+}
+export declare const TAP_REQUEST_FRAME_CONVERTER: TapApduRequestConverter;
+export declare const TAP_RESPONSE_FRAME_CONVERTER: TapApduResponseConverter;

package/packages/tap/client/impl/src/lib/debug.d.ts

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

package/packages/tap/client/impl/src/lib/error-detection/checksum.d.ts

@@ -0,0 +1,3 @@
+export declare class Checksum {
+    static compute(data: Uint8Array): number;
+}

package/packages/tap/client/impl/src/lib/error-detection/crc.d.ts

@@ -0,0 +1,12 @@
+export declare class CRC {
+    readonly polynomial: number;
+    static POLYNOMIAL_CRC32_MPEG2: number;
+    static MODULO: number;
+    static FIRST_VALUE: number;
+    static mpeg2(): CRC;
+    constructor(polynomial: number);
+    compute(buffer: Uint32Array | Uint8Array, firstValue?: number): number;
+    static fromBytes(data: Uint8Array, crc?: number, polynomial?: number): number;
+    static fromWord(buffer: Uint32Array, crc?: number, polynomial?: number): number;
+    static appendCrcNumber(crc: number, data: number, polynomial: number): number;
+}

package/packages/tap/client/impl/src/lib/frame/import-adapter.d.ts

@@ -0,0 +1 @@
+export { TapStreamReader, TapStreamWriter } from './tap-stream-extended';

package/packages/tap/client/impl/src/lib/frame/tap-stream-core.d.ts

@@ -0,0 +1,41 @@
+import { KaitaiStreamReader, KaitaiStreamWriter, StreamBufferType } from '@iotize/common/byte-stream';
+export declare function enumKeyOrValueToNumber<T>(key: string | number | T, mapping: any): number;
+export declare class TapStreamReader extends KaitaiStreamReader {
+    static fromArray(array: Uint8Array): TapStreamReader;
+    static create(packet: Uint8Array | TapStreamReader): TapStreamReader;
+    readStr(n: number): string;
+    /**
+     * Read given byte size as string
+     * @param n number of byte to read
+     */
+    readString(n?: number): string;
+    /**
+     * Read string until terminator character is reached
+     */
+    readStringTerminator(terminator: string): string;
+    readU2(): number;
+    readU4(): number;
+    readF4(): number;
+    subStream(length: number): TapStreamReader;
+}
+export declare class TapStreamWriter extends KaitaiStreamWriter {
+    constructor(lengthOrBuffer?: number | StreamBufferType, byteOffset?: number, isBigEndian?: boolean);
+    static create(size: number): TapStreamWriter;
+    writeFunction(type: string, options: any, fieldValue?: any, fieldSize?: any): this;
+    addPadding(padSize: number): this;
+    addCRC(options?: {
+        offset?: number;
+    }): this;
+    writeUnsigned(value: number, length: number): this;
+    writeU4(value: number): this;
+    writeU2(value: number): this;
+    writeU1(value: number): this;
+    writeF4(value: number): this;
+    writeFloat(value: number, length: number): this;
+    writeSigned(value: number, length: number): this;
+    writeString(value: string | undefined, length?: number): this;
+    writeStr(value: string, length?: number): this;
+    writeBitsInt(value: number, n: number): this;
+    writeBits(value: number, n: number): this;
+    writeBoolean(value: number | boolean, n: number): this;
+}

package/packages/tap/client/impl/src/lib/frame/tap-stream-encoder-decoder.d.ts

@@ -0,0 +1,5 @@
+import { TapStreamReader, TapStreamWriter } from './tap-stream-extended';
+export interface TapStreamEncoderDecoder<DataType> {
+    encode(v: DataType, stream: TapStreamWriter): void;
+    decode(stream: TapStreamReader): DataType;
+}

package/packages/tap/client/impl/src/lib/frame/tap-stream-extended.d.ts

@@ -0,0 +1,2 @@
+import '../generated-adapter';
+export { TapStreamReader, TapStreamWriter } from './tap-stream-core';

package/packages/tap/client/impl/src/lib/generated/converter-stream-extension.d.ts

@@ -0,0 +1,30 @@
+/**
+ *   Generated file. Do not edit
+ */
+import { ApduRequest, ApduResponse, TapRequestEncrypted, TapApduRequest, TapEncryptedFrame, TapRequestFrame, TapResponseFrame } from '@iotize/tap/client/api';
+declare module '../frame/tap-stream-core' {
+    interface TapStreamReader {
+        readApduRequest(): ApduRequest;
+        readApduRequestHeader(): ApduRequest.Header;
+        readApduResponse(): ApduResponse;
+        readTapRequestEncrypted(): TapRequestEncrypted;
+        readTapApduRequest(): TapApduRequest;
+        readTapEncryptedFrame(): TapEncryptedFrame;
+        readTapRequestFrame(): TapRequestFrame;
+        readTapRequestFrameHeader(): TapRequestFrame.Header;
+        readTapRequestFramePath(): TapRequestFrame.Path;
+        readTapResponseFrame(): TapResponseFrame;
+    }
+    interface TapStreamWriter {
+        writeApduRequest(model: ApduRequest): TapStreamWriter;
+        writeApduRequestHeader(model: ApduRequest.Header): TapStreamWriter;
+        writeApduResponse(model: ApduResponse): TapStreamWriter;
+        writeTapRequestEncrypted(model: TapRequestEncrypted): TapStreamWriter;
+        writeTapApduRequest(model: TapApduRequest): TapStreamWriter;
+        writeTapEncryptedFrame(model: TapEncryptedFrame): TapStreamWriter;
+        writeTapRequestFrame(model: TapRequestFrame): TapStreamWriter;
+        writeTapRequestFrameHeader(model: TapRequestFrame.Header): TapStreamWriter;
+        writeTapRequestFramePath(model: TapRequestFrame.Path): TapStreamWriter;
+        writeTapResponseFrame(model: TapResponseFrame): TapStreamWriter;
+    }
+}

package/packages/tap/client/impl/src/lib/generated/converter.d.ts

@@ -0,0 +1,35 @@
+/**
+ *   Generated file. Do not edit
+ */
+import './converter-stream-extension';
+import { BodyConverter } from '@iotize/tap/client/api';
+import { ApduRequest, ApduResponse, TapRequestEncrypted, TapApduRequest, TapEncryptedFrame, TapRequestFrame, TapResponseFrame } from '@iotize/tap/client/api';
+import { TapStreamReader, TapStreamWriter } from '../frame/tap-stream-core';
+export declare class ApduRequestConverter implements BodyConverter<ApduRequest> {
+    encode(model: ApduRequest, stream?: TapStreamWriter): Uint8Array;
+    decode(data: TapStreamReader | Uint8Array): ApduRequest;
+}
+export declare class ApduResponseConverter implements BodyConverter<ApduResponse> {
+    encode(model: ApduResponse, stream?: TapStreamWriter): Uint8Array;
+    decode(data: TapStreamReader | Uint8Array): ApduResponse;
+}
+export declare class TapRequestEncryptedConverter implements BodyConverter<TapRequestEncrypted> {
+    encode(model: TapRequestEncrypted, stream?: TapStreamWriter): Uint8Array;
+    decode(data: TapStreamReader | Uint8Array): TapRequestEncrypted;
+}
+export declare class TapApduRequestConverter implements BodyConverter<TapApduRequest> {
+    encode(model: TapApduRequest, stream?: TapStreamWriter): Uint8Array;
+    decode(data: TapStreamReader | Uint8Array): TapApduRequest;
+}
+export declare class TapEncryptedFrameConverter implements BodyConverter<TapEncryptedFrame> {
+    encode(model: TapEncryptedFrame, stream?: TapStreamWriter): Uint8Array;
+    decode(data: TapStreamReader | Uint8Array): TapEncryptedFrame;
+}
+export declare class TapRequestFrameConverter implements BodyConverter<TapRequestFrame> {
+    encode(model: TapRequestFrame, stream?: TapStreamWriter): Uint8Array;
+    decode(data: TapStreamReader | Uint8Array): TapRequestFrame;
+}
+export declare class TapResponseFrameConverter implements BodyConverter<TapResponseFrame> {
+    encode(model: TapResponseFrame, stream?: TapStreamWriter): Uint8Array;
+    decode(data: TapStreamReader | Uint8Array): TapResponseFrame;
+}

package/packages/tap/client/impl/src/lib/generated-adapter.d.ts

@@ -0,0 +1,2 @@
+export * from './generated/converter';
+import './generated/converter-stream-extension';

package/packages/tap/client/impl/src/lib/interceptors/interceptor-chain.d.ts

@@ -0,0 +1,9 @@
+import { ExecutionContext, RequestInterceptor, RequestInterceptorType, TapResponseFrame } from '@iotize/tap/client/api';
+import { Observable } from 'rxjs';
+export declare class InterceptorChain {
+    private target;
+    interceptors: RequestInterceptor[];
+    constructor(target: (context: ExecutionContext) => Observable<TapResponseFrame>);
+    addInterceptor(interceptor: RequestInterceptorType): this;
+    execute<T>(context: ExecutionContext): Observable<TapResponseFrame>;
+}

package/packages/tap/client/impl/src/lib/model/models.extensions.d.ts

@@ -0,0 +1,2 @@
+import { TapEncryptedFrame } from '@iotize/tap/client/api';
+export declare function createTapEncryptedFrame(id: number, payload: Uint8Array, paddingGenerator?: (size: number) => Uint8Array): TapEncryptedFrame;

package/packages/tap/client/impl/src/lib/request/tap-request-builder.d.ts

@@ -0,0 +1,13 @@
+import { TapRequestFrame } from '@iotize/tap/client/api';
+export declare class TapRequestFrameBuilder {
+    static MAX_ID: number;
+    static parsePath(path: string): TapRequestFrame.Path;
+    static GET(url: string, body?: Uint8Array): TapRequestFrame;
+    static PUT(url: string, body?: Uint8Array): TapRequestFrame;
+    static POST(url: string, body?: Uint8Array): TapRequestFrame;
+    static create(method: TapRequestFrame.MethodType, url: string, data?: Uint8Array): TapRequestFrame;
+    static validateId(id: number): number;
+}
+export declare namespace TapRequestFrameBuilder {
+    const PATH_EXPRESSION: RegExp;
+}

package/packages/tap/client/impl/src/lib/request/tap-request-helper.d.ts

@@ -0,0 +1,9 @@
+import { TapRequestFrame } from '@iotize/tap/client/api';
+export declare class TapRequestHelper {
+    static toString(request: TapRequestFrame, options?: {
+        printMaxId?: boolean;
+    }): string;
+    static pathToString(path: TapRequestFrame.Path, options?: {
+        printMaxId?: boolean;
+    }): string;
+}