(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('@iotize/common/byte-converter'), require('@iotize/device-client.js/client/impl'), require('@iotize/device-client.js/protocol/core'), require('rxjs'), require('rxjs/operators'), require('@iotize/common'), require('@iotize/common/byte-stream'), require('@iotize/device-client.js/client/api'), require('@iotize/device-client.js')) :
    typeof define === 'function' && define.amd ? define('@iotize/device-client.js/testing', ['@iotize/common/byte-converter', '@iotize/device-client.js/client/impl', '@iotize/device-client.js/protocol/core', 'rxjs', 'rxjs/operators', '@iotize/common', '@iotize/common/byte-stream', '@iotize/device-client.js/client/api', '@iotize/device-client.js'], factory) :
    (global = global || self, (global.iotize = global.iotize || {}, global.iotize['device-client'] = global.iotize['device-client'] || {}, global.iotize['device-client'].js = global.iotize['device-client'].js || {}, global.iotize['device-client'].js.testing = factory(global.byteConverter, global.iotize['device-client'].js.client.impl, global.iotize['device-client'].js.protocol.core, global.rxjs, global.rxjs.operators, global.common, global.byteStream, global.iotize['device-client'].js.client.api, global.iotize['device-client'].js)));
}(this, (function (byteConverter, impl, core, rxjs, operators, common, byteStream, api, deviceClient) { 'use strict';

    byteConverter = byteConverter && byteConverter.hasOwnProperty('default') ? byteConverter['default'] : byteConverter;
    impl = impl && impl.hasOwnProperty('default') ? impl['default'] : impl;
    core = core && core.hasOwnProperty('default') ? core['default'] : core;
    rxjs = rxjs && rxjs.hasOwnProperty('default') ? rxjs['default'] : rxjs;
    operators = operators && operators.hasOwnProperty('default') ? operators['default'] : operators;
    common = common && common.hasOwnProperty('default') ? common['default'] : common;
    byteStream = byteStream && byteStream.hasOwnProperty('default') ? byteStream['default'] : byteStream;
    api = api && api.hasOwnProperty('default') ? api['default'] : api;
    deviceClient = deviceClient && deviceClient.hasOwnProperty('default') ? deviceClient['default'] : deviceClient;

    var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

    function commonjsRequire () {
    	throw new Error('Dynamic requires are not currently supported by rollup-plugin-commonjs');
    }

    function unwrapExports (x) {
    	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
    }

    function createCommonjsModule(fn, module) {
    	return module = { exports: {} }, fn(module, module.exports), module.exports;
    }

    function getCjsExportFromNamespace (n) {
    	return n && n['default'] || n;
    }

    var debug = createCommonjsModule(function (module, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });

    var prefix = '@iotize:device-client.js:testing';
    exports.debug = common.createDebugger(prefix);

    });

    var debug$1 = unwrapExports(debug);
    var debug_1 = debug.debug;

    var util = createCommonjsModule(function (module, exports) {
    "use strict";
    var __values = (commonjsGlobal && commonjsGlobal.__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.");
    };
    Object.defineProperty(exports, "__esModule", { value: true });



    var impl_2 = impl;

    var TAG = 'MockProtocol';
    var EqualRequestFilter = /** @class */ (function () {
        function EqualRequestFilter(command) {
            this.command = command;
        }
        EqualRequestFilter.prototype.test = function (command) {
            if (!command) {
                return true;
            }
            return this.command.toString() === command.toString();
        };
        EqualRequestFilter.prototype.toString = function () {
            return "EqualRequestFilter " + this.command;
        };
        return EqualRequestFilter;
    }());
    exports.EqualRequestFilter = EqualRequestFilter;
    var RegExpFilter = /** @class */ (function () {
        function RegExpFilter(regex) {
            this.regex = regex;
        }
        RegExpFilter.prototype.test = function (input) {
            var cmdString = input.toString();
            return Boolean(cmdString.match(this.regex));
        };
        return RegExpFilter;
    }());
    exports.RegExpFilter = RegExpFilter;
    var Util = /** @class */ (function () {
        function Util() {
        }
        // public static REQUEST_REGEX: RegExp = /^(GET|PUT|POST) ((\/[a-zA-Z0-9])+) (0x([a-zA-Z0-9]+))?$/i;
        Util.parseApiRequestString = function (cmdString) {
            var parts = cmdString.split(' ');
            var methodtype = parts[0].toUpperCase();
            if (['GET', 'PUT', 'POST'].indexOf(methodtype) === -1) {
                throw new Error("Invalid command type: " + methodtype + ". From command: \"" + cmdString + "\"");
            }
            var methodPath = parts[1];
            var payload = undefined;
            if (parts.length >= 3) {
                payload = byteConverter.hexStringToBuffer(parts[2]);
            }
            // TODO improve as we can call anyother static function
            // It should be reduce to GET, PUT, POST
            return impl_2.ApiRequest[methodtype](methodPath, payload);
        };
        return Util;
    }());
    exports.Util = Util;
    var Router = /** @class */ (function () {
        function Router() {
            this._routes = [];
        }
        Object.defineProperty(Router.prototype, "routes", {
            get: function () {
                return this._routes;
            },
            enumerable: true,
            configurable: true
        });
        Router.prototype.findRoute = function (request) {
            var e_1, _a;
            var adapter;
            try {
                for (var _b = __values(this._routes), _c = _b.next(); !_c.done; _c = _b.next()) {
                    var route = _c.value;
                    // debug("\t- MockProtocol", `Check route: ${route.filter.toString()}`);
                    if (route.predicate.test(request)) {
                        adapter = route.adapter;
                        break;
                    }
                }
            }
            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; }
            }
            var response;
            if (!adapter) {
                return null;
            }
            else {
                response = adapter.adapt(request);
            }
            return response;
        };
        Router.prototype.addRoute = function (left, right) {
            var filter;
            if (typeof left === 'string') {
                left = Util.parseApiRequestString(left);
            }
            if (left instanceof impl_2.ApiRequest) {
                filter = new EqualRequestFilter(left);
            }
            else if (left instanceof RegExp) {
                filter = new RegExpFilter(left);
            }
            else if (typeof left === 'function') {
                filter = {
                    test: left
                };
            }
            else {
                filter = left;
            }
            var adapter;
            if (right instanceof impl.ResponseImpl) {
                adapter = new (/** @class */ (function () {
                    function Tmp() {
                    }
                    Tmp.prototype.adapt = function (command) {
                        return right;
                    };
                    return Tmp;
                }()))();
            }
            else if (right instanceof Uint8Array) {
                adapter = new (/** @class */ (function () {
                    function Tmp() {
                    }
                    Tmp.prototype.adapt = function (command) {
                        return new impl.ResponseImpl(right);
                    };
                    return Tmp;
                }()))();
            }
            else if (typeof right === 'function') {
                adapter = {
                    adapt: right
                };
            }
            else {
                adapter = right;
            }
            this._routes.push({
                predicate: filter,
                adapter: adapter
            });
            return this;
        };
        /**
         * Mapping a command (represented as a string with format "<request-type> <path> [data]"
         * ie: GET /3//3 0xABCD or POST /1024//0 0xtest
         *
         * Response must either be:
         *  - an hexadecimal data represented as a string (0xABCD)
         *  - An object with a coreRet and a body
         *  - A Uint8Array
         */
        Router.prototype.addRoutes = function (map) {
            for (var pathString in map) {
                var info = map[pathString];
                var command = Util.parseApiRequestString(pathString);
                var response = void 0;
                if (info instanceof Uint8Array) {
                    response = new impl.ResponseImpl(info);
                }
                else if (info instanceof impl.ResponseImpl) {
                    response = info;
                }
                else if (typeof info === 'number') {
                    response = impl.ResponseImpl.create(info);
                }
                else if (typeof info === 'string') {
                    response = new impl.ResponseImpl(byteConverter.hexStringToBuffer(info));
                }
                else if (typeof info === 'object') {
                    var codeRet = info.codeRet;
                    response = new impl.ResponseImpl(byteStream.KaitaiStreamWriter.mergeArrays(Uint8Array.from([codeRet]), info.body || new Uint8Array(0)));
                }
                else {
                    throw new Error("Invalid response type " + typeof info + " with value: " + JSON.stringify(info));
                }
                debug.debug(TAG, "\t- Add map " + command + " -> " + response);
                this.addRoute(command, response);
            }
            return this;
        };
        Router.prototype.clearRoutes = function () {
            this._routes = [];
            return this;
        };
        return Router;
    }());
    exports.Router = Router;

    });

    var util$1 = unwrapExports(util);
    var util_1 = util.EqualRequestFilter;
    var util_2 = util.RegExpFilter;
    var util_3 = util.Util;
    var util_4 = util.Router;

    var mockProtocol = createCommonjsModule(function (module, exports) {
    "use strict";
    var __extends = (commonjsGlobal && commonjsGlobal.__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 __());
        };
    })();
    Object.defineProperty(exports, "__esModule", { value: true });








    var TAG = 'MockProtocol';
    /**
     *
     * <p>
     * This is a mock com protocol for testing only
     * <p>
     * We can simulate iotize response according to the request message
     */
    var MockProtocol = /** @class */ (function (_super) {
        __extends(MockProtocol, _super);
        function MockProtocol() {
            var _this = _super.call(this) || this;
            _this.mockOptions = {
                connect: {
                    delay: 100
                },
                disconnect: {
                    delay: 100
                },
                write: {
                    delay: 1
                }
            };
            _this._router = new util.Router();
            // this.connectDelay = 2000;
            // this.disconnectDelay = 2000;
            // this.callback = callback;
            _this.inputData = new Uint8Array(0);
            _this.outputData = new Uint8Array(0);
            _this.commandDecoder = new impl.DefaultCommandDecoder();
            _this.responseEncoder = new impl.DefaultResponseEncoder();
            return _this;
            // this.configuration = new Configuration();
            // this.configuration.connectionTimeoutMillis = 3000;
            // this.configuration.sendTimeoutMillis = 3000;
        }
        MockProtocol.MIRROR = function () {
            var mockProtocol = new MockProtocol();
            mockProtocol.router.addRoute({
                test: function (command) {
                    return true;
                }
                // toString: () => {
                //     return `MirrorFilter for ALL request`;
                // }
            }, {
                adapt: function (command) {
                    return impl.Response.SUCCESS(command.getData());
                }
            });
            return mockProtocol;
        };
        Object.defineProperty(MockProtocol.prototype, "router", {
            get: function () {
                return this._router;
            },
            enumerable: true,
            configurable: true
        });
        MockProtocol.prototype.setConnectionState = function (connectionState) {
            debug.debug(TAG, "setConnectionState: " + connectionState);
            this.connectionState = connectionState;
            return this;
        };
        MockProtocol.prototype.setConnectDelay = function (connectDelay) {
            this.mockOptions.connect.delay = connectDelay;
            return this;
        };
        MockProtocol.prototype.getDisconnectDelay = function () {
            return this.mockOptions.disconnect.delay;
        };
        MockProtocol.prototype.setDisconnectDelay = function (disconnectDelay) {
            this.mockOptions.disconnect.delay = disconnectDelay;
            return this;
        };
        MockProtocol.prototype.hasNewData = function () {
            return this.inputData != null;
        };
        MockProtocol.prototype.setInputData = function (inputData) {
            this.inputData = inputData;
        };
        MockProtocol.prototype.setOutputData = function (outputData) {
            this.outputData = outputData;
        };
        MockProtocol.prototype.setCallback = function (callback) {
            this.callback = callback;
        };
        MockProtocol.prototype._connect = function (options) {
            return rxjs.of(null).pipe(operators.delay(this.mockOptions.connect.delay));
        };
        MockProtocol.prototype._disconnect = function (options) {
            return rxjs.of(null).pipe(operators.delay(this.mockOptions.disconnect.delay));
        };
        MockProtocol.prototype.write = function (message) {
            var _this = this;
            try {
                if (this.callback != null) {
                    this.callback.beforeWrite(message);
                }
                this.outputData = message;
                // TODO we need to know if it's a command or a response ?
                var request = this.commandDecoder.decode(message);
                debug.debug(TAG, "MockProtocol decoded input " + byteConverter.bufferToHexString(message) + " to " + request);
                var response = this.router.findRoute(request);
                if (!response) {
                    response = impl.Response.ERROR(api.ResultCode.IOTIZE_501_NOT_IMPLEMENTED);
                }
                debug.debug(TAG, 'MockProtocol', 'Mocking response for ' + request + ' => ' + response);
                var result = this.responseEncoder.encode(response);
                this.inputData = result;
                if (this.callback != null) {
                    this.callback.afterWrite(message);
                }
                return new Promise(function (resolve) {
                    return setTimeout(resolve, _this.mockOptions.write.delay);
                });
            }
            catch (err) {
                return new Promise(function (resolve, reject) {
                    return setTimeout(function () { return reject(err); }, _this.mockOptions.write.delay);
                });
            }
        };
        MockProtocol.prototype.read = function () {
            try {
                if (this.callback) {
                    this.callback.beforeRead();
                }
                while (!this.hasNewData()) {
                    // TODO wait ??
                }
                if (this.hasNewData()) {
                    var result = rxjs.of(this.inputData);
                    if (this.callback) {
                        this.callback.afterRead(result);
                    }
                    return result.toPromise();
                }
                else {
                    return Promise.reject(new Error('Read timeout'));
                }
            }
            catch (err) {
                return Promise.reject(err);
            }
        };
        /**
         * @deprecated in favor of {@link #addRoute}
         */
        MockProtocol.prototype.mapResponse = function (left, right) {
            return this.addRoute(left, right);
        };
        MockProtocol.prototype.addRoute = function (left, right) {
            this.router.addRoute(left, right);
            return this;
        };
        //     public Configuration getConfiguration() {
        //     return configuration;
        // }
        /**
         * Create a new instance from roote mapping
         */
        MockProtocol.createFromRoutes = function (map) {
            var mockProtocol = new MockProtocol();
            mockProtocol.router.addRoutes(map);
            return mockProtocol;
        };
        return MockProtocol;
    }(core.QueueComProtocol));
    exports.MockProtocol = MockProtocol;
    //    public addOnRequestListener() {
    //        this.mOnRequestListener =
    //    }
    //    public interface onRequestListener{
    //        onRequest(RequestMessage request);
    //    }

    });

    var mockProtocol$1 = unwrapExports(mockProtocol);
    var mockProtocol_1 = mockProtocol.MockProtocol;

    var mockClient = createCommonjsModule(function (module, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });







    var TAG = 'MockClient';
    ;
    var MockClient = /** @class */ (function () {
        function MockClient(mapping, options) {
            this._isConnected = false;
            this._router = mapping || new util.Router();
            this.options = options || MockClient.DEFAULT_OPTIONS;
        }
        MockClient.prototype.addInterceptor = function (interceptor) {
            throw new Error('Method not implemented.');
        };
        MockClient.prototype.isEncryptionEnabled = function () {
            throw new Error('Method not implemented.');
        };
        /**
         *
         * TOPO add support for parameters ?
         * TODO use Shell Grammar instead ?
         *
         * @param map
         */
        MockClient.createFromMap = function (map) {
            var client = new MockClient();
            client.addRoutes(map);
            return client;
        };
        MockClient.fromMockProtocol = function (protocol) {
            var client = impl.DefaultIoTizeClient.create();
            client.addComProtocol(protocol);
            return client;
        };
        Object.defineProperty(MockClient.prototype, "router", {
            get: function () {
                return this._router;
            },
            enumerable: true,
            configurable: true
        });
        MockClient.prototype.isConnected = function () {
            return this._isConnected;
        };
        MockClient.prototype.onConnectionStateChange = function () {
            throw new Error('Method not implemented.');
        };
        MockClient.prototype.addComProtocol = function (newProtocol, id) {
            this._protocol = newProtocol;
            return this;
        };
        MockClient.prototype.switchProtocol = function (type) {
            throw new Error('Method not implemented.');
        };
        MockClient.prototype.getCurrentProtocol = function () {
            throw new Error('Method not implemented.');
        };
        MockClient.prototype.connect = function () {
            var _this = this;
            var observable = rxjs.of(null).pipe(operators.delay(this.options.connect.delay));
            observable.subscribe(function () {
                _this._isConnected = true;
            });
            return observable;
        };
        MockClient.prototype.disconnect = function () {
            var _this = this;
            var observable = rxjs.of(null).pipe(operators.delay(this.options.disconnect.delay));
            observable.subscribe(function () {
                _this._isConnected = false;
            });
            return observable;
        };
        MockClient.prototype.command = function (request, bodyDecoder) {
            if (!this._isConnected) {
                throw new Error("Device is not connected");
            }
            var response = this.computeResponse(request);
            return rxjs.from([response]).pipe(operators.delay(this.options.command.delay));
        };
        MockClient.prototype.useComProtocol = function (protocol) {
            throw new Error('Method not implemented.');
        };
        MockClient.prototype.send = function (dataIn, bodyDecoder) {
            throw new Error('Method not implemented.');
        };
        /**
         * @deprecated in favor of addRoute
         * @param cmd
         * @param response
         */
        MockClient.prototype.mapCommandToResponse = function (cmd, response) {
            return this.addRoute(cmd, response);
        };
        MockClient.prototype.addRoute = function (command, response) {
            debug.debug(TAG, "\t- Mapping command " + command.toString() + " to response " + response.toString());
            if (command instanceof RegExp) {
                throw new Error("Route with regular expressions are not implemented yet");
            }
            else if (typeof command === 'string') {
                command = util.Util.parseApiRequestString(command);
            }
            this.router.addRoute(command, this.createResponse(command, response));
            return this;
        };
        MockClient.prototype.addRoutes = function (map) {
            for (var pathString in map) {
                var info = map[pathString];
                var command = util.Util.parseApiRequestString(pathString);
                var response = this.createResponse(command, info);
                this.addRoute(command, response);
            }
            return this;
        };
        MockClient.prototype.hasRoute = function (command) {
            if (typeof command === 'string') {
                command = util.Util.parseApiRequestString(command);
            }
            return this.router.findRoute(command) != null;
        };
        MockClient.prototype.setEncryptionAlgo = function (algo) {
            this.encryptionAlgo = algo;
        };
        MockClient.prototype.getEncryptionAlgo = function () {
            return this.encryptionAlgo;
        };
        MockClient.prototype.enableEncryption = function (value) {
            this.options.encryption = value;
            return Promise.resolve();
        };
        MockClient.prototype.createResponse = function (command, info) {
            var response;
            if (typeof info === 'number') {
                response = impl.Response.create(info);
            }
            else if (typeof info === 'string') {
                response = new impl.Response(byteConverter.hexStringToBuffer(info));
            }
            else if (typeof info === 'object') {
                if (info instanceof impl.Response) {
                    response = info;
                }
                else {
                    response = impl.Response.create(info.codeRet);
                    response.setBody(info.body);
                }
            }
            else if (typeof info === 'function') {
                if (command instanceof impl.ApiRequest) {
                    response = info(command);
                }
                else {
                    return function (command) {
                        return info(command);
                    };
                }
            }
            else {
                throw new Error("Invalid payload type from key " + command.toString());
            }
            return response;
        };
        MockClient.prototype.computeResponse = function (cmd) {
            var response = this.router.findRoute(cmd);
            if (response) {
                return response;
            }
            else {
                debug.debug(TAG, "MockClient", "command " + cmd + " has not been mapped. Returning 404 not found");
                return impl.Response.ERROR(api.ResultCode.IOTIZE_404_NOT_FOUND);
            }
        };
        MockClient.DEFAULT_OPTIONS = {
            connect: {
                delay: 100
            },
            disconnect: {
                delay: 100
            },
            command: {
                delay: 100
            },
            encryption: true
        };
        return MockClient;
    }());
    exports.MockClient = MockClient;

    });

    var mockClient$1 = unwrapExports(mockClient);
    var mockClient_1 = mockClient.MockClient;

    var mockDevice = createCommonjsModule(function (module, exports) {
    "use strict";
    var __awaiter = (commonjsGlobal && commonjsGlobal.__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 = (commonjsGlobal && commonjsGlobal.__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 };
        }
    };
    Object.defineProperty(exports, "__esModule", { value: true });


    function getMockDeviceFromSnapshot(snapshotData) {
        return __awaiter(this, void 0, void 0, function () {
            var protocol;
            return __generator(this, function (_a) {
                protocol = mockProtocol.MockProtocol.createFromRoutes(snapshotData);
                return [2 /*return*/, deviceClient.Tap.fromProtocol(protocol)];
            });
        });
    }
    exports.getMockDeviceFromSnapshot = getMockDeviceFromSnapshot;

    });

    var mockDevice$1 = unwrapExports(mockDevice);
    var mockDevice_1 = mockDevice.getMockDeviceFromSnapshot;

    var public_api = createCommonjsModule(function (module, exports) {
    "use strict";
    function __export(m) {
        for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
    }
    Object.defineProperty(exports, "__esModule", { value: true });
    __export(mockProtocol);
    __export(util);
    __export(mockClient);
    __export(mockDevice);

    });

    var public_api$1 = unwrapExports(public_api);

    var iotizeDeviceClient_jsTesting = createCommonjsModule(function (module, exports) {
    "use strict";
    /**
     * Generated bundle index. Do not edit.
     */
    function __export(m) {
        for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
    }
    Object.defineProperty(exports, "__esModule", { value: true });
    __export(public_api);

    });

    var iotizeDeviceClient_jsTesting$1 = unwrapExports(iotizeDeviceClient_jsTesting);

    return iotizeDeviceClient_jsTesting$1;

})));
//# sourceMappingURL=iotize-device-client.js-testing.umd.js.map
