/**
 * This file has been generated
 * DO NOT EDIT, IT MAY BE OVERWRITTEN
 */
import { TapRequest } from './import-adapter';
import { TapResponse } from './import-adapter';
export interface Types {
}
export declare namespace Types {
}
export declare enum VariableFormat {
    _1_BIT = 0,
    _8_BITS = 1,
    _16_BITS = 2,
    _32_BITS = 3
}
export declare enum VariableType {
    BOOLEAN = 0,
    INT8 = 1,
    INT16 = 2,
    INT32 = 3,
    UINT8 = 33,
    UINT16 = 34,
    UINT32 = 35,
    FLOAT32 = 19,
    STRING = 128
}
export declare enum AvailablePowerSource {
    DC_POWER = 1,
    S3P = 16,
    AC_EXTERNAL_POWER = 32
}
export declare enum FirmwareState {
    NORMAL = 1,
    UPDATING = 2,
    UPDATED = 4
}
export declare enum FirmwareUpdateResult {
    DEFAULT_VALUE = 0,
    UPDATE_SUCCESSFUL = 1,
    NOT_ENOUGH_MEMORY = 2,
    OUT_OF_MEMORY = 4,
    CONNECTION_LOST = 8,
    CRC_CHECK_FAILURE = 16,
    UNSUPPORTED_PACKAGE_TYPE = 32,
    INVALID_URI = 64
}
export declare enum HostProtocol {
    NFC = 1,
    BLUETOOTH = 2,
    GSM = 4,
    USB_RLINK = 8,
    USB_CMISIS_DAP = 16,
    WIFI = 32,
    BLE = 64
}
export declare enum LowPowerOptimisationLevel {
    NO = 0,
    STANDBY = 2,
    SHUTDOWN = 3
}
export declare enum NetworkMode {
    PEER_TO_PEER = 0,
    INFRASTRUCTURE_ONLY = 1,
    INFRASTRUCTURE_CLOUD = 2
}
export declare enum CloudConnectionMode {
    GENERIC = 0,
    IBM_BLUEMIX = 1,
    MICROSOFT_AZURE = 2,
    AMAZON_AWS = 4
}
export declare enum TargetProtocol {
    SWD = 0,
    S3P = 1,
    JTAG = 2,
    MODBUS = 3,
    GPIO = 4,
    SERIAL_STANDARD = 5,
    SERIAL_VIA_TAPNPASS = 6,
    NONE = 255
}
export declare enum CoreType {
    M0_CORTEX = 1,
    M2_CORTEX = 2,
    M3_CORTEX = 3
}
export declare enum NfcPairingMode {
    NO = 0,
    MANDATORY = 1,
    MANDATORY_FOR_LOGIN = 2
}
export declare enum TargetCoreType {
    M0_CORTEX = 0,
    M1_CORTEX = 1
}
export declare enum SpecialFeature {
    SWD_DIRECT_ACCESS = 100,
    SERIAL_ACCESS = 101,
    MODBUS_DIRECT_ACCESS = 102,
    TAPNPASS_CONTROL_ACCESS = 103,
    SP_CODEEXEC_ACCESS = 104
}
export declare enum NfcConnectionPriority {
    NFC_PRIORITY = 0,
    NFC_NON_PRIORITY = 1
}
export interface AclEntry {
    /**
     *
     */
    create: boolean;
    /**
     *
     */
    delete: boolean;
    /**
     *
     */
    execute: boolean;
    /**
     *
     */
    write: boolean;
    /**
     *
     */
    read: boolean;
}
export declare namespace AclEntry {
}
export interface MemoryInfo {
    /**
     * Address
     */
    address: number;
    /**
     * Number of word
     */
    length: number;
    /**
     * Size of one word
     */
    format: VariableFormat;
}
export declare namespace MemoryInfo {
}
export interface MemoryWriteInfo {
    /**
     *
     */
    info: MemoryInfo;
    /**
     *
     */
    data: Uint8Array;
}
export declare namespace MemoryWriteInfo {
}
export interface ReadWriteRights {
    /**
     *
     */
    groupId: number;
    /**
     *
     */
    write: boolean;
    /**
     *
     */
    read: boolean;
}
export declare namespace ReadWriteRights {
}
export interface DataLogOption {
    /**
     * True if packets are stored encrypted
     */
    security: boolean;
    /**
     * Quality Of Service
     */
    qos: boolean;
    /**
     * True to create a new data log packet when value change
     */
    logOnChange: boolean;
    /**
     *
     */
    rollingMode: boolean;
    /**
     * True to automatically run data log when tap is powered on
     */
    autorun: boolean;
}
export declare namespace DataLogOption {
}
export interface UartSettings {
    /**
     *
     */
    slv: number;
    /**
     *
     */
    ofs: boolean;
    /**
     *
     */
    baudRate: number;
    /**
     *
     */
    physicalPort: UartSettings.PhysicalPort;
    /**
     *
     */
    stopBit: UartSettings.StopBit;
    /**
     *
     */
    bitParity: UartSettings.BitParity;
    /**
     *
     */
    dataBitsLength: UartSettings.DataBitsLength;
    /**
     *
     */
    handshakeDelimiter: UartSettings.HandshakeDelimiter;
    /**
     *
     */
    handshakeValue: UartSettings.Handshake;
    /**
     *
     */
    timeout: number;
}
export declare namespace UartSettings {
    enum BitParity {
        NONE = 0,
        ODD = 1,
        EVEN = 2
    }
    enum Handshake {
        NONE = 0,
        RTS = 1,
        CTS = 2,
        RTS_CTS = 3
    }
    enum StopBit {
        ONE = 0,
        ONE_AND_HALF = 1,
        TWO = 2
    }
    enum PhysicalPort {
        NONE = 0,
        RS232 = 1,
        USB = 3,
        AUTO = 6,
        RS485 = 10
    }
    enum HandshakeDelimiter {
        NONE = 0,
        CR = 1,
        LF = 2,
        CR_LF = 3
    }
    enum DataBitsLength {
        _7 = 0,
        _8 = 1,
        _9 = 2
    }
}
export interface ProtocolConfiguration {
    /**
     *
     */
    slv: number;
    /**
     *
     */
    ofs: boolean;
    /**
     *
     */
    baudRate: number;
    /**
     *
     */
    identification: boolean;
    /**
     *
     */
    ledStatus: boolean;
    /**
     *
     */
    physicalPort: UartSettings.PhysicalPort;
    /**
     *
     */
    stopBit: UartSettings.StopBit;
    /**
     *
     */
    bitParity: UartSettings.BitParity;
    /**
     *
     */
    dataBitsLength: UartSettings.DataBitsLength;
    /**
     *
     */
    handshakeDelimiter: UartSettings.HandshakeDelimiter;
    /**
     *
     */
    handshakeValue: UartSettings.Handshake;
    /**
     *
     */
    timeout: number;
    /**
     *
     */
    usbSettings: ProtocolConfiguration.UsbSettings;
}
export declare namespace ProtocolConfiguration {
    interface UsbSettings {
        /**
     *
     */
        aliases: Array<ProtocolConfiguration.UsbAlias>;
    }
    interface UsbAlias {
        /**
     *
     */
        pid: Uint8Array;
        /**
     *
     */
        vid: Uint8Array;
        /**
     *
     */
        equ: number;
    }
}
export interface TapVersion {
    /**
     *
     */
    major: number;
    /**
     *
     */
    minor: number;
    /**
     *
     */
    patch: number;
}
export declare namespace TapVersion {
}
export interface Lwm2mTlv {
    /**
     * 00= Object Instance in which case the Value contains one or more Resource TLVs 01= Resource Instance with Value for use within a multiple Resource TLV 10= multiple Resource, in which case the Value contains one or more Resource Instance TLVs 11= Resource with Value
     */
    identifierType: number;
    /**
     * Indicates the Length of the Identifier. 0=The Identifier field of this TLV is 8 bits long 1=The Identifier field of this TLV is 16 bits long
     */
    identifierLength: boolean;
    /**
     * 00=No length field, the value immediately follows the Identifier field in is of the length indicated by Bits 2-0 of this field 01 = The Length field is 8-bits and Bits 2-0 MUST be ignored 10 = The Length field is 16-bits and Bits 2-0 MUST be ignored 11 = The Length field is 24-bits and Bits 2-0 MUST be ignored
     */
    lengthType: number;
    /**
     * A 3-bit unsigned integer indicating the Length of the Value.
     */
    other: number;
    /**
     *
     */
    identifier: Uint8Array;
    /**
     *
     */
    len: number;
    /**
     *
     */
    value: Uint8Array;
}
export declare namespace Lwm2mTlv {
}
export interface InterfaceLock {
    /**
     * true if scram is activated
     */
    scramActivated: boolean;
    /**
     * true if login is done using the hash of the password instead of the password itself
     */
    hashPassword: boolean;
    /**
     * true to disable factory reset using hardware
     */
    factoryReset: boolean;
    /**
     * true to disable login using UID (resource /1024//5)
     */
    resourceLogUid: boolean;
    /**
     * true to disable factory reset using LwM2M resource
     */
    resourceFactory: boolean;
}
export declare namespace InterfaceLock {
}
export interface LoginCredential {
    /**
     *
     */
    username: string;
    /**
     *
     */
    password: string;
}
export declare namespace LoginCredential {
}
export interface LoginCredentialHashed {
    /**
     *
     */
    username: string;
    /**
     *
     */
    password: Uint8Array;
}
export declare namespace LoginCredentialHashed {
}
export interface ScramLoginParams {
    /**
     *
     */
    username: string;
    /**
     *
     */
    clientNonce: number;
}
export declare namespace ScramLoginParams {
}
export interface ScramLoginResponseBody {
    /**
     *
     */
    serverNonce: number;
    /**
     *
     */
    salt: Uint8Array;
    /**
     *
     */
    iterationNumber: number;
}
export declare namespace ScramLoginResponseBody {
}
export interface TargetComStats {
    /**
     *
     */
    nbFailCom: number;
    /**
     *
     */
    nbSuccessfulCom: number;
}
export declare namespace TargetComStats {
}
export interface AvailableFunction {
    /**
     *
     */
    debug: boolean;
    /**
     *
     */
    dataLog: boolean;
}
export declare namespace AvailableFunction {
}
export interface MultiRequest {
    /**
     *
     */
    requests: Array<MultiRequest.RequestItem>;
}
export declare namespace MultiRequest {
    interface RequestItem {
        /**
     *
     */
        requestLen: number;
        /**
     *
     */
        request: TapRequest;
        /**
     *
     */
        expectedCodeRet: number;
    }
    enum ExpectedResultCode {
        SUCCESS = 127,
        ANYTHING = 255
    }
}
export interface MultiResponse {
    /**
     *
     */
    responses: Array<MultiResponse.ResponseItem>;
}
export declare namespace MultiResponse {
    interface ResponseItem {
        /**
     *
     */
        responseLen: number;
        /**
     *
     */
        response: TapResponse;
    }
}
export interface CrcCheckBody {
    /**
     *
     */
    address: number;
    /**
     *
     */
    size: number;
    /**
     *
     */
    crc: number;
}
export declare namespace CrcCheckBody {
}
export interface SinglePacket {
    /**
     *
     */
    sendTime: number;
    /**
     *
     */
    outerHeader: SinglePacket.OuterHeader;
    /**
     *
     */
    payload: SinglePacket.Payload;
}
export declare namespace SinglePacket {
    interface OuterHeader {
        /**
     * Packet length is full size without send_time. When encoded, it is a multile of 16 when encryption is enabled and a multiple of 256 when is_extended is enabled
     */
        packetLength: number;
        /**
     *
     */
        packetId: number;
        /**
     *
     */
        configVersion: number;
        /**
     *
     */
        messageType: SinglePacket.PacketType;
        /**
     * if true, packet length is a multiple of 256
     */
        isExtended: boolean;
        /**
     *
     */
        encryption: boolean;
        /**
     *
     */
        ack: boolean;
        /**
     *
     */
        senderId: number;
        /**
     *
     */
        salt: number;
    }
    interface Payload {
        /**
     *
     */
        logTime: number;
        /**
     * Same as packet_length, size depends on the unit. In case of a code_exec packet, this is not used
     */
        dataSize: number;
        /**
     *
     */
        data: Uint8Array;
        /**
     * Padding on 4 bytes (usefull to compute CRC)
     */
        padding?: Uint8Array;
        /**
     * CRC32 is computed starting from field packet_length
     */
        crc?: number;
    }
    enum PacketType {
        MASK = 7,
        DATA_LOG = 1,
        COMMAND = 2,
        CODE_EXEC = 3,
        CONF_UPDATE = 4,
        SECURITY_TOKEN = 5,
        TARGET_FW_UPDATE = 6
    }
}
export interface AclEntries {
    /**
     *
     */
    items: Array<AclEntry>;
}
export declare namespace AclEntries {
}
export interface LoraConfig {
    /**
     *
     */
    classA: boolean;
    /**
     *
     */
    classB: boolean;
    /**
     *
     */
    classC: boolean;
    /**
     *
     */
    dataLoggingEnabled: boolean;
    /**
     *
     */
    singlePacketEnabled: boolean;
}
export declare namespace LoraConfig {
}
export interface SinglePacketPart {
    /**
     * Number of 16 bytes word
     */
    len: number;
    /**
     * Offset in 16 bytes words
     */
    offset: number;
    /**
     *
     */
    data: Uint8Array;
}
export declare namespace SinglePacketPart {
}
export interface ModbusOptions {
    /**
     * Modbus object type
    * @see <a href="https://en.wikipedia.org/wiki/Modbus#Modbus_object_types">https://en.wikipedia.org/wiki/Modbus#Modbus_object_types</a>
     */
    objectType: ModbusOptions.ObjectType;
    /**
     * Slave address
     */
    slave: number;
    /**
     * Modbus address to read
     */
    address: number;
    /**
     * Number of word to read
     */
    length: number;
    /**
     * Variable format (only on for variables)
     */
    format: VariableFormat;
}
export declare namespace ModbusOptions {
    enum ObjectType {
        DEFAULT = 0,
        COIL = 1,
        DISCRET_INPUT = 2,
        HOLDING_REGISTER = 3,
        INPUT_REGISTER = 4
    }
}
export interface ModbusWriteOptions {
    /**
     *
     */
    options: ModbusOptions;
    /**
     * Modbus data
     */
    data: Uint8Array;
}
export declare namespace ModbusWriteOptions {
}
export interface SinglePacketStoreInfo {
    /**
     *
     */
    state: SinglePacketStoreInfo.State;
}
export declare namespace SinglePacketStoreInfo {
    enum State {
        UNAVAILABLE = 0,
        EMPTY = 1,
        USED = 2,
        FULL = 3,
        ERROR = 4
    }
}
export interface AdpControlIn {
    /**
     *
     */
    command: AdpControlIn.Command;
    /**
     *
     */
    param: number;
}
export declare namespace AdpControlIn {
    enum Command {
        NONE = 0,
        ZIP = 32769,
        UNZIP = 32770,
        SET_TRANSMISSION_BUFFER_SIZE = 32771,
        TOTAL_BUFFER_SIZE = 32772,
        GET_TRANSMISSION_BUFFER_SIZE = 32773,
        SET_RESPONSE_DELIMITER_LOW = 32774,
        SET_RESPONSE_DELIMITER_HIGH = 32775,
        SET_COMMAND_DELIMITER_LOW = 32776,
        EXEC_COMMANDS = 32777
    }
}
export interface AdpControlOut {
    /**
     * Result code
     */
    resultCode: AdpControlOut.ResultCode;
    /**
     *
     */
    param: number;
}
export declare namespace AdpControlOut {
    enum ResultCode {
        NONE = 0,
        OK = 32768,
        ZIP_TIMEOUT = 32769,
        UNZIP_TIMEOUT = 32770,
        ZIP_ERROR = 32771,
        UNZIP_ERROR = 32772,
        UNKNOWN_COMMAND = 32773,
        INVALID_PARAM = 32774
    }
}
export interface AdpStats {
    /**
     *
     */
    header: AdpStats.Header;
    /**
     *
     */
    state: AdpStats.State;
    /**
     *
     */
    uart: AdpStats.Uart;
    /**
     *
     */
    usb: AdpStats.Usb;
    /**
     *
     */
    current: Uint8Array;
    /**
     *
     */
    com: AdpStats.Com;
    /**
     *
     */
    battery: Uint8Array;
    /**
     *
     */
    intern: AdpStats.Intern;
}
export declare namespace AdpStats {
    interface Header {
        /**
     *
     */
        version: AdpStats.Version;
        /**
     *
     */
        errorCode: number;
    }
    interface Version {
        /**
     *
     */
        major: number;
        /**
     *
     */
        minor: number;
        /**
     *
     */
        patch: number;
    }
    interface Intern {
        /**
     *
     */
        time: Uint8Array;
        /**
     *
     */
        nbBoots: Uint8Array;
        /**
     *
     */
        nbShutdown: Uint8Array;
        /**
     *
     */
        nbAdpFault: Uint8Array;
        /**
     *
     */
        nbAdpMemFault: Uint8Array;
        /**
     *
     */
        nbAdpBusFault: Uint8Array;
        /**
     *
     */
        nbAdpUsageFault: Uint8Array;
        /**
     *
     */
        temperature: Uint8Array;
    }
    interface State {
        /**
     *
     */
        usbDisconnected: boolean;
    }
    interface Uart {
        /**
     *
     */
        nbPartityError: number;
        /**
     *
     */
        nbNoiseError: number;
        /**
     *
     */
        nbFrameError: number;
        /**
     *
     */
        nbDmaError: number;
        /**
     *
     */
        nbTxError: number;
        /**
     *
     */
        nbRxError: number;
        /**
     *
     */
        nbOverRun: number;
    }
    interface Usb {
        /**
     *
     */
        nbFail: number;
        /**
     *
     */
        nbTimeout: number;
        /**
     *
     */
        nbError: number;
        /**
     *
     */
        nbUnknownClass: number;
        /**
     *
     */
        nbDisconnect: number;
        /**
     *
     */
        nbOff: number;
    }
    interface Com {
        /**
     *
     */
        txBufferOverRun: number;
        /**
     *
     */
        rxBufferOverRun: number;
        /**
     *
     */
        nbErrorSettings: number;
        /**
     *
     */
        nbComAdp: Uint8Array;
    }
}
export interface EncryptedIVCommand {
    /**
     *
     */
    iv: Uint8Array;
    /**
     *
     */
    command: Uint8Array;
}
export declare namespace EncryptedIVCommand {
}
export interface EncryptedIVResponse {
    /**
     *
     */
    iv: Uint8Array;
    /**
     *
     */
    response: Uint8Array;
}
export declare namespace EncryptedIVResponse {
}
