(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@iotize/tap/client/api'), require('@iotize/tap/service/core'), require('@iotize/tap/client/impl'), require('@iotize/tap')) :
    typeof define === 'function' && define.amd ? define('@iotize/tap/service/impl/interface', ['exports', '@iotize/tap/client/api', '@iotize/tap/service/core', '@iotize/tap/client/impl', '@iotize/tap'], factory) :
    (global = global || self, factory((global.iotize = global.iotize || {}, global.iotize.tap = global.iotize.tap || {}, global.iotize.tap.service = global.iotize.tap.service || {}, global.iotize.tap.service.impl = global.iotize.tap.service.impl || {}, global.iotize.tap.service.impl.interface = {}), global.iotize.tap.client.api, global.iotize.tap.service.core, global.iotize.tap.client.impl, global.iotize.tap));
}(this, (function (exports, api, core, impl, tap) { 'use strict';

    /**
     *   Generated file. Do not edit
     */
    var __values = (this && this.__values) || function(o) {
        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
        if (m) return m.call(o);
        if (o && typeof o.length === "number") return {
            next: function () {
                if (o && i >= o.length) o = void 0;
                return { value: o && o[i++], done: !o };
            }
        };
        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
    };
    impl.TapStreamReader.prototype.readLoginCredential = function () {
        var model = {};
        model.username = this.readString(16);
        model.password = this.readString(16);
        return model;
    };
    impl.TapStreamReader.prototype.readLoginCredentialHashed = function () {
        var model = {};
        model.username = this.readString(16);
        model.password = this.readBytes(16);
        return model;
    };
    impl.TapStreamReader.prototype.readSecurityOptions = function () {
        var model = {};
        this.forwardBits(8);
        this.forwardBits(3);
        model.scramActivated = this.readBoolean(1);
        model.hashPassword = this.readBoolean(1);
        model.disableHardwareFactoryReset = this.readBoolean(1);
        model.disableLoginWithUID = this.readBoolean(1);
        model.disableResourceFactoryReset = this.readBoolean(1);
        return model;
    };
    impl.TapStreamReader.prototype.readProtocolMaxFrameSize = function () {
        var model = {};
        model.request = this.readUnsigned(2);
        model.response = this.readUnsigned(2);
        return model;
    };
    impl.TapStreamReader.prototype.readMultiRequestFrame = function () {
        var model = {};
        model.requests = [];
        while (!this.isEof()) {
            model.requests.push(this.readMultiRequestFrameRequestItem());
        }
        return model;
    };
    impl.TapStreamReader.prototype.readMultiRequestFrameRequestItem = function () {
        var model = {};
        model.requestLen = this.readUnsigned(2);
        model.request = this.subStream(model.requestLen).readTapRequestFrame();
        model.expectedResponseStatus = this.readUnsigned(1);
        return model;
    };
    impl.TapStreamReader.prototype.readMultiResponseFrame = function () {
        var model = {};
        model.responses = [];
        while (!this.isEof()) {
            model.responses.push(this.readMultiResponseFrameResponseItem());
        }
        return model;
    };
    impl.TapStreamReader.prototype.readMultiResponseFrameResponseItem = function () {
        var model = {};
        model.responseLen = this.readUnsigned(2);
        model.response = this.subStream(model.responseLen).readTapResponseFrame();
        return model;
    };
    // TapStreamWriter.prototype.write(model: LoginCredential) : TapStreamWriter{
    //     return this.writeLoginCredential(model)
    // }
    impl.TapStreamWriter.prototype.writeLoginCredential = function (model) {
        this.writeString(model.username, 16);
        this.writeString(model.password, 16);
        return this;
    };
    // TapStreamWriter.prototype.write(model: LoginCredentialHashed) : TapStreamWriter{
    //     return this.writeLoginCredentialHashed(model)
    // }
    impl.TapStreamWriter.prototype.writeLoginCredentialHashed = function (model) {
        this.writeString(model.username, 16);
        this.writeBytes(model.password, 16);
        return this;
    };
    // TapStreamWriter.prototype.write(model: SecurityOptions) : TapStreamWriter{
    //     return this.writeSecurityOptions(model)
    // }
    impl.TapStreamWriter.prototype.writeSecurityOptions = function (model) {
        this.forwardBits(8);
        this.forwardBits(3);
        this.writeBoolean(model.scramActivated, 1);
        this.writeBoolean(model.hashPassword, 1);
        this.writeBoolean(model.disableHardwareFactoryReset, 1);
        this.writeBoolean(model.disableLoginWithUID, 1);
        this.writeBoolean(model.disableResourceFactoryReset, 1);
        return this;
    };
    // TapStreamWriter.prototype.write(model: ProtocolMaxFrameSize) : TapStreamWriter{
    //     return this.writeProtocolMaxFrameSize(model)
    // }
    impl.TapStreamWriter.prototype.writeProtocolMaxFrameSize = function (model) {
        this.writeUnsigned(model.request, 2);
        this.writeUnsigned(model.response, 2);
        return this;
    };
    // TapStreamWriter.prototype.write(model: MultiRequestFrame) : TapStreamWriter{
    //     return this.writeMultiRequestFrame(model)
    // }
    impl.TapStreamWriter.prototype.writeMultiRequestFrame = function (model) {
        var e_1, _a;
        try {
            for (var _b = __values(model.requests), _c = _b.next(); !_c.done; _c = _b.next()) {
                var item = _c.value;
                this.writeMultiRequestFrameRequestItem(item);
            }
        }
        catch (e_1_1) { e_1 = { error: e_1_1 }; }
        finally {
            try {
                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
            }
            finally { if (e_1) throw e_1.error; }
        }
        return this;
    };
    impl.TapStreamWriter.prototype.writeMultiRequestFrameRequestItem = function (model) {
        this.writeUnsigned(model.requestLen, 2);
        this.writeTapRequestFrame(model.request);
        this.writeUnsigned(model.expectedResponseStatus, 1);
        return this;
    };
    // TapStreamWriter.prototype.write(model: MultiResponseFrame) : TapStreamWriter{
    //     return this.writeMultiResponseFrame(model)
    // }
    impl.TapStreamWriter.prototype.writeMultiResponseFrame = function (model) {
        var e_2, _a;
        try {
            for (var _b = __values(model.responses), _c = _b.next(); !_c.done; _c = _b.next()) {
                var item = _c.value;
                this.writeMultiResponseFrameResponseItem(item);
            }
        }
        catch (e_2_1) { e_2 = { error: e_2_1 }; }
        finally {
            try {
                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
            }
            finally { if (e_2) throw e_2.error; }
        }
        return this;
    };
    impl.TapStreamWriter.prototype.writeMultiResponseFrameResponseItem = function (model) {
        this.writeUnsigned(model.responseLen, 2);
        this.writeTapResponseFrame(model.response);
        return this;
    };

    /**
     *   Generated file. Do not edit
     */
    var LoginCredentialConverter = /** @class */ (function () {
        function LoginCredentialConverter() {
        }
        LoginCredentialConverter.prototype.encode = function (model, stream) {
            if (stream === void 0) { stream = new impl.TapStreamWriter(); }
            stream.writeLoginCredential(model);
            return stream.toBytes;
        };
        LoginCredentialConverter.prototype.decode = function (data) {
            var stream = data instanceof impl.TapStreamReader ? data : impl.TapStreamReader.create(data);
            return stream.readLoginCredential();
        };
        return LoginCredentialConverter;
    }());
    var LoginCredentialHashedConverter = /** @class */ (function () {
        function LoginCredentialHashedConverter() {
        }
        LoginCredentialHashedConverter.prototype.encode = function (model, stream) {
            if (stream === void 0) { stream = new impl.TapStreamWriter(); }
            stream.writeLoginCredentialHashed(model);
            return stream.toBytes;
        };
        LoginCredentialHashedConverter.prototype.decode = function (data) {
            var stream = data instanceof impl.TapStreamReader ? data : impl.TapStreamReader.create(data);
            return stream.readLoginCredentialHashed();
        };
        return LoginCredentialHashedConverter;
    }());
    var SecurityOptionsConverter = /** @class */ (function () {
        function SecurityOptionsConverter() {
        }
        SecurityOptionsConverter.prototype.encode = function (model, stream) {
            if (stream === void 0) { stream = new impl.TapStreamWriter(); }
            stream.writeSecurityOptions(model);
            return stream.toBytes;
        };
        SecurityOptionsConverter.prototype.decode = function (data) {
            var stream = data instanceof impl.TapStreamReader ? data : impl.TapStreamReader.create(data);
            return stream.readSecurityOptions();
        };
        return SecurityOptionsConverter;
    }());
    var ProtocolMaxFrameSizeConverter = /** @class */ (function () {
        function ProtocolMaxFrameSizeConverter() {
        }
        ProtocolMaxFrameSizeConverter.prototype.encode = function (model, stream) {
            if (stream === void 0) { stream = new impl.TapStreamWriter(); }
            stream.writeProtocolMaxFrameSize(model);
            return stream.toBytes;
        };
        ProtocolMaxFrameSizeConverter.prototype.decode = function (data) {
            var stream = data instanceof impl.TapStreamReader ? data : impl.TapStreamReader.create(data);
            return stream.readProtocolMaxFrameSize();
        };
        return ProtocolMaxFrameSizeConverter;
    }());
    var MultiRequestFrameConverter = /** @class */ (function () {
        function MultiRequestFrameConverter() {
        }
        MultiRequestFrameConverter.prototype.encode = function (model, stream) {
            if (stream === void 0) { stream = new impl.TapStreamWriter(); }
            stream.writeMultiRequestFrame(model);
            return stream.toBytes;
        };
        MultiRequestFrameConverter.prototype.decode = function (data) {
            var stream = data instanceof impl.TapStreamReader ? data : impl.TapStreamReader.create(data);
            return stream.readMultiRequestFrame();
        };
        return MultiRequestFrameConverter;
    }());
    var MultiResponseFrameConverter = /** @class */ (function () {
        function MultiResponseFrameConverter() {
        }
        MultiResponseFrameConverter.prototype.encode = function (model, stream) {
            if (stream === void 0) { stream = new impl.TapStreamWriter(); }
            stream.writeMultiResponseFrame(model);
            return stream.toBytes;
        };
        MultiResponseFrameConverter.prototype.decode = function (data) {
            var stream = data instanceof impl.TapStreamReader ? data : impl.TapStreamReader.create(data);
            return stream.readMultiResponseFrame();
        };
        return MultiResponseFrameConverter;
    }());

    /* tslint:disable */
    /**
     * This file was automatically generated by json-schema-to-typescript.
     * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
     * and run json-schema-to-typescript to regenerate this file.
     */

    (function (NfcPairingMode) {
        NfcPairingMode[NfcPairingMode["NO"] = 0] = "NO";
        NfcPairingMode[NfcPairingMode["MANDATORY"] = 1] = "MANDATORY";
        NfcPairingMode[NfcPairingMode["MANDATORY_FOR_LOGIN"] = 2] = "MANDATORY_FOR_LOGIN";
    })(exports.NfcPairingMode || (exports.NfcPairingMode = {}));
    /* tslint:disable */
    /**
     * This file was automatically generated by json-schema-to-typescript.
     * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
     * and run json-schema-to-typescript to regenerate this file.
     */

    (function (LowPowerOptimizationLevel) {
        LowPowerOptimizationLevel[LowPowerOptimizationLevel["NO"] = 0] = "NO";
        LowPowerOptimizationLevel[LowPowerOptimizationLevel["STANDBY"] = 2] = "STANDBY";
        LowPowerOptimizationLevel[LowPowerOptimizationLevel["SHUTDOWN"] = 3] = "SHUTDOWN";
    })(exports.LowPowerOptimizationLevel || (exports.LowPowerOptimizationLevel = {}));
    /* tslint:disable */
    /**
     * This file was automatically generated by json-schema-to-typescript.
     * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
     * and run json-schema-to-typescript to regenerate this file.
     */

    (function (ServiceCode) {
        ServiceCode[ServiceCode["DATALOG"] = 1] = "DATALOG";
        ServiceCode[ServiceCode["JVM"] = 2] = "JVM";
    })(exports.ServiceCode || (exports.ServiceCode = {}));
    /* tslint:disable */
    /**
     * This file was automatically generated by json-schema-to-typescript.
     * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
     * and run json-schema-to-typescript to regenerate this file.
     */

    (function (NfcConnectionPriority) {
        NfcConnectionPriority[NfcConnectionPriority["NFC_PRIORITY"] = 0] = "NFC_PRIORITY";
        NfcConnectionPriority[NfcConnectionPriority["NFC_NON_PRIORITY"] = 1] = "NFC_NON_PRIORITY";
    })(exports.NfcConnectionPriority || (exports.NfcConnectionPriority = {}));

    (function (MultiRequestFrame) {
        /* tslint:disable */
        /**
         * This file was automatically generated by json-schema-to-typescript.
         * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
         * and run json-schema-to-typescript to regenerate this file.
         */
        /* tslint:disable */
        /**
         * This file was automatically generated by json-schema-to-typescript.
         * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
         * and run json-schema-to-typescript to regenerate this file.
         */
        var ExpectedResponseStatus;
        (function (ExpectedResponseStatus) {
            ExpectedResponseStatus[ExpectedResponseStatus["SUCCESS"] = 127] = "SUCCESS";
            ExpectedResponseStatus[ExpectedResponseStatus["ANYTHING"] = 255] = "ANYTHING";
        })(ExpectedResponseStatus = MultiRequestFrame.ExpectedResponseStatus || (MultiRequestFrame.ExpectedResponseStatus = {}));
    })(exports.MultiRequestFrame || (exports.MultiRequestFrame = {}));

    /**
     *   Generated file. Do not edit
     */
    var loginCredential = new LoginCredentialConverter();
    var loginCredentialHashed = new LoginCredentialHashedConverter();
    var securityOptions = new SecurityOptionsConverter();
    var nfcPairingMode = core.createEnumConverter(exports.NfcPairingMode, 1);
    var nfcPairingModeArray = core.createEnumArrayConverter(exports.NfcPairingMode, 1);
    var lowPowerOptimizationLevel = core.createEnumConverter(exports.LowPowerOptimizationLevel, 1);
    var lowPowerOptimizationLevelArray = core.createEnumArrayConverter(exports.LowPowerOptimizationLevel, 1);
    var serviceCode = core.createEnumConverter(exports.ServiceCode, 1);
    var serviceCodeArray = core.createEnumArrayConverter(exports.ServiceCode, 1);
    var nfcConnectionPriority = core.createEnumConverter(exports.NfcConnectionPriority, 1);
    var nfcConnectionPriorityArray = core.createEnumArrayConverter(exports.NfcConnectionPriority, 1);
    var protocolMaxFrameSize = new ProtocolMaxFrameSizeConverter();
    var multiRequestFrame = new MultiRequestFrameConverter();
    var multiResponseFrame = new MultiResponseFrameConverter();

    var serviceConverters = /*#__PURE__*/Object.freeze({
        __proto__: null,
        loginCredential: loginCredential,
        loginCredentialHashed: loginCredentialHashed,
        securityOptions: securityOptions,
        nfcPairingMode: nfcPairingMode,
        nfcPairingModeArray: nfcPairingModeArray,
        lowPowerOptimizationLevel: lowPowerOptimizationLevel,
        lowPowerOptimizationLevelArray: lowPowerOptimizationLevelArray,
        serviceCode: serviceCode,
        serviceCodeArray: serviceCodeArray,
        nfcConnectionPriority: nfcConnectionPriority,
        nfcConnectionPriorityArray: nfcConnectionPriorityArray,
        protocolMaxFrameSize: protocolMaxFrameSize,
        multiRequestFrame: multiRequestFrame,
        multiResponseFrame: multiResponseFrame
    });

    /**
     *   Generated file. Do not edit
     */
    var __assign = (this && this.__assign) || function () {
        __assign = Object.assign || function(t) {
            for (var s, i = 1, n = arguments.length; i < n; i++) {
                s = arguments[i];
                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                    t[p] = s[p];
            }
            return t;
        };
        return __assign.apply(this, arguments);
    };
    var allConverters = __assign(__assign({}, core.converters), serviceConverters);
    var SERVICE_CALLS = {
        login: {
            method: api.TapRequestFrame.MethodType.POST,
            pathAlias: "/interface/login",
            path: "/1024//0",
            bodyEncoder: allConverters.loginCredential
        },
        loginWithHash: {
            method: api.TapRequestFrame.MethodType.POST,
            pathAlias: "/interface/login-with-hash",
            path: "/1024//0",
            bodyEncoder: allConverters.loginCredentialHashed
        },
        logout: {
            method: api.TapRequestFrame.MethodType.POST,
            pathAlias: "/interface/logout",
            path: "/1024//1"
        },
        getCurrentProfileId: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/current-profile/id",
            path: "/1024//2",
            responseBodyDecoder: allConverters.uint16
        },
        getCurrentHostProtocol: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/current-host-protocol",
            path: "/1024//3",
            responseBodyDecoder: allConverters.hostProtocol
        },
        putCurrentHostProtocol: {
            method: api.TapRequestFrame.MethodType.PUT,
            pathAlias: "/interface/current-host-protocol",
            path: "/1024//3",
            bodyEncoder: allConverters.hostProtocol
        },
        getUID: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/uid",
            path: "/1024//5"
        },
        loginWithUID: {
            method: api.TapRequestFrame.MethodType.POST,
            pathAlias: "/interface/uid",
            path: "/1024//5"
        },
        keepAlive: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/keep-alive",
            path: "/1024//4",
            responseBodyDecoder: allConverters.uint32
        },
        getSecurityOptions: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/security-options",
            path: "/1024//6",
            responseBodyDecoder: allConverters.securityOptions
        },
        putSecurityOptions: {
            method: api.TapRequestFrame.MethodType.PUT,
            pathAlias: "/interface/security-options",
            path: "/1024//6",
            bodyEncoder: allConverters.securityOptions
        },
        getCurrentGroupId: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/current-group-id",
            path: "/1024//7",
            responseBodyDecoder: allConverters.uint16
        },
        getConfigFormatVersion: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/config-format-version",
            path: "/1024//8",
            responseBodyDecoder: allConverters.uint16
        },
        putConfigFormatVersion: {
            method: api.TapRequestFrame.MethodType.PUT,
            pathAlias: "/interface/config-format-version",
            path: "/1024//8",
            bodyEncoder: allConverters.uint16
        },
        getAppName: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/app-name",
            path: "/1024//9",
            responseBodyDecoder: allConverters.ascii
        },
        putAppName: {
            method: api.TapRequestFrame.MethodType.PUT,
            pathAlias: "/interface/app-name",
            path: "/1024//9",
            bodyEncoder: allConverters.ascii
        },
        getConfigVersion: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/config-version",
            path: "/1024//10",
            responseBodyDecoder: allConverters.stringVersion
        },
        putConfigVersion: {
            method: api.TapRequestFrame.MethodType.PUT,
            pathAlias: "/interface/config-version",
            path: "/1024//10",
            bodyEncoder: allConverters.stringVersion
        },
        reloadConfig: {
            method: api.TapRequestFrame.MethodType.POST,
            pathAlias: "/interface/config-version",
            path: "/1024//10"
        },
        getAppPath: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/app-path",
            path: "/1024//11",
            responseBodyDecoder: allConverters.ascii
        },
        putAppPath: {
            method: api.TapRequestFrame.MethodType.PUT,
            pathAlias: "/interface/app-path",
            path: "/1024//11",
            bodyEncoder: allConverters.ascii
        },
        getNfcPairingMode: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/nfc/pairing-mode",
            path: "/1024//13",
            responseBodyDecoder: allConverters.nfcPairingMode
        },
        putNfcPairingMode: {
            method: api.TapRequestFrame.MethodType.PUT,
            pathAlias: "/interface/nfc/pairing-mode",
            path: "/1024//13",
            bodyEncoder: allConverters.nfcPairingMode
        },
        getPowerOptimisationLevel: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/power-optimisation-level",
            path: "/1024//14",
            responseBodyDecoder: allConverters.lowPowerOptimizationLevel
        },
        putPowerOptimisationLevel: {
            method: api.TapRequestFrame.MethodType.PUT,
            pathAlias: "/interface/power-optimisation-level",
            path: "/1024//14",
            bodyEncoder: allConverters.lowPowerOptimizationLevel
        },
        getAuthorizedHostProtocol: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/authorized-host-protocol",
            path: "/1024//17",
            responseBodyDecoder: allConverters.hostProtocolArray
        },
        putAuthorizedHostProtocol: {
            method: api.TapRequestFrame.MethodType.PUT,
            pathAlias: "/interface/authorized-host-protocol",
            path: "/1024//17",
            bodyEncoder: allConverters.hostProtocolArray
        },
        getConfigFormatFirmwareVersion: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/config-format-firmware-version",
            path: "/1024//18",
            responseBodyDecoder: allConverters.uint16
        },
        getUniversalLink: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/universal-link",
            path: "/1024//19",
            responseBodyDecoder: allConverters.ascii
        },
        putUniversalLink: {
            method: api.TapRequestFrame.MethodType.PUT,
            pathAlias: "/interface/universal-link",
            path: "/1024//19",
            bodyEncoder: allConverters.ascii
        },
        getAvailableHostProtocols: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/available-host-protocols",
            path: "/1024//21",
            responseBodyDecoder: allConverters.hostProtocolArray
        },
        getDisabledServices: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/disabled-services",
            path: "/1024//75",
            responseBodyDecoder: allConverters.serviceCodeArray
        },
        postDisabledServices: {
            method: api.TapRequestFrame.MethodType.POST,
            pathAlias: "/interface/disabled-services",
            path: "/1024//75",
            bodyEncoder: allConverters.serviceCodeArray
        },
        getNfcConnectionPriority: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/nfc_connection_priority",
            path: "/1024//24",
            responseBodyDecoder: allConverters.nfcConnectionPriority
        },
        postNfcConnectionPriority: {
            method: api.TapRequestFrame.MethodType.POST,
            pathAlias: "/interface/nfc_connection_priority",
            path: "/1024//24",
            bodyEncoder: allConverters.nfcConnectionPriority
        },
        putNfcConnectionPriority: {
            method: api.TapRequestFrame.MethodType.PUT,
            pathAlias: "/interface/nfc_connection_priority",
            path: "/1024//24",
            bodyEncoder: allConverters.nfcConnectionPriority
        },
        getNfcAutologProfileId: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/nfc-autolog-profile-id",
            path: "/1024//43",
            responseBodyDecoder: allConverters.uint16
        },
        putNfcAutologProfileId: {
            method: api.TapRequestFrame.MethodType.PUT,
            pathAlias: "/interface/nfc-autolog-profile-id",
            path: "/1024//43",
            bodyEncoder: allConverters.uint16
        },
        getHostInactivityPeriod: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/host-inactivity-period",
            path: "/1024//34",
            responseBodyDecoder: allConverters.uint16
        },
        putHostInactivityPeriod: {
            method: api.TapRequestFrame.MethodType.PUT,
            pathAlias: "/interface/host-inactivity-period",
            path: "/1024//34",
            bodyEncoder: allConverters.uint8
        },
        getApplicationData: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/application-data",
            path: "/1024//36"
        },
        putApplicationData: {
            method: api.TapRequestFrame.MethodType.PUT,
            pathAlias: "/interface/application-data",
            path: "/1024//36"
        },
        getProductKey: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/product-key",
            path: "/1024//60",
            responseBodyDecoder: allConverters.ascii
        },
        getCurrentHostProtocolMaxFrameSize: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/current-host-protocol-max-frame-size",
            path: "/1024//88",
            responseBodyDecoder: allConverters.protocolMaxFrameSize
        },
        executeMultiRequestFrame: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/multi-request-frame",
            path: "/1024//89",
            responseBodyDecoder: allConverters.multiResponseFrame,
            bodyEncoder: allConverters.multiRequestFrame
        },
        putCertificatePublicKey: {
            method: api.TapRequestFrame.MethodType.PUT,
            pathAlias: "/interface/certificate/public-key",
            append: true,
            path: "/1024//37"
        },
        putCertificatePrivateKey: {
            method: api.TapRequestFrame.MethodType.PUT,
            pathAlias: "/interface/certificate/private-key",
            append: true,
            path: "/1024//38"
        },
        getProductCode: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/product-code",
            path: "/1024//84",
            responseBodyDecoder: allConverters.ascii
        },
        putProductCode: {
            method: api.TapRequestFrame.MethodType.PUT,
            pathAlias: "/interface/product-code",
            path: "/1024//84",
            bodyEncoder: allConverters.ascii
        },
        getSpecialFeatureProfile: {
            method: api.TapRequestFrame.MethodType.GET,
            pathAlias: "/interface/special-feature/{featureId}",
            path: "/1024//{featureId}",
            responseBodyDecoder: allConverters.uint16
        },
        setSpecialFeatureProfile: {
            method: api.TapRequestFrame.MethodType.POST,
            pathAlias: "/interface/special-feature/{featureId}",
            path: "/1024//{featureId}",
            bodyEncoder: allConverters.uint16
        },
        putSpecialFeatureProfile: {
            method: api.TapRequestFrame.MethodType.PUT,
            pathAlias: "/interface/special-feature/{featureId}",
            path: "/1024//{featureId}",
            bodyEncoder: allConverters.uint16
        }
    };

    var __extends = (this && this.__extends) || (function () {
        var extendStatics = function (d, b) {
            extendStatics = Object.setPrototypeOf ||
                ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
                function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    var __assign$1 = (this && this.__assign) || function () {
        __assign$1 = Object.assign || function(t) {
            for (var s, i = 1, n = arguments.length; i < n; i++) {
                s = arguments[i];
                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                    t[p] = s[p];
            }
            return t;
        };
        return __assign$1.apply(this, arguments);
    };
    var InterfaceService = /** @class */ (function (_super) {
        __extends(InterfaceService, _super);
        function InterfaceService() {
            var _this = _super !== null && _super.apply(this, arguments) || this;
            _this.resources = SERVICE_CALLS;
            return _this;
        }
        /**
         * Login
         *
         * LWM2M path: /1024//0
         *
         * @tapVersion(">=")
         * @param credential input
         * @return
         */
        InterfaceService.prototype.login = function (
        /*
         * Username/password credentials
         */
        credential) {
            return this.serviceCallRunner.execute(this.loginCall(credential));
        };
        /**
         *
         *
         * LWM2M path: /1024//0
         *
         * @tapVersion(">=")
         * @param credential input
         * @return call options
         */
        InterfaceService.prototype.loginCall = function (
        /*
         * Username/password credentials
         */
        credential) {
            var callOptions = __assign$1({}, this.resources.login);
            callOptions.body = credential;
            return callOptions;
        };
        /**
         * Login
         *
         * LWM2M path: /1024//0
         *
         * @tapVersion(">=")
         * @param credential input
         * @return
         */
        InterfaceService.prototype.loginWithHash = function (
        /*
         *
         */
        credential) {
            return this.serviceCallRunner.execute(this.loginWithHashCall(credential));
        };
        /**
         *
         *
         * LWM2M path: /1024//0
         *
         * @tapVersion(">=")
         * @param credential input
         * @return call options
         */
        InterfaceService.prototype.loginWithHashCall = function (
        /*
         *
         */
        credential) {
            var callOptions = __assign$1({}, this.resources.loginWithHash);
            callOptions.body = credential;
            return callOptions;
        };
        /**
         * Logout
         *
         * LWM2M path: /1024//1
         *
         * @tapVersion(">=")
         * @return
         */
        InterfaceService.prototype.logout = function () {
            return this.serviceCallRunner.execute(this.logoutCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//1
         *
         * @tapVersion(">=")
         * @return call options
         */
        InterfaceService.prototype.logoutCall = function () {
            var callOptions = __assign$1({}, this.resources.logout);
            return callOptions;
        };
        /**
         * Get current profile id
         *
         * LWM2M path: /1024//2
         *
         * @tapVersion(">=")
         * @return
         */
        InterfaceService.prototype.getCurrentProfileId = function () {
            return this.serviceCallRunner.execute(this.getCurrentProfileIdCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//2
         *
         * @tapVersion(">=")
         * @return call options
         */
        InterfaceService.prototype.getCurrentProfileIdCall = function () {
            var callOptions = __assign$1({}, this.resources.getCurrentProfileId);
            return callOptions;
        };
        /**
         * Get current host protocol
         *
         * LWM2M path: /1024//3
         *
         * @tapVersion(">=")
         * @return
         */
        InterfaceService.prototype.getCurrentHostProtocol = function () {
            return this.serviceCallRunner.execute(this.getCurrentHostProtocolCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//3
         *
         * @tapVersion(">=")
         * @return call options
         */
        InterfaceService.prototype.getCurrentHostProtocolCall = function () {
            var callOptions = __assign$1({}, this.resources.getCurrentHostProtocol);
            return callOptions;
        };
        /**
         * Write current host protocol
         *
         * LWM2M path: /1024//3
         *
         * @tapVersion(">=")
         * @param hostProtocol input
         * @return
         */
        InterfaceService.prototype.putCurrentHostProtocol = function (
        /*
         *
         */
        hostProtocol) {
            return this.serviceCallRunner.execute(this.putCurrentHostProtocolCall(hostProtocol));
        };
        /**
         *
         *
         * LWM2M path: /1024//3
         *
         * @tapVersion(">=")
         * @param hostProtocol input
         * @return call options
         */
        InterfaceService.prototype.putCurrentHostProtocolCall = function (
        /*
         *
         */
        hostProtocol) {
            var callOptions = __assign$1({}, this.resources.putCurrentHostProtocol);
            callOptions.body = hostProtocol;
            return callOptions;
        };
        /**
         * Get UID value
         *
         * LWM2M path: /1024//5
         *
         * @tapVersion(">=")
         * @return
         */
        InterfaceService.prototype.getUID = function () {
            return this.serviceCallRunner.execute(this.getUIDCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//5
         *
         * @tapVersion(">=")
         * @return call options
         */
        InterfaceService.prototype.getUIDCall = function () {
            var callOptions = __assign$1({}, this.resources.getUID);
            return callOptions;
        };
        /**
         * Administrator login with UID.
         *
         * LWM2M path: /1024//5
         *
         * @tapVersion(">=")
         * @param uid input
         * @return
         */
        InterfaceService.prototype.loginWithUID = function (
        /*
         *
         */
        uid) {
            return this.serviceCallRunner.execute(this.loginWithUIDCall(uid));
        };
        /**
         *
         *
         * LWM2M path: /1024//5
         *
         * @tapVersion(">=")
         * @param uid input
         * @return call options
         */
        InterfaceService.prototype.loginWithUIDCall = function (
        /*
         *
         */
        uid) {
            var callOptions = __assign$1({}, this.resources.loginWithUID);
            callOptions.body = uid;
            return callOptions;
        };
        /**
         * Keep alive.
         *
         * LWM2M path: /1024//4
         *
         * @tapVersion(">=")
         * @return
         */
        InterfaceService.prototype.keepAlive = function () {
            return this.serviceCallRunner.execute(this.keepAliveCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//4
         *
         * @tapVersion(">=")
         * @return call options
         */
        InterfaceService.prototype.keepAliveCall = function () {
            var callOptions = __assign$1({}, this.resources.keepAlive);
            return callOptions;
        };
        /**
         * Get lock infos
         *
         * LWM2M path: /1024//6
         *
         * @tapVersion(">=")
         * @return
         */
        InterfaceService.prototype.getSecurityOptions = function () {
            return this.serviceCallRunner.execute(this.getSecurityOptionsCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//6
         *
         * @tapVersion(">=")
         * @return call options
         */
        InterfaceService.prototype.getSecurityOptionsCall = function () {
            var callOptions = __assign$1({}, this.resources.getSecurityOptions);
            return callOptions;
        };
        /**
         * Set lock infos
         *
         * LWM2M path: /1024//6
         *
         * @tapVersion(">=")
         * @param infos input
         * @return
         */
        InterfaceService.prototype.putSecurityOptions = function (
        /*
         * lock informations
         */
        infos) {
            return this.serviceCallRunner.execute(this.putSecurityOptionsCall(infos));
        };
        /**
         *
         *
         * LWM2M path: /1024//6
         *
         * @tapVersion(">=")
         * @param infos input
         * @return call options
         */
        InterfaceService.prototype.putSecurityOptionsCall = function (
        /*
         * lock informations
         */
        infos) {
            var callOptions = __assign$1({}, this.resources.putSecurityOptions);
            callOptions.body = infos;
            return callOptions;
        };
        /**
         * Get current group id
         *
         * LWM2M path: /1024//7
         *
         * @tapVersion(">=")
         * @return
         */
        InterfaceService.prototype.getCurrentGroupId = function () {
            return this.serviceCallRunner.execute(this.getCurrentGroupIdCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//7
         *
         * @tapVersion(">=")
         * @return call options
         */
        InterfaceService.prototype.getCurrentGroupIdCall = function () {
            var callOptions = __assign$1({}, this.resources.getCurrentGroupId);
            return callOptions;
        };
        /**
         * Get config format version
         *
         * LWM2M path: /1024//8
         *
         * @tapVersion(">=")
         * @return
         */
        InterfaceService.prototype.getConfigFormatVersion = function () {
            return this.serviceCallRunner.execute(this.getConfigFormatVersionCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//8
         *
         * @tapVersion(">=")
         * @return call options
         */
        InterfaceService.prototype.getConfigFormatVersionCall = function () {
            var callOptions = __assign$1({}, this.resources.getConfigFormatVersion);
            return callOptions;
        };
        /**
         * Set config format version
         *
         * LWM2M path: /1024//8
         *
         * @tapVersion(">=")
         * @param configFormat input
         * @return
         */
        InterfaceService.prototype.putConfigFormatVersion = function (
        /*
         *
         */
        configFormat) {
            return this.serviceCallRunner.execute(this.putConfigFormatVersionCall(configFormat));
        };
        /**
         *
         *
         * LWM2M path: /1024//8
         *
         * @tapVersion(">=")
         * @param configFormat input
         * @return call options
         */
        InterfaceService.prototype.putConfigFormatVersionCall = function (
        /*
         *
         */
        configFormat) {
            var callOptions = __assign$1({}, this.resources.putConfigFormatVersion);
            callOptions.body = configFormat;
            return callOptions;
        };
        /**
         * Get application name
         *
         * LWM2M path: /1024//9
         *
         * @tapVersion(">=")
         * @return
         */
        InterfaceService.prototype.getAppName = function () {
            return this.serviceCallRunner.execute(this.getAppNameCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//9
         *
         * @tapVersion(">=")
         * @return call options
         */
        InterfaceService.prototype.getAppNameCall = function () {
            var callOptions = __assign$1({}, this.resources.getAppName);
            return callOptions;
        };
        /**
         * Set application name
         *
         * LWM2M path: /1024//9
         *
         * @tapVersion(">=")
         * @param appName input
         * @return
         */
        InterfaceService.prototype.putAppName = function (
        /*
         *
         */
        appName) {
            return this.serviceCallRunner.execute(this.putAppNameCall(appName));
        };
        /**
         *
         *
         * LWM2M path: /1024//9
         *
         * @tapVersion(">=")
         * @param appName input
         * @return call options
         */
        InterfaceService.prototype.putAppNameCall = function (
        /*
         *
         */
        appName) {
            var callOptions = __assign$1({}, this.resources.putAppName);
            callOptions.body = appName;
            return callOptions;
        };
        /**
         * Get config version
         *
         * LWM2M path: /1024//10
         *
         * @tapVersion(">=")
         * @return
         */
        InterfaceService.prototype.getConfigVersion = function () {
            return this.serviceCallRunner.execute(this.getConfigVersionCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//10
         *
         * @tapVersion(">=")
         * @return call options
         */
        InterfaceService.prototype.getConfigVersionCall = function () {
            var callOptions = __assign$1({}, this.resources.getConfigVersion);
            return callOptions;
        };
        /**
         * Set config version
         *
         * LWM2M path: /1024//10
         *
         * @tapVersion(">=")
         * @param version input
         * @return
         */
        InterfaceService.prototype.putConfigVersion = function (
        /*
         *
         */
        version) {
            return this.serviceCallRunner.execute(this.putConfigVersionCall(version));
        };
        /**
         *
         *
         * LWM2M path: /1024//10
         *
         * @tapVersion(">=")
         * @param version input
         * @return call options
         */
        InterfaceService.prototype.putConfigVersionCall = function (
        /*
         *
         */
        version) {
            var callOptions = __assign$1({}, this.resources.putConfigVersion);
            callOptions.body = version;
            return callOptions;
        };
        /**
         * Apply the new configuration on the Tap
         *
         * LWM2M path: /1024//10
         *
         * @tapVersion(">=")
         * @return
         */
        InterfaceService.prototype.reloadConfig = function () {
            return this.serviceCallRunner.execute(this.reloadConfigCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//10
         *
         * @tapVersion(">=")
         * @return call options
         */
        InterfaceService.prototype.reloadConfigCall = function () {
            var callOptions = __assign$1({}, this.resources.reloadConfig);
            return callOptions;
        };
        /**
         * Get app path
         *
         * LWM2M path: /1024//11
         *
         * @tapVersion(">=")
         * @return
         */
        InterfaceService.prototype.getAppPath = function () {
            return this.serviceCallRunner.execute(this.getAppPathCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//11
         *
         * @tapVersion(">=")
         * @return call options
         */
        InterfaceService.prototype.getAppPathCall = function () {
            var callOptions = __assign$1({}, this.resources.getAppPath);
            return callOptions;
        };
        /**
         * Set app path
         *
         * LWM2M path: /1024//11
         *
         * @tapVersion(">=")
         * @param value input
         * @return
         */
        InterfaceService.prototype.putAppPath = function (
        /*
         *
         */
        value) {
            return this.serviceCallRunner.execute(this.putAppPathCall(value));
        };
        /**
         *
         *
         * LWM2M path: /1024//11
         *
         * @tapVersion(">=")
         * @param value input
         * @return call options
         */
        InterfaceService.prototype.putAppPathCall = function (
        /*
         *
         */
        value) {
            var callOptions = __assign$1({}, this.resources.putAppPath);
            callOptions.body = value;
            return callOptions;
        };
        /**
         * Check if nfc paring is mandatory
         *
         * LWM2M path: /1024//13
         *
         * @tapVersion(">=")
         * @return
         */
        InterfaceService.prototype.getNfcPairingMode = function () {
            return this.serviceCallRunner.execute(this.getNfcPairingModeCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//13
         *
         * @tapVersion(">=")
         * @return call options
         */
        InterfaceService.prototype.getNfcPairingModeCall = function () {
            var callOptions = __assign$1({}, this.resources.getNfcPairingMode);
            return callOptions;
        };
        /**
         * Change wether if nfc pairing is mandatory
         *
         * LWM2M path: /1024//13
         *
         * @tapVersion(">=")
         * @param mode input
         * @return
         */
        InterfaceService.prototype.putNfcPairingMode = function (
        /*
         *
         */
        mode) {
            return this.serviceCallRunner.execute(this.putNfcPairingModeCall(mode));
        };
        /**
         *
         *
         * LWM2M path: /1024//13
         *
         * @tapVersion(">=")
         * @param mode input
         * @return call options
         */
        InterfaceService.prototype.putNfcPairingModeCall = function (
        /*
         *
         */
        mode) {
            var callOptions = __assign$1({}, this.resources.putNfcPairingMode);
            callOptions.body = mode;
            return callOptions;
        };
        /**
         * Get power optimization level
         *
         * LWM2M path: /1024//14
         *
         * @tapVersion(">=")
         * @return
         */
        InterfaceService.prototype.getPowerOptimisationLevel = function () {
            return this.serviceCallRunner.execute(this.getPowerOptimisationLevelCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//14
         *
         * @tapVersion(">=")
         * @return call options
         */
        InterfaceService.prototype.getPowerOptimisationLevelCall = function () {
            var callOptions = __assign$1({}, this.resources.getPowerOptimisationLevel);
            return callOptions;
        };
        /**
         * Write power optimization level
         *
         * LWM2M path: /1024//14
         *
         * @tapVersion(">=")
         * @param mode input
         * @return
         */
        InterfaceService.prototype.putPowerOptimisationLevel = function (
        /*
         *
         */
        mode) {
            return this.serviceCallRunner.execute(this.putPowerOptimisationLevelCall(mode));
        };
        /**
         *
         *
         * LWM2M path: /1024//14
         *
         * @tapVersion(">=")
         * @param mode input
         * @return call options
         */
        InterfaceService.prototype.putPowerOptimisationLevelCall = function (
        /*
         *
         */
        mode) {
            var callOptions = __assign$1({}, this.resources.putPowerOptimisationLevel);
            callOptions.body = mode;
            return callOptions;
        };
        /**
         * Get authorized host protocols
         *
         * LWM2M path: /1024//17
         *
         * @tapVersion(">=")
         * @return
         */
        InterfaceService.prototype.getAuthorizedHostProtocol = function () {
            return this.serviceCallRunner.execute(this.getAuthorizedHostProtocolCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//17
         *
         * @tapVersion(">=")
         * @return call options
         */
        InterfaceService.prototype.getAuthorizedHostProtocolCall = function () {
            var callOptions = __assign$1({}, this.resources.getAuthorizedHostProtocol);
            return callOptions;
        };
        /**
         * Write authorized host protocols
         *
         * LWM2M path: /1024//17
         *
         * @tapVersion(">=")
         * @param mode input
         * @return
         */
        InterfaceService.prototype.putAuthorizedHostProtocol = function (
        /*
         *
         */
        mode) {
            return this.serviceCallRunner.execute(this.putAuthorizedHostProtocolCall(mode));
        };
        /**
         *
         *
         * LWM2M path: /1024//17
         *
         * @tapVersion(">=")
         * @param mode input
         * @return call options
         */
        InterfaceService.prototype.putAuthorizedHostProtocolCall = function (
        /*
         *
         */
        mode) {
            var callOptions = __assign$1({}, this.resources.putAuthorizedHostProtocol);
            callOptions.body = mode;
            return callOptions;
        };
        /**
         * Get config format firmware version
         *
         * LWM2M path: /1024//18
         *
         * @tapVersion(">=")
         * @return
         */
        InterfaceService.prototype.getConfigFormatFirmwareVersion = function () {
            return this.serviceCallRunner.execute(this.getConfigFormatFirmwareVersionCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//18
         *
         * @tapVersion(">=")
         * @return call options
         */
        InterfaceService.prototype.getConfigFormatFirmwareVersionCall = function () {
            var callOptions = __assign$1({}, this.resources.getConfigFormatFirmwareVersion);
            return callOptions;
        };
        /**
         * Get configured universal link value
         *
         * LWM2M path: /1024//19
         *
         * @tapVersion(">=")
         * @return
         */
        InterfaceService.prototype.getUniversalLink = function () {
            return this.serviceCallRunner.execute(this.getUniversalLinkCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//19
         *
         * @tapVersion(">=")
         * @return call options
         */
        InterfaceService.prototype.getUniversalLinkCall = function () {
            var callOptions = __assign$1({}, this.resources.getUniversalLink);
            return callOptions;
        };
        /**
         * Write universal link value
         *
         * LWM2M path: /1024//19
         *
         * @tapVersion(">=")
         * @param url input
         * @return
         */
        InterfaceService.prototype.putUniversalLink = function (
        /*
         *
         */
        url) {
            return this.serviceCallRunner.execute(this.putUniversalLinkCall(url));
        };
        /**
         *
         *
         * LWM2M path: /1024//19
         *
         * @tapVersion(">=")
         * @param url input
         * @return call options
         */
        InterfaceService.prototype.putUniversalLinkCall = function (
        /*
         *
         */
        url) {
            var callOptions = __assign$1({}, this.resources.putUniversalLink);
            callOptions.body = url;
            return callOptions;
        };
        /**
         * Get available host protocols
         *
         * LWM2M path: /1024//21
         *
         * @tapVersion(">=")
         * @return
         */
        InterfaceService.prototype.getAvailableHostProtocols = function () {
            return this.serviceCallRunner.execute(this.getAvailableHostProtocolsCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//21
         *
         * @tapVersion(">=")
         * @return call options
         */
        InterfaceService.prototype.getAvailableHostProtocolsCall = function () {
            var callOptions = __assign$1({}, this.resources.getAvailableHostProtocols);
            return callOptions;
        };
        /**
         * Get currently disabled service list
         *
         * LWM2M path: /1024//75
         *
         * @tapVersion(">=1.107")
         * @return
         */
        InterfaceService.prototype.getDisabledServices = function () {
            return this.serviceCallRunner.execute(this.getDisabledServicesCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//75
         *
         * @tapVersion(">=1.107")
         * @return call options
         */
        InterfaceService.prototype.getDisabledServicesCall = function () {
            var callOptions = __assign$1({}, this.resources.getDisabledServices);
            return callOptions;
        };
        /**
         * Enable/disable execution of services
         *
         * LWM2M path: /1024//75
         *
         * @tapVersion(">=1.107")
         * @param serviceCodes input
         * @return
         */
        InterfaceService.prototype.postDisabledServices = function (
        /*
         *
         */
        serviceCodes) {
            return this.serviceCallRunner.execute(this.postDisabledServicesCall(serviceCodes));
        };
        /**
         *
         *
         * LWM2M path: /1024//75
         *
         * @tapVersion(">=1.107")
         * @param serviceCodes input
         * @return call options
         */
        InterfaceService.prototype.postDisabledServicesCall = function (
        /*
         *
         */
        serviceCodes) {
            var callOptions = __assign$1({}, this.resources.postDisabledServices);
            callOptions.body = serviceCodes;
            return callOptions;
        };
        /**
         * Get NFC connection priority over other protocols
         *
         * LWM2M path: /1024//24
         *
         * @tapVersion(">=1.85")
         * @return
         */
        InterfaceService.prototype.getNfcConnectionPriority = function () {
            return this.serviceCallRunner.execute(this.getNfcConnectionPriorityCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//24
         *
         * @tapVersion(">=1.85")
         * @return call options
         */
        InterfaceService.prototype.getNfcConnectionPriorityCall = function () {
            var callOptions = __assign$1({}, this.resources.getNfcConnectionPriority);
            return callOptions;
        };
        /**
         * Set NFC connection priority over other protocols (until reboot)
         *
         * LWM2M path: /1024//24
         *
         * @tapVersion(">=1.85")
         * @param key input
         * @return
         */
        InterfaceService.prototype.postNfcConnectionPriority = function (
        /*
         *
         */
        key) {
            return this.serviceCallRunner.execute(this.postNfcConnectionPriorityCall(key));
        };
        /**
         *
         *
         * LWM2M path: /1024//24
         *
         * @tapVersion(">=1.85")
         * @param key input
         * @return call options
         */
        InterfaceService.prototype.postNfcConnectionPriorityCall = function (
        /*
         *
         */
        key) {
            var callOptions = __assign$1({}, this.resources.postNfcConnectionPriority);
            callOptions.body = key;
            return callOptions;
        };
        /**
         * Write in configuration NFC connection priority over other protocols
         *
         * LWM2M path: /1024//24
         *
         * @tapVersion(">=1.85")
         * @param key input
         * @return
         */
        InterfaceService.prototype.putNfcConnectionPriority = function (
        /*
         *
         */
        key) {
            return this.serviceCallRunner.execute(this.putNfcConnectionPriorityCall(key));
        };
        /**
         *
         *
         * LWM2M path: /1024//24
         *
         * @tapVersion(">=1.85")
         * @param key input
         * @return call options
         */
        InterfaceService.prototype.putNfcConnectionPriorityCall = function (
        /*
         *
         */
        key) {
            var callOptions = __assign$1({}, this.resources.putNfcConnectionPriority);
            callOptions.body = key;
            return callOptions;
        };
        /**
         * Get profile id that will be logged in when starting an encrypted session with NFC
         *
         * LWM2M path: /1024//43
         *
         * @tapVersion(">=1.55")
         * @return
         */
        InterfaceService.prototype.getNfcAutologProfileId = function () {
            return this.serviceCallRunner.execute(this.getNfcAutologProfileIdCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//43
         *
         * @tapVersion(">=1.55")
         * @return call options
         */
        InterfaceService.prototype.getNfcAutologProfileIdCall = function () {
            var callOptions = __assign$1({}, this.resources.getNfcAutologProfileId);
            return callOptions;
        };
        /**
         * Write profile id
         *
         * LWM2M path: /1024//43
         *
         * @tapVersion(">=1.55")
         * @param value input
         * @return
         */
        InterfaceService.prototype.putNfcAutologProfileId = function (
        /*
         *
         */
        value) {
            return this.serviceCallRunner.execute(this.putNfcAutologProfileIdCall(value));
        };
        /**
         *
         *
         * LWM2M path: /1024//43
         *
         * @tapVersion(">=1.55")
         * @param value input
         * @return call options
         */
        InterfaceService.prototype.putNfcAutologProfileIdCall = function (
        /*
         *
         */
        value) {
            var callOptions = __assign$1({}, this.resources.putNfcAutologProfileId);
            callOptions.body = value;
            return callOptions;
        };
        /**
         * Get host inactivity period
         *
         * LWM2M path: /1024//34
         *
         * @tapVersion(">=")
         * @return
         */
        InterfaceService.prototype.getHostInactivityPeriod = function () {
            return this.serviceCallRunner.execute(this.getHostInactivityPeriodCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//34
         *
         * @tapVersion(">=")
         * @return call options
         */
        InterfaceService.prototype.getHostInactivityPeriodCall = function () {
            var callOptions = __assign$1({}, this.resources.getHostInactivityPeriod);
            return callOptions;
        };
        /**
         * Write host inactivity timeout
         *
         * LWM2M path: /1024//34
         *
         * @tapVersion(">=")
         * @param key input
         * @return
         */
        InterfaceService.prototype.putHostInactivityPeriod = function (
        /*
         *
         */
        key) {
            return this.serviceCallRunner.execute(this.putHostInactivityPeriodCall(key));
        };
        /**
         *
         *
         * LWM2M path: /1024//34
         *
         * @tapVersion(">=")
         * @param key input
         * @return call options
         */
        InterfaceService.prototype.putHostInactivityPeriodCall = function (
        /*
         *
         */
        key) {
            var callOptions = __assign$1({}, this.resources.putHostInactivityPeriod);
            callOptions.body = key;
            return callOptions;
        };
        /**
         * Get application data
         *
         * LWM2M path: /1024//36
         *
         * @tapVersion(">=")
         * @return
         */
        InterfaceService.prototype.getApplicationData = function () {
            return this.serviceCallRunner.execute(this.getApplicationDataCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//36
         *
         * @tapVersion(">=")
         * @return call options
         */
        InterfaceService.prototype.getApplicationDataCall = function () {
            var callOptions = __assign$1({}, this.resources.getApplicationData);
            return callOptions;
        };
        /**
         * Write custom application data
         *
         * LWM2M path: /1024//36
         *
         * @tapVersion(">=")
         * @param value input
         * @return
         */
        InterfaceService.prototype.putApplicationData = function (
        /*
         *
         */
        value) {
            return this.serviceCallRunner.execute(this.putApplicationDataCall(value));
        };
        /**
         *
         *
         * LWM2M path: /1024//36
         *
         * @tapVersion(">=")
         * @param value input
         * @return call options
         */
        InterfaceService.prototype.putApplicationDataCall = function (
        /*
         *
         */
        value) {
            var callOptions = __assign$1({}, this.resources.putApplicationData);
            callOptions.body = value;
            return callOptions;
        };
        /**
         * Get the Tap product key
         *
         * LWM2M path: /1024//60
         *
         * @tapVersion(">=")
         * @return
         */
        InterfaceService.prototype.getProductKey = function () {
            return this.serviceCallRunner.execute(this.getProductKeyCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//60
         *
         * @tapVersion(">=")
         * @return call options
         */
        InterfaceService.prototype.getProductKeyCall = function () {
            var callOptions = __assign$1({}, this.resources.getProductKey);
            return callOptions;
        };
        /**
         * Get max frame sizes for current host protocol
         *
         * LWM2M path: /1024//88
         *
         * @tapVersion(">=1.88")
         * @return
         */
        InterfaceService.prototype.getCurrentHostProtocolMaxFrameSize = function () {
            return this.serviceCallRunner.execute(this.getCurrentHostProtocolMaxFrameSizeCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//88
         *
         * @tapVersion(">=1.88")
         * @return call options
         */
        InterfaceService.prototype.getCurrentHostProtocolMaxFrameSizeCall = function () {
            var callOptions = __assign$1({}, this.resources.getCurrentHostProtocolMaxFrameSize);
            return callOptions;
        };
        /**
         * Execute multiple commands sent in one frame, and return all answers in one
         *
         * LWM2M path: /1024//89
         *
         * @tapVersion(">=1.13")
         * @param data input
         * @return
         */
        InterfaceService.prototype.executeMultiRequestFrame = function (
        /*
         *
         */
        data) {
            return this.serviceCallRunner.execute(this.executeMultiRequestFrameCall(data));
        };
        /**
         *
         *
         * LWM2M path: /1024//89
         *
         * @tapVersion(">=1.13")
         * @param data input
         * @return call options
         */
        InterfaceService.prototype.executeMultiRequestFrameCall = function (
        /*
         *
         */
        data) {
            var callOptions = __assign$1({}, this.resources.executeMultiRequestFrame);
            callOptions.body = data;
            return callOptions;
        };
        /**
         * Certificate data in PEM format for SSL mutual authentication, default is NULL
         *
         * LWM2M path: /1024//37
         *
         * @tapVersion(">=1.86")
         * @param value input
         * @return
         */
        InterfaceService.prototype.putCertificatePublicKey = function (
        /*
         * Up to 16kB
         */
        value) {
            return this.serviceCallRunner.execute(this.putCertificatePublicKeyCall(value));
        };
        InterfaceService.prototype.putCertificatePublicKeyAppendCalls = function (
        /*
         * Up to 16kB
         */
        value, chunkSize) {
            return this.serviceCallRunner.createAppendCalls(this.putCertificatePublicKeyCall(value), chunkSize);
        };
        /**
         *
         *
         * LWM2M path: /1024//37
         *
         * @tapVersion(">=1.86")
         * @param value input
         * @return call options
         */
        InterfaceService.prototype.putCertificatePublicKeyCall = function (
        /*
         * Up to 16kB
         */
        value) {
            var callOptions = __assign$1({}, this.resources.putCertificatePublicKey);
            callOptions.body = value;
            return callOptions;
        };
        /**
         * private key data in PEM format for SSL mutual authentication, default is NULL
         *
         * LWM2M path: /1024//38
         *
         * @tapVersion(">=1.86")
         * @param value input
         * @return
         */
        InterfaceService.prototype.putCertificatePrivateKey = function (
        /*
         * Up to 16kB
         */
        value) {
            return this.serviceCallRunner.execute(this.putCertificatePrivateKeyCall(value));
        };
        InterfaceService.prototype.putCertificatePrivateKeyAppendCalls = function (
        /*
         * Up to 16kB
         */
        value, chunkSize) {
            return this.serviceCallRunner.createAppendCalls(this.putCertificatePrivateKeyCall(value), chunkSize);
        };
        /**
         *
         *
         * LWM2M path: /1024//38
         *
         * @tapVersion(">=1.86")
         * @param value input
         * @return call options
         */
        InterfaceService.prototype.putCertificatePrivateKeyCall = function (
        /*
         * Up to 16kB
         */
        value) {
            var callOptions = __assign$1({}, this.resources.putCertificatePrivateKey);
            callOptions.body = value;
            return callOptions;
        };
        /**
         * Get product code
         *
         * LWM2M path: /1024//84
         *
         * @tapVersion(">=1.113")
         * @return
         */
        InterfaceService.prototype.getProductCode = function () {
            return this.serviceCallRunner.execute(this.getProductCodeCall());
        };
        /**
         *
         *
         * LWM2M path: /1024//84
         *
         * @tapVersion(">=1.113")
         * @return call options
         */
        InterfaceService.prototype.getProductCodeCall = function () {
            var callOptions = __assign$1({}, this.resources.getProductCode);
            return callOptions;
        };
        /**
         * Put product code
         *
         * LWM2M path: /1024//84
         *
         * @tapVersion(">=1.113")
         * @param topic input
         * @return
         */
        InterfaceService.prototype.putProductCode = function (
        /*
         *
         */
        topic) {
            return this.serviceCallRunner.execute(this.putProductCodeCall(topic));
        };
        /**
         *
         *
         * LWM2M path: /1024//84
         *
         * @tapVersion(">=1.113")
         * @param topic input
         * @return call options
         */
        InterfaceService.prototype.putProductCodeCall = function (
        /*
         *
         */
        topic) {
            var callOptions = __assign$1({}, this.resources.putProductCode);
            callOptions.body = topic;
            return callOptions;
        };
        /**
         * Get bundle id that have the special feature. Si non définit, retourne 0x0
         *
         * LWM2M path: /1024//{featureId}
         *
         * @tapVersion(">=1.23")
         * @param featureId input
         * @return
         */
        InterfaceService.prototype.getSpecialFeatureProfile = function (
        /*
         *
         */
        featureId) {
            return this.serviceCallRunner.execute(this.getSpecialFeatureProfileCall(featureId));
        };
        /**
         *
         *
         * LWM2M path: /1024//{featureId}
         *
         * @tapVersion(">=1.23")
         * @param featureId input
         * @return call options
         */
        InterfaceService.prototype.getSpecialFeatureProfileCall = function (
        /*
         *
         */
        featureId) {
            var callOptions = __assign$1({}, this.resources.getSpecialFeatureProfile);
            callOptions.pathParameters = {
                featureId: featureId
            };
            return callOptions;
        };
        /**
         * Set bundle id that own the special feature
         *
         * LWM2M path: /1024//{featureId}
         *
         * @tapVersion(">=1.23")
         * @param featureId input
         * @param value input
         * @return
         */
        InterfaceService.prototype.setSpecialFeatureProfile = function (
        /*
         *
         */
        featureId, 
        /*
         * Profile id
         */
        value) {
            return this.serviceCallRunner.execute(this.setSpecialFeatureProfileCall(featureId, value));
        };
        /**
         *
         *
         * LWM2M path: /1024//{featureId}
         *
         * @tapVersion(">=1.23")
         * @param featureId input
         * @param value input
         * @return call options
         */
        InterfaceService.prototype.setSpecialFeatureProfileCall = function (
        /*
         *
         */
        featureId, 
        /*
         * Profile id
         */
        value) {
            var callOptions = __assign$1({}, this.resources.setSpecialFeatureProfile);
            callOptions.body = value;
            callOptions.pathParameters = {
                featureId: featureId
            };
            return callOptions;
        };
        /**
         * Write bundle id that own the special feature
         *
         * LWM2M path: /1024//{featureId}
         *
         * @tapVersion(">=1.23")
         * @param featureId input
         * @param value input
         * @return
         */
        InterfaceService.prototype.putSpecialFeatureProfile = function (
        /*
         *
         */
        featureId, 
        /*
         * Profile id
         */
        value) {
            return this.serviceCallRunner.execute(this.putSpecialFeatureProfileCall(featureId, value));
        };
        /**
         *
         *
         * LWM2M path: /1024//{featureId}
         *
         * @tapVersion(">=1.23")
         * @param featureId input
         * @param value input
         * @return call options
         */
        InterfaceService.prototype.putSpecialFeatureProfileCall = function (
        /*
         *
         */
        featureId, 
        /*
         * Profile id
         */
        value) {
            var callOptions = __assign$1({}, this.resources.putSpecialFeatureProfile);
            callOptions.body = value;
            callOptions.pathParameters = {
                featureId: featureId
            };
            return callOptions;
        };
        return InterfaceService;
    }(tap.AbstractService));

    var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
        return new (P || (P = Promise))(function (resolve, reject) {
            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
            step((generator = generator.apply(thisArg, _arguments || [])).next());
        });
    };
    var __generator = (this && this.__generator) || function (thisArg, body) {
        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
        function verb(n) { return function (v) { return step([n, v]); }; }
        function step(op) {
            if (f) throw new TypeError("Generator is already executing.");
            while (_) try {
                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
                if (y = 0, t) op = [op[0] & 2, t.value];
                switch (op[0]) {
                    case 0: case 1: t = op; break;
                    case 4: _.label++; return { value: op[1], done: false };
                    case 5: _.label++; y = op[1]; op = [0]; continue;
                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
                    default:
                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                        if (t[2]) _.ops.pop();
                        _.trys.pop(); continue;
                }
                op = body.call(thisArg, _);
            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
        }
    };
    InterfaceService.prototype.getAppUrl = function () {
        return __awaiter(this, void 0, void 0, function () {
            var appPath, body, code, content;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.getAppPath()];
                    case 1:
                        appPath = _a.sent();
                        if (appPath.isSuccessful()) {
                            body = appPath.body();
                            if (body.match(/^\$[1-6]\//)) {
                                code = body.substring(0, 3);
                                content = body.substring(3);
                                switch (code) {
                                    case '$1/':
                                        body = "https://user.cloud.iotize.com/users/" + content;
                                        break;
                                    case '$2/':
                                        body = "http://" + content;
                                        break;
                                    case '$5/':
                                        body = "https://user.cloud.iotize.com/users/" + content;
                                        break;
                                    default:
                                        body = '';
                                }
                                appPath.setBody(body);
                            }
                        }
                        return [2 /*return*/, appPath];
                }
            });
        });
    };
    InterfaceService.prototype.getAndroidApplicationId = function () {
        return __awaiter(this, void 0, void 0, function () {
            var appPath, body;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.getAppPath()];
                    case 1:
                        appPath = _a.sent();
                        if (appPath.isSuccessful()) {
                            body = appPath.body();
                            if (body.startsWith('$4/')) { // TODO replace with constant
                                appPath.setBody(body.substring(3));
                            }
                            else {
                                appPath.setBody("");
                            }
                        }
                        return [2 /*return*/, appPath];
                }
            });
        });
    };
    InterfaceService.prototype.putAndroidApplicationId = function (value) {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                return [2 /*return*/, this.putAppPath("$4/" + value)];
            });
        });
    };

    var __awaiter$1 = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
        return new (P || (P = Promise))(function (resolve, reject) {
            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
            step((generator = generator.apply(thisArg, _arguments || [])).next());
        });
    };
    var __generator$1 = (this && this.__generator) || function (thisArg, body) {
        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
        function verb(n) { return function (v) { return step([n, v]); }; }
        function step(op) {
            if (f) throw new TypeError("Generator is already executing.");
            while (_) try {
                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
                if (y = 0, t) op = [op[0] & 2, t.value];
                switch (op[0]) {
                    case 0: case 1: t = op; break;
                    case 4: _.label++; return { value: op[1], done: false };
                    case 5: _.label++; y = op[1]; op = [0]; continue;
                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
                    default:
                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                        if (t[2]) _.ops.pop();
                        _.trys.pop(); continue;
                }
                op = body.call(thisArg, _);
            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
        }
    };
    // type ExecuteMultipleCallsParameterType<BodyType, ReturnType> = ExecuteMutlipleCallItem<>[];
    var TAP_REQUEST_FRAME_HEADER_LENGTH = 7; // TODO generated instead
    function toBodyDecoder(input) {
        if (typeof input === 'function') {
            return {
                decode: input
            };
        }
        else {
            return input;
        }
    }
    function toCall(serviceCall) {
        if ('expectedResponseStatus' in serviceCall) {
            return serviceCall.call;
        }
        else {
            return serviceCall;
        }
    }
    InterfaceService.prototype.executeMultipleCalls = function (calls, defaultExpectedResponseStatus) {
        if (defaultExpectedResponseStatus === void 0) { defaultExpectedResponseStatus = exports.MultiRequestFrame.ExpectedResponseStatus.ANYTHING; }
        return __awaiter$1(this, void 0, void 0, function () {
            var decoders, multiRequestRequests, multiRequestFrame, response, body, responses;
            return __generator$1(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        decoders = calls.map(function (serviceCall) { return toBodyDecoder(toCall(serviceCall).responseBodyDecoder); });
                        multiRequestRequests = createMultiRequestItems(calls, defaultExpectedResponseStatus);
                        multiRequestFrame = {
                            requests: multiRequestRequests.map(function (item) { return item.requestItem; })
                        };
                        return [4 /*yield*/, this.executeMultiRequestFrame(multiRequestFrame)];
                    case 1:
                        response = _a.sent();
                        body = response.body();
                        if (body.responses.length !== calls.length) {
                            throw new Error("API sent " + calls.length + " request(s) but tap responded with " + body.responses.length + " response(s).");
                        }
                        responses = body.responses.map(function (tapResponseItem, index) {
                            var response = new tap.TapResponse(tapResponseItem.response);
                            var decoder = decoders[index];
                            if (decoder) {
                                response.setBodyDecoder(decoder);
                            }
                            response.setRequest(multiRequestRequests[index].requestItem.request);
                            if (!response.isSuccessful()) {
                                response.setError(tap.TapError.reponseStatusError(response, toCall(calls[index])));
                            }
                            return response;
                        });
                        return [2 /*return*/, responses];
                }
            });
        });
    };
    function createMultiRequestItems(calls, defaultExpectedResponseStatus) {
        if (defaultExpectedResponseStatus === void 0) { defaultExpectedResponseStatus = exports.MultiRequestFrame.ExpectedResponseStatus.ANYTHING; }
        return calls.map(function (serviceCall) {
            var call;
            var expectedResponseStatus;
            if ('expectedResponseStatus' in serviceCall) {
                call = serviceCall.call;
                expectedResponseStatus = serviceCall.expectedResponseStatus;
            }
            else {
                call = serviceCall;
                expectedResponseStatus = defaultExpectedResponseStatus;
            }
            var request = tap.ServiceCallRunner.toTapRequest(call);
            var responseBodyDecoder = tap.ServiceCallRunner.resolveResponseBodyDecoder(call);
            return {
                requestItem: {
                    expectedResponseStatus: expectedResponseStatus,
                    request: request,
                    requestLen: request.payload.length +
                        TAP_REQUEST_FRAME_HEADER_LENGTH
                },
                responseBodyDecoder: responseBodyDecoder
            };
        });
    }

    var _TAP_SERVICE_EXTENSION_INTERFACE_ = tap.extendServiceContainer("interface", InterfaceService);

    exports.INTERFACE_SERVICE_CALLS = SERVICE_CALLS;
    exports.InterfaceService = InterfaceService;
    exports.LoginCredentialConverter = LoginCredentialConverter;
    exports.LoginCredentialHashedConverter = LoginCredentialHashedConverter;
    exports.MultiRequestFrameConverter = MultiRequestFrameConverter;
    exports.MultiResponseFrameConverter = MultiResponseFrameConverter;
    exports.ProtocolMaxFrameSizeConverter = ProtocolMaxFrameSizeConverter;
    exports.SecurityOptionsConverter = SecurityOptionsConverter;
    exports._TAP_SERVICE_EXTENSION_INTERFACE_ = _TAP_SERVICE_EXTENSION_INTERFACE_;
    exports.interfaceConverters = serviceConverters;

    Object.defineProperty(exports, '__esModule', { value: true });

})));
//# sourceMappingURL=iotize-tap-service-impl-interface.umd.js.map
