File Explorer

1"use strict";2/*3 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.4 * SPDX-License-Identifier: Apache-2.0.5 */6var __extends = (this && this.__extends) || (function () {7    var extendStatics = function (d, b) {8        extendStatics = Object.setPrototypeOf ||9            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||10            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };11        return extendStatics(d, b);12    };13    return function (d, b) {14        if (typeof b !== "function" && b !== null)15            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");16        extendStatics(d, b);17        function __() { this.constructor = d; }18        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());19    };20})();21var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {22    if (k2 === undefined) k2 = k;23    var desc = Object.getOwnPropertyDescriptor(m, k);24    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {25      desc = { enumerable: true, get: function() { return m[k]; } };26    }27    Object.defineProperty(o, k2, desc);28}) : (function(o, m, k, k2) {29    if (k2 === undefined) k2 = k;30    o[k2] = m[k];31}));32var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {33    Object.defineProperty(o, "default", { enumerable: true, value: v });34}) : function(o, v) {35    o["default"] = v;36});37var __importStar = (this && this.__importStar) || function (mod) {38    if (mod && mod.__esModule) return mod;39    var result = {};40    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);41    __setModuleDefault(result, mod);42    return result;43};44var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {45    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }46    return new (P || (P = Promise))(function (resolve, reject) {47        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }48        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }49        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }50        step((generator = generator.apply(thisArg, _arguments || [])).next());51    });52};53var __generator = (this && this.__generator) || function (thisArg, body) {54    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;55    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;56    function verb(n) { return function (v) { return step([n, v]); }; }57    function step(op) {58        if (f) throw new TypeError("Generator is already executing.");59        while (g && (g = 0, op[0] && (_ = 0)), _) try {60            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;61            if (y = 0, t) op = [op[0] & 2, t.value];62            switch (op[0]) {63                case 0: case 1: t = op; break;64                case 4: _.label++; return { value: op[1], done: false };65                case 5: _.label++; y = op[1]; op = [0]; continue;66                case 7: op = _.ops.pop(); _.trys.pop(); continue;67                default:68                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }69                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }70                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }71                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }72                    if (t[2]) _.ops.pop();73                    _.trys.pop(); continue;74            }75            op = body.call(thisArg, _);76        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }77        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };78    }79};80var __values = (this && this.__values) || function(o) {81    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;82    if (m) return m.call(o);83    if (o && typeof o.length === "number") return {84        next: function () {85            if (o && i >= o.length) o = void 0;86            return { value: o && o[i++], done: !o };87        }88    };89    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");90};91Object.defineProperty(exports, "__esModule", { value: true });92exports.MqttClientConnection = exports.MqttClient = exports.MqttWill = exports.QoS = void 0;93/**94 *95 * A module containing support for mqtt connection establishment and operations.96 *97 * @packageDocumentation98 * @module mqtt99 * @mergeTarget100 */101var internal_mqtt_client = __importStar(require("./mqtt_internal/client"));102var mqtt5 = __importStar(require("../common/mqtt5"));103var ws = __importStar(require("./ws"));104var auth = __importStar(require("./auth"));105var promise = __importStar(require("../common/promise"));106var model = __importStar(require("./mqtt_internal/model"));107var mqtt_shared = __importStar(require("../common/mqtt_shared"));108var mqtt_shared_browser = __importStar(require("./mqtt_shared_browser"));109var aws_iot_metrics = __importStar(require("./aws_iot_metrics"));110var trie_1 = require("./trie");111var event_1 = require("../common/event");112var error_1 = require("./error");113var mqtt_1 = require("../common/mqtt");114var events_1 = require("events");115var mqtt_2 = require("../common/mqtt");116Object.defineProperty(exports, "QoS", { enumerable: true, get: function () { return mqtt_2.QoS; } });117Object.defineProperty(exports, "MqttWill", { enumerable: true, get: function () { return mqtt_2.MqttWill; } });118/**119 * MQTT client120 *121 * @category MQTT122 */123var MqttClient = /** @class */ (function () {124    function MqttClient(bootstrap) {125    }126    /**127     * Creates a new {@link MqttClientConnection}128     * @param config Configuration for the connection129     * @returns A new connection130     */131    MqttClient.prototype.new_connection = function (config) {132        return new MqttClientConnection(this, config);133    };134    return MqttClient;135}());136exports.MqttClient = MqttClient;137/**138 * @internal139 */140var MqttBrowserClientState;141(function (MqttBrowserClientState) {142    MqttBrowserClientState[MqttBrowserClientState["Connected"] = 0] = "Connected";143    MqttBrowserClientState[MqttBrowserClientState["Stopped"] = 1] = "Stopped";144})(MqttBrowserClientState || (MqttBrowserClientState = {}));145;146/** @internal */147var TopicTrie = /** @class */ (function (_super) {148    __extends(TopicTrie, _super);149    function TopicTrie() {150        return _super.call(this, '/') || this;151    }152    TopicTrie.prototype.find_node = function (key, op) {153        var e_1, _a;154        var parts = this.split_key(key);155        var current = this.root;156        var parent = undefined;157        try {158            for (var parts_1 = __values(parts), parts_1_1 = parts_1.next(); !parts_1_1.done; parts_1_1 = parts_1.next()) {159                var part = parts_1_1.value;160                var child = current.children.get(part);161                if (!child) {162                    child = current.children.get('#');163                    if (child) {164                        return child;165                    }166                    child = current.children.get('+');167                }168                if (!child) {169                    if (op == trie_1.TrieOp.Insert) {170                        current.children.set(part, child = new trie_1.Node(part));171                    }172                    else {173                        return undefined;174                    }175                }176                parent = current;177                current = child;178            }179        }180        catch (e_1_1) { e_1 = { error: e_1_1 }; }181        finally {182            try {183                if (parts_1_1 && !parts_1_1.done && (_a = parts_1.return)) _a.call(parts_1);184            }185            finally { if (e_1) throw e_1.error; }186        }187        if (parent && op == trie_1.TrieOp.Delete) {188            parent.children.delete(current.key);189        }190        return current;191    };192    return TopicTrie;193}(trie_1.Trie));194/**195 * MQTT client connection196 *197 * @category MQTT198 */199var MqttClientConnection = /** @class */ (function (_super) {200    __extends(MqttClientConnection, _super);201    /**202     * @param client The client that owns this connection203     * @param config The configuration for this connection204     */205    function MqttClientConnection(client, config) {206        var _this = _super.call(this) || this;207        _this.client = client;208        _this.config = config;209        _this.subscriptions = new TopicTrie();210        _this.connection_count = 0;211        _this.connectPromise = undefined;212        _this.isSessionPresent = false;213        _this.currentState = MqttBrowserClientState.Stopped;214        _this.desiredState = MqttBrowserClientState.Stopped;215        _this.on_connection_success = function (event) {216            _this.on_online(event.connack.sessionPresent);217        };218        _this.on_online = function (session_present) {219            _this.isSessionPresent = session_present;220            _this.currentState = MqttBrowserClientState.Connected;221            if (++_this.connection_count == 1) {222                _this.emit('connect', session_present);223            }224            else {225                /** Reset reconnect times after reconnect succeed. */226                _this.emit('resume', 0, session_present);227            }228            // Call connection success every time we connect, whether it is a first connect or a reconnect229            var successCallbackData = { session_present: session_present };230            _this.emit('connection_success', successCallbackData);231        };232        _this.on_connection_failure = function (event) {233            var failureCallbackData = { error: event.error };234            _this.emit('connection_failure', failureCallbackData);235        };236        _this.on_disconnection = function (event) {237            _this.currentState = MqttBrowserClientState.Stopped;238            _this.emit('interrupt', -1);239        };240        _this.on_stopped = function (event) {241            _this.emit("closed");242            _this.emit("disconnect");243        };244        _this.on_publish_received = function (event) {245            var _a;246            var packet = event.publish;247            var topic = packet.topicName;248            var payload = packet.payload;249            var retain = (_a = packet.retain) !== null && _a !== void 0 ? _a : false;250            var array_buffer = payload ? model.payloadToArrayBuffer(payload) : new ArrayBuffer(0);251            var callback = _this.subscriptions.find(topic);252            if (callback) {253                callback(topic, array_buffer, packet.duplicate, packet.qos, retain);254            }255            _this.emit('message', topic, array_buffer, packet.duplicate, packet.qos, retain);256        };257        if (!config) {258            throw new error_1.CrtError("MqttClientConnection constructor: config not defined");259        }260        var internalConnectOptions = {261            keepAliveIntervalSeconds: _this.config.keep_alive ? _this.config.keep_alive : 1200,262            resumeSessionPolicy: _this.config.clean_session ? internal_mqtt_client.ResumeSessionPolicyType.Never : internal_mqtt_client.ResumeSessionPolicyType.Always,263        };264        if (_this.config.client_id) {265            internalConnectOptions.clientId = _this.config.client_id;266        }267        if (_this.config.disable_metrics) {268            if (_this.config.username) {269                internalConnectOptions.username = _this.config.username;270            }271        }272        else {273            internalConnectOptions.username = mqtt_shared_browser.buildFinalUsernameFromMetrics(aws_iot_metrics.create_metrics_mqtt3(_this.config), _this.config.username);274        }275        if (_this.config.password) {276            internalConnectOptions.password = mqtt_shared_browser.normalize_payload_to_buffer(_this.config.password);277        }278        if (_this.config.will) {279            internalConnectOptions.will = {280                topicName: _this.config.will.topic,281                payload: mqtt_shared_browser.normalize_payload_to_buffer(_this.config.will.payload),282                qos: _this.config.will.qos,283                retain: _this.config.will.retain,284            };285        }286        // If the credentials are set but no the credentials_provider287        if (_this.config.credentials_provider == undefined &&288            _this.config.credentials != undefined) {289            var provider = new auth.StaticCredentialProvider({ aws_region: _this.config.credentials.aws_region,290                aws_access_id: _this.config.credentials.aws_access_id,291                aws_secret_key: _this.config.credentials.aws_secret_key,292                aws_sts_token: _this.config.credentials.aws_sts_token });293            _this.config.credentials_provider = provider;294        }295        var thisConfig = _this.config;296        var connectionFactory = function () {297            var _this = this;298            return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {299                var conn;300                return __generator(this, function (_a) {301                    switch (_a.label) {302                        case 0:303                            if (!thisConfig.credentials_provider) return [3 /*break*/, 2];304                            return [4 /*yield*/, thisConfig.credentials_provider.refreshCredentials()];305                        case 1:306                            _a.sent();307                            _a.label = 2;308                        case 2:309                            conn = ws.create_websocket_stream(thisConfig);310                            conn.on('error', function (err) {311                                reject(err);312                            });313                            conn.on('connect', function () {314                                resolve(conn);315                            });316                            return [2 /*return*/];317                    }318                });319            }); });320        };321        var internalConfig = {322            protocolVersion: mqtt_shared.ProtocolMode.Mqtt311,323            offlineQueuePolicy: internal_mqtt_client.OfflineQueuePolicy.PreserveQos1PlusPublishes,324            connectOptions: internalConnectOptions,325            pingTimeoutMillis: _this.config.ping_timeout ? _this.config.ping_timeout : 30 * 1000,326            connectionFactory: connectionFactory,327            // yes this is wrong, but this is how the old client was configured328            // ideally, we'd use the socket options timeout value here329            connectTimeoutMillis: _this.config.ping_timeout ? _this.config.ping_timeout : 30 * 1000,330            retryJitterMode: mqtt5.RetryJitterType.Default,331            // this was how the previous mqtt-js integration behaved332            resubscribeMode: internal_mqtt_client.ResubscribeModeType.EnabledAlways333        };334        if (config.reconnect_min_sec !== undefined) {335            internalConfig.minReconnectDelayMs = config.reconnect_min_sec * 1000;336        }337        if (config.reconnect_max_sec !== undefined) {338            internalConfig.maxReconnectDelayMs = config.reconnect_max_sec * 1000;339        }340        // we never implemented a reset delay in the browser client, so reset immediately after connecting341        internalConfig.resetConnectionFailureCountMillis = 0;342        _this.internalClient = new internal_mqtt_client.Client(internalConfig);343        _this.internalClient.on("connectionSuccess", _this.on_connection_success);344        _this.internalClient.on("connectionFailure", _this.on_connection_failure);345        _this.internalClient.on("disconnection", _this.on_disconnection);346        _this.internalClient.on("publishReceived", _this.on_publish_received);347        _this.internalClient.on("stopped", _this.on_stopped);348        return _this;349    }350    MqttClientConnection.prototype.on = function (event, listener) {351        return _super.prototype.on.call(this, event, listener);352    };353    /**354     * Open the actual connection to the server (async).355     * @returns A Promise which completes whether the connection succeeds or fails.356     *          If connection fails, the Promise will reject with an exception.357     *          If connection succeeds, the Promise will return a boolean that is358     *          true for resuming an existing session, or false if the session is new359     */360    MqttClientConnection.prototype.connect = function () {361        return __awaiter(this, void 0, void 0, function () {362            var client, internalClient, isStarted, listeners_1;363            var _this = this;364            return __generator(this, function (_a) {365                client = this;366                internalClient = this.internalClient;367                isStarted = client.desiredState == MqttBrowserClientState.Connected;368                this.desiredState = MqttBrowserClientState.Connected;369                setTimeout(function () { _this.uncork(); }, 0);370                if (this.currentState == MqttBrowserClientState.Connected && isStarted) {371                    return [2 /*return*/, new Promise(function (resolve, reject) {372                            resolve(client.isSessionPresent);373                        })];374                }375                if (!this.connectPromise) {376                    this.connectPromise = promise.newLiftedPromise();377                    listeners_1 = {};378                    listeners_1.connectionSuccess = function (event) {379                        if (client.connectPromise) {380                            client.connectPromise.resolve(event.connack.sessionPresent);381                            client.connectPromise = undefined;382                        }383                        if (listeners_1.connectionFailure) {384                            internalClient.removeListener("connectionFailure", listeners_1.connectionFailure);385                        }386                    };387                    listeners_1.connectionFailure = function (event) {388                        if (client.connectPromise) {389                            client.connectPromise.reject(event.error);390                            client.connectPromise = undefined;391                        }392                        if (listeners_1.connectionSuccess) {393                            internalClient.removeListener("connectionSuccess", listeners_1.connectionSuccess);394                        }395                    };396                    internalClient.once("connectionSuccess", listeners_1.connectionSuccess);397                    internalClient.once("connectionFailure", listeners_1.connectionFailure);398                }399                if (!isStarted) {400                    internalClient.start();401                }402                return [2 /*return*/, this.connectPromise.promise];403            });404        });405    };406    /**407     * The connection will automatically reconnect. To cease reconnection attempts, call {@link disconnect}.408     * To resume the connection, call {@link connect}.409     * @deprecated410     */411    MqttClientConnection.prototype.reconnect = function () {412        return __awaiter(this, void 0, void 0, function () {413            return __generator(this, function (_a) {414                return [2 /*return*/, this.connect()];415            });416        });417    };418    /**419     * Publish message (async).420     * If the device is offline, the PUBLISH packet will be sent once the connection resumes.421     *422     * @param topic Topic name423     * @param payload Contents of message424     * @param qos Quality of Service for delivering this message425     * @param retain If true, the server will store the message and its QoS so that it can be426     *               delivered to future subscribers whose subscriptions match the topic name427     * @returns Promise which returns a {@link MqttRequest} which will contain the packet id of428     *          the PUBLISH packet.429     *430     * * For QoS 0, completes as soon as the packet is sent.431     * * For QoS 1, completes when PUBACK is received.432     * * For QoS 2, completes when PUBCOMP is received.433     */434    MqttClientConnection.prototype.publish = function (topic, payload, qos, retain) {435        if (retain === void 0) { retain = false; }436        return __awaiter(this, void 0, void 0, function () {437            var payload_data, options, publishResult, id;438            return __generator(this, function (_a) {439                switch (_a.label) {440                    case 0:441                        payload_data = mqtt_shared.normalize_payload(payload);442                        options = {};443                        if (this.config.protocol_operation_timeout) {444                            options.timeoutInMillis = this.config.protocol_operation_timeout;445                        }446                        return [4 /*yield*/, this.internalClient.publish({447                                topicName: topic,448                                qos: qos,449                                payload: payload_data,450                                retain: retain451                            }, options)];452                    case 1:453                        publishResult = _a.sent();454                        id = undefined;455                        if (qos == mqtt_1.QoS.AtLeastOnce) {456                            id = publishResult.packet.packetId;457                        }458                        return [2 /*return*/, { packet_id: id }];459                }460            });461        });462    };463    /**464     * Subscribe to a topic filter (async).465     * The client sends a SUBSCRIBE packet and the server responds with a SUBACK.466     *467     * subscribe() may be called while the device is offline, though the async468     * operation cannot complete successfully until the connection resumes.469     *470     * Once subscribed, `callback` is invoked each time a message matching471     * the `topic` is received. It is possible for such messages to arrive before472     * the SUBACK is received.473     *474     * @param topic Subscribe to this topic filter, which may include wildcards475     * @param qos Maximum requested QoS that server may use when sending messages to the client.476     *            The server may grant a lower QoS in the SUBACK477     * @param on_message Optional callback invoked when message received.478     * @returns Promise which returns a {@link MqttSubscribeRequest} which will contain the479     *          result of the SUBSCRIBE. The Promise resolves when a SUBACK is returned480     *          from the server or is rejected when an exception occurs.481     */482    MqttClientConnection.prototype.subscribe = function (topic, qos, on_message) {483        return __awaiter(this, void 0, void 0, function () {484            var options, suback;485            return __generator(this, function (_a) {486                switch (_a.label) {487                    case 0:488                        if (typeof (topic) !== 'string') {489                            return [2 /*return*/, Promise.reject("topic is not a string")];490                        }491                        if (typeof (qos) !== 'number') {492                            return [2 /*return*/, Promise.reject("qos is not a number")];493                        }494                        this.subscriptions.insert(topic, on_message);495                        options = {};496                        if (this.config.protocol_operation_timeout) {497                            options.timeoutInMillis = this.config.protocol_operation_timeout;498                        }499                        return [4 /*yield*/, this.internalClient.subscribe({500                                subscriptions: [501                                    {502                                        topicFilter: topic,503                                        qos: qos504                                    }505                                ]506                            }, options)];507                    case 1:508                        suback = _a.sent();509                        return [2 /*return*/, {510                                topic: topic,511                                /*512                                 * 128 is not modeled in QoS, either on our side nor mqtt-js's side.513                                 * We have always passed this 128 to the user and it is not reasonable to extend514                                 * our output type with 128 since it's also our input type and we don't want anyone515                                 * to pass 128 to us.516                                 *517                                 * The 5 client solves this by making the output type a completely separate enum.518                                 *519                                 * By doing this cast, we make the type checker ignore this edge case.520                                 */521                                qos: suback.reasonCodes[0]522                            }];523                }524            });525        });526    };527    /**528     * Unsubscribe from a topic filter (async).529     * The client sends an UNSUBSCRIBE packet, and the server responds with an UNSUBACK.530     * @param topic The topic filter to unsubscribe from. May contain wildcards.531     * @returns Promise which returns a {@link MqttRequest} which will contain the packet id532     *          of the UNSUBSCRIBE packet being acknowledged. Promise is resolved when an533     *          UNSUBACK is received from the server or is rejected when an exception occurs.534     */535    MqttClientConnection.prototype.unsubscribe = function (topic) {536        return __awaiter(this, void 0, void 0, function () {537            var options, unsuback;538            return __generator(this, function (_a) {539                switch (_a.label) {540                    case 0:541                        if (typeof (topic) !== 'string') {542                            return [2 /*return*/, Promise.reject("topic is not a string")];543                        }544                        this.subscriptions.remove(topic);545                        options = {};546                        if (this.config.protocol_operation_timeout) {547                            options.timeoutInMillis = this.config.protocol_operation_timeout;548                        }549                        return [4 /*yield*/, this.internalClient.unsubscribe({550                                topicFilters: [551                                    topic552                                ]553                            }, options)];554                    case 1:555                        unsuback = _a.sent();556                        return [2 /*return*/, {557                                packet_id: unsuback.packetId558                            }];559                }560            });561        });562    };563    /**564     * Close the connection (async).565     * @returns Promise which completes when the connection is closed.566     */567    MqttClientConnection.prototype.disconnect = function () {568        return __awaiter(this, void 0, void 0, function () {569            var isStarted, stopped;570            return __generator(this, function (_a) {571                isStarted = this.desiredState == MqttBrowserClientState.Connected;572                this.desiredState = MqttBrowserClientState.Stopped;573                if (!isStarted && this.currentState == MqttBrowserClientState.Stopped) {574                    return [2 /*return*/, Promise.resolve()];575                }576                stopped = (0, events_1.once)(this.internalClient, "stopped");577                if (isStarted) {578                    this.internalClient.stop();579                }580                return [2 /*return*/, stopped];581            });582        });583    };584    /**585     * Queries whether the client is currently connected586     *587     * @returns whether the client is currently connected588     */589    MqttClientConnection.prototype.is_connected = function () {590        return this.currentState == MqttBrowserClientState.Connected;591    };592    /**593     * Emitted when the connection successfully establishes itself for the first time594     *595     * @event596     */597    MqttClientConnection.CONNECT = 'connect';598    /**599     * Emitted when connection has disconnected successfully.600     *601     * @event602     */603    MqttClientConnection.DISCONNECT = 'disconnect';604    /**605     * Emitted when an error occurs.  The error will contain the error606     * code and message.607     *608     * @event609     */610    MqttClientConnection.ERROR = 'error';611    /**612     * Emitted when the connection is dropped unexpectedly. The error will contain the error613     * code and message.  The underlying mqtt implementation will attempt to reconnect.614     *615     * @event616     */617    MqttClientConnection.INTERRUPT = 'interrupt';618    /**619     * Emitted when the connection reconnects (after an interrupt). Only triggers on connections after the initial one.620     *621     * @event622     */623    MqttClientConnection.RESUME = 'resume';624    /**625     * Emitted when any MQTT publish message arrives.626     *627     * @event628     */629    MqttClientConnection.MESSAGE = 'message';630    /**631     * Emitted on every successful connect and reconnect.632     * Will contain a boolean indicating whether the connection resumed a session.633     *634     * @event635     */636    MqttClientConnection.CONNECTION_SUCCESS = 'connection_success';637    /**638     * Emitted on an unsuccessful connect and reconnect.639     * Will contain an error code indicating the reason for the unsuccessful connection.640     *641     * @event642     */643    MqttClientConnection.CONNECTION_FAILURE = 'connection_failure';644    /**645     * Emitted when the MQTT connection was disconnected and shutdown successfully.646     *647     * @event648     */649    MqttClientConnection.CLOSED = 'closed';650    return MqttClientConnection;651}(event_1.BufferedEventEmitter));652exports.MqttClientConnection = MqttClientConnection;653//# sourceMappingURL=mqtt.js.map