nodejs-insta-private-api-mqt 1.3.83 → 1.3.84

package/dist-ts/dist/fbns/fbns.client.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FbnsClient = void 0;
+const constants_1 = require("../constants");
+const fbns_device_auth_1 = require("./fbns.device-auth");
+const shared_1 = require("../shared");
+const mqttot_1 = require("../mqttot");
+const chance_1 = require("chance");
+const mqtts_1 = require("../mqtt-shim");
+const errors_1 = require("../errors");
+const eventemitter3_1 = require("eventemitter3");
+const fbns_utilities_1 = require("./fbns.utilities");
+/**
+ * FbnsClient
+ *
+ * Lightweight wrapper around MQTToTClient to handle FBNS-specific connection
+ * payloads, registration, message handling and safe disconnect behavior.
+ *
+ * NOTE: This file contains a small but important robustness change:
+ * when receiving an empty CONNACK payload we no longer force a disconnect.
+ * Instagram sometimes returns a successful CONNACK with an empty payload;
+ * treating that as a fatal error causes unnecessary disconnect loops.
+ */
+class FbnsClient extends eventemitter3_1.EventEmitter {
+    get auth() {
+        return this._auth;
+    }
+    set auth(value) {
+        this._auth = value;
+    }
+    constructor(ig) {
+        super();
+        this.ig = ig;
+        this.fbnsDebug = (0, shared_1.debugChannel)('fbns');
+        this.safeDisconnect = false;
+        this._auth = new fbns_device_auth_1.FbnsDeviceAuth(this.ig);
+    }
+    buildConnection() {
+        this.fbnsDebug('Constructing connection');
+        this.conn = new mqttot_1.MQTToTConnection({
+            clientIdentifier: this._auth.clientId,
+            clientInfo: {
+                userId: BigInt(this._auth.userId),
+                userAgent: (0, shared_1.createFbnsUserAgent)(this.ig),
+                clientCapabilities: 183,
+                endpointCapabilities: 128,
+                publishFormat: 1,
+                noAutomaticForeground: true,
+                makeUserAvailableInForeground: false,
+                deviceId: this._auth.deviceId,
+                isInitiallyForeground: false,
+                networkType: 1,
+                networkSubtype: 0,
+                clientMqttSessionId: BigInt(Date.now()) & BigInt(0xffffffff),
+                subscribeTopics: [76, 80, 231],
+                clientType: 'device_auth',
+                appId: BigInt(567310203415052),
+                deviceSecret: this._auth.deviceSecret,
+                anotherUnknown: BigInt(-1),
+                clientStack: 3,
+            },
+            password: this._auth.password,
+        });
+    }
+    /**
+     * Connect to FBNS (Firebase/FBNS equivalent over Instagram MQTT)
+     *
+     * Options:
+     *  - enableTrace
+     *  - autoReconnect
+     *  - socksOptions
+     *  - additionalTlsOptions
+     *
+     * Important robustness changes:
+     *  - Do not force disconnect on empty CONNACK payload; log and continue.
+     *  - Use clean:false to prefer session resume on reconnect (less aggressive).
+     */
+    async connect({ enableTrace, autoReconnect, socksOptions, additionalTlsOptions, } = {}) {
+        this.fbnsDebug('Connecting to FBNS...');
+        // Ensure auth info is up-to-date
+        this.auth.update();
+        this.client = new mqttot_1.MQTToTClient({
+            url: constants_1.FBNS.HOST_NAME_V6,
+            payloadProvider: () => {
+                this.buildConnection();
+                if (!this.conn) {
+                    throw new errors_1.InvalidStateError("No connection created - can't build provider");
+                }
+                return (0, shared_1.compressDeflate)(this.conn.toThrift());
+            },
+            enableTrace,
+            autoReconnect: autoReconnect !== null && autoReconnect !== void 0 ? autoReconnect : true,
+            requirePayload: false,
+            socksOptions,
+            additionalOptions: additionalTlsOptions,
+        });
+        // Re-emit warnings/errors to outer listeners
+        this.client.on('warning', w => this.emit('warning', w));
+        this.client.on('error', e => this.emit('error', e));
+        // If disconnect happens and safeDisconnect is false, emit error to upper layer
+        this.client.on('disconnect', reason => this.safeDisconnect
+            ? this.emit('disconnect', reason && JSON.stringify(reason))
+            : this.emit('error', new errors_1.ClientDisconnectedError(`MQTToTClient got disconnected. Reason: ${reason && JSON.stringify(reason)}`)));
+        // Listen for FBNS messages and transform them accordingly
+        this.client.listen(constants_1.FbnsTopics.FBNS_MESSAGE.id, msg => this.handleMessage(msg));
+        this.client.listen({
+            topic: constants_1.FbnsTopics.FBNS_EXP_LOGGING.id,
+            transformer: async (msg) => JSON.parse((await (0, shared_1.tryUnzipAsync)(msg.payload)).toString()),
+        }, msg => this.emit('logging', msg));
+        this.client.listen(constants_1.FbnsTopics.PP.id, msg => this.emit('pp', msg.payload.toString()));
+        // Handle connect event from the underlying mqtt client
+        this.client.on('connect', async (res) => {
+            var _a;
+            if (!this.client) {
+                throw new mqtts_1.IllegalStateError('No client registered but an event was received');
+            }
+            this.fbnsDebug('Connected to MQTT');
+            // IMPORTANT: Instagram sometimes returns a valid CONNACK with an empty payload.
+            // Historically this library treated that as an error and disconnected.
+            // That behavior causes unnecessary reconnect loops. Instead, log and continue.
+            if (!((_a = res.payload) === null || _a === void 0 ? void 0 : _a.length)) {
+                this.fbnsDebug(`Received empty connect packet. Reason: ${res.errorName} (continuing without disconnect)`);
+                // Emit a warning but do not disconnect.
+                this.emit('warning', new errors_1.EmptyPacketError('Received empty connect packet (continuing).'));
+                // NOTE: we do not return here because some flows expect the registration step below.
+                // If you prefer to skip registration on empty payload, uncomment the next line:
+                // return;
+            }
+            else {
+                // If payload present, read auth as before
+                try {
+                    const payload = res.payload.toString('utf8');
+                    this.fbnsDebug(`Received auth: ${payload}`);
+                    this._auth.read(payload);
+                    this.emit('auth', this.auth);
+                }
+                catch (e) {
+                    this.fbnsDebug(`Failed to parse connect payload: ${(e === null || e === void 0 ? void 0 : e.message) || e}`);
+                    this.emit('error', e);
+                    // do not force disconnect here - let reconnect logic handle transient issues
+                }
+            }
+            // Continue with registration attempt if possible.
+            try {
+                await this.client.mqttotPublish({
+                    topic: constants_1.FbnsTopics.FBNS_REG_REQ.id,
+                    payload: Buffer.from(JSON.stringify({
+                        pkg_name: constants_1.INSTAGRAM_PACKAGE_NAME,
+                        appid: this.ig.state.fbAnalyticsApplicationId,
+                    }), 'utf8'),
+                    qosLevel: 1,
+                });
+            }
+            catch (e) {
+                // Log registration publish error but don't necessarily abort connection entirely here
+                this.fbnsDebug(`FBNS_REG_REQ publish failed: ${(e === null || e === void 0 ? void 0 : e.message) || e}`);
+                this.emit('warning', e);
+            }
+        });
+        // Set up the register response listener BEFORE connecting
+        // because the response can arrive before connect() returns
+        const regRespPromise = (0, shared_1.listenOnce)(this.client, constants_1.FbnsTopics.FBNS_REG_RESP.id);
+        // Establish connection with conservative options (prefer session resume)
+        await this.client
+            .connect({
+            keepAlive: 60,
+            protocolLevel: 3,
+            // Use clean: false to allow session resume where the broker supports it.
+            // If you have issues with stale state, consider setting clean: true.
+            clean: false,
+            connectDelay: 60 * 1000,
+        })
+            .catch(e => {
+            this.fbnsDebug(`Connection failed: ${e}`);
+            throw e;
+        });
+        // Subscribe to FBNS message topic
+        await this.client.subscribe({ topic: constants_1.FbnsTopics.FBNS_MESSAGE.id });
+        // Wait for the register response (listener was set up before connect)
+        const msg = await regRespPromise;
+        const data = await (0, shared_1.tryUnzipAsync)(msg.payload);
+        const payload = data.toString('utf8');
+        this.fbnsDebug(`Received register response: ${payload}`);
+        const { token, error } = JSON.parse(payload);
+        if (error) {
+            this.emit('error', error);
+            throw error;
+        }
+        try {
+            await this.sendPushRegister(token);
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                this.emit('error', e);
+            }
+            throw e;
+        }
+    }
+    disconnect() {
+        this.safeDisconnect = true;
+        if (!this.client) {
+            return Promise.resolve();
+        }
+        return this.client.disconnect();
+    }
+    async handleMessage(msg) {
+        const payload = JSON.parse((await (0, shared_1.tryUnzipAsync)(msg.payload)).toString('utf8'));
+        if ((0, shared_1.notUndefined)(payload.fbpushnotif)) {
+            const notification = (0, fbns_utilities_1.createNotificationFromJson)(payload.fbpushnotif);
+            this.emit('push', notification);
+            if (notification.collapseKey)
+                this.emit(notification.collapseKey, notification);
+        }
+        else {
+            this.fbnsDebug(`Received a message without 'fbpushnotif': ${JSON.stringify(payload)}`);
+            this.emit('message', payload);
+        }
+    }
+    async sendPushRegister(token) {
+        const { body } = await this.ig.request.send({
+            url: `/api/v1/push/register/`,
+            method: 'POST',
+            form: {
+                device_type: 'android_mqtt',
+                is_main_push_channel: true,
+                device_sub_type: 2,
+                device_token: token,
+                guid: this.ig.state.uuid,
+                uuid: this.ig.state.uuid,
+                users: this.ig.state.cookieUserId,
+                family_device_id: new chance_1.Chance().guid({ version: 4 }),
+            },
+        });
+        return body;
+    }
+}
+exports.FbnsClient = FbnsClient;

package/dist-ts/dist/fbns/fbns.device-auth.js

@@ -0,0 +1,59 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+        r = Reflect.decorate(decorators, target, key, desc);
+    else
+        for (var i = decorators.length - 1; i >= 0; i--)
+            if (d = decorators[i])
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FbnsDeviceAuth = void 0;
+const decorators_1 = require("instagram-private-api/dist/decorators");
+const shared_1 = require("../shared");
+class FbnsDeviceAuth {
+    constructor(ig) {
+        var _a;
+        this.authLog = (0, shared_1.debugChannel)('fbns', 'device-auth');
+        this.ig = ig;
+        this.clientId = ((_a = this.ig.state.phoneId) === null || _a === void 0 ? void 0 : _a.substr(0, 20)) || '';
+        this.deviceId = '';
+        this.userId = 0;
+        this.deviceSecret = '';
+        this.password = '';
+    }
+    update() {
+        var _a;
+        if (this.clientId === '') {
+            this.clientId = ((_a = this.ig.state.phoneId) === null || _a === void 0 ? void 0 : _a.substr(0, 20)) || '';
+        }
+    }
+    read(jsonStr) {
+        this.authLog(`Reading auth json ${jsonStr !== null && jsonStr !== void 0 ? jsonStr : 'empty'}`);
+        if (!jsonStr)
+            return;
+        this.json = jsonStr;
+        const { ck, cs, di, ds, sr, rc } = JSON.parse(jsonStr);
+        this.userId = ck || this.userId;
+        this.password = cs || this.password;
+        if (di) {
+            this.deviceId = di;
+            this.clientId = this.deviceId.substr(0, 20);
+        }
+        else {
+            this.deviceId = '';
+        }
+        this.deviceSecret = ds || this.deviceSecret;
+        this.sr = sr || this.sr;
+        this.rc = rc || this.rc;
+    }
+    toString() {
+        return this.json || '';
+    }
+}
+exports.FbnsDeviceAuth = FbnsDeviceAuth;
+__decorate([
+    (0, decorators_1.Enumerable)(false)
+], FbnsDeviceAuth.prototype, "ig", void 0);

package/dist-ts/dist/fbns/fbns.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-ts/dist/fbns/fbns.utilities.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNotificationFromJson = void 0;
+const shared_1 = require("../shared");
+const querystring = require("querystring");
+const URL = require("url");
+function createNotificationFromJson(json) {
+    const data = JSON.parse(json);
+    const notification = Object.defineProperty({}, 'description', {
+        enumerable: false,
+        value: data,
+    });
+    if ((0, shared_1.notUndefined)(data.t)) {
+        notification.title = data.t;
+    }
+    if ((0, shared_1.notUndefined)(data.m)) {
+        notification.message = data.m;
+    }
+    if ((0, shared_1.notUndefined)(data.tt)) {
+        notification.tickerText = data.tt;
+    }
+    if ((0, shared_1.notUndefined)(data.ig)) {
+        notification.igAction = data.ig;
+        const url = URL.parse(data.ig);
+        if (url.pathname) {
+            notification.actionPath = url.pathname;
+        }
+        if (url.query) {
+            notification.actionParams = querystring.decode(url.query);
+        }
+    }
+    if ((0, shared_1.notUndefined)(data.collapse_key)) {
+        notification.collapseKey = data.collapse_key;
+    }
+    if ((0, shared_1.notUndefined)(data.i)) {
+        notification.optionalImage = data.i;
+    }
+    if ((0, shared_1.notUndefined)(data.a)) {
+        notification.optionalAvatarUrl = data.a;
+    }
+    if ((0, shared_1.notUndefined)(data.sound)) {
+        notification.sound = data.sound;
+    }
+    if ((0, shared_1.notUndefined)(data.pi)) {
+        notification.pushId = data.pi;
+    }
+    if ((0, shared_1.notUndefined)(data.c)) {
+        notification.pushCategory = data.c;
+    }
+    if ((0, shared_1.notUndefined)(data.u)) {
+        notification.intendedRecipientUserId = data.u;
+    }
+    if ((0, shared_1.notUndefined)(data.s) && data.s !== 'None') {
+        notification.sourceUserId = data.s;
+    }
+    if ((0, shared_1.notUndefined)(data.igo)) {
+        notification.igActionOverride = data.igo;
+    }
+    if ((0, shared_1.notUndefined)(data.bc)) {
+        const badgeCount = {};
+        const parsed = JSON.parse(data.bc);
+        if ((0, shared_1.notUndefined)(parsed.di)) {
+            badgeCount.direct = parsed.di;
+        }
+        if ((0, shared_1.notUndefined)(parsed.ds)) {
+            badgeCount.ds = parsed.ds;
+        }
+        if ((0, shared_1.notUndefined)(parsed.ac)) {
+            badgeCount.activities = parsed.ac;
+        }
+        notification.badgeCount = badgeCount;
+    }
+    if ((0, shared_1.notUndefined)(data.ia)) {
+        notification.inAppActors = data.ia;
+    }
+    return notification;
+}
+exports.createNotificationFromJson = createNotificationFromJson;

package/dist-ts/dist/fbns/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function (o, m, k, k2) {
+    if (k2 === undefined)
+        k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function () { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function (o, m, k, k2) {
+    if (k2 === undefined)
+        k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function (m, exports) {
+    for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p))
+            __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./fbns.client"), exports);
+__exportStar(require("./fbns.device-auth"), exports);
+__exportStar(require("./fbns.types"), exports);
+__exportStar(require("./fbns.utilities"), exports);

package/dist-ts/dist/index.js

@@ -0,0 +1,137 @@
+const IgApiClient = require('./core/client');
+const NavChainManager = require('./core/nav-chain');
+const { IgApiClientError } = require('./errors');
+const { APP_VERSION } = require('./constants/constants');
+const { RealtimeClient, IrisHandshake, SkywalkerProtocol, PresenceManager, DMSender, ErrorHandler, GapHandler, EnhancedDirectCommands, PresenceTypingMixin } = require('./realtime');
+const constants = require('./constants/constants');
+const sendmedia = require('./sendmedia');
+const { sendRavenPhoto, sendRavenPhotoOnce, sendRavenPhotoReplayable, sendRavenVideo, sendRavenVideoOnce, sendRavenVideoReplayable } = sendmedia;
+const { useMultiFileAuthState, MultiFileAuthState, extractStateData, applyStateData } = require('./useMultiFileAuthState');
+const { downloadContentFromMessage, downloadMediaBuffer, extractMediaUrls, hasMedia, getMediaType, isViewOnceMedia, MEDIA_TYPES } = require('./downloadMedia');
+const { GraphQLSubscriptions, QueryIDs } = require('./realtime/subscriptions/graphql.subscription');
+const { SkywalkerSubscriptions } = require('./realtime/subscriptions/skywalker.subscription');
+let FbnsClient;
+try {
+    FbnsClient = require('./fbns/fbns.client').FbnsClient;
+}
+catch (e) {
+    FbnsClient = class FbnsClient {
+        constructor() { throw new Error('FbnsClient requires mqtt-shim dependency which is not installed. Install it with: npm install mqtt-shim'); }
+    };
+}
+const { MQTToTClient, mqttotConnectFlow, INSTAGRAM_VERSION } = require('./mqttot/mqttot.client');
+const { MQTToTConnection } = require('./mqttot/mqttot.connection');
+const { IgApiClientExt, withFbns, withRealtime, withFbnsAndRealtime } = require('./extend');
+const AccountRepository = require('./repositories/account.repository');
+const UserRepository = require('./repositories/user.repository');
+const MediaRepository = require('./repositories/media.repository');
+const FeedRepository = require('./repositories/feed.repository');
+const UploadRepository = require('./repositories/upload.repository');
+const StoryRepository = require('./repositories/story.repository');
+const DirectRepository = require('./repositories/direct.repository');
+const DirectThreadRepository = require('./repositories/direct-thread.repository');
+const FriendshipRepository = require('./repositories/friendship.repository');
+const LocationRepository = require('./repositories/location.repository');
+const HashtagRepository = require('./repositories/hashtag.repository');
+const NewsRepository = require('./repositories/news.repository');
+const CollectionRepository = require('./repositories/collection.repository');
+const CloseFriendsRepository = require('./repositories/close-friends.repository');
+const HighlightsRepository = require('./repositories/highlights.repository');
+const ClipRepository = require('./repositories/clip.repository');
+const TimelineRepository = require('./repositories/timeline.repository');
+const InsightsRepository = require('./repositories/insights.repository');
+const NoteRepository = require('./repositories/note.repository');
+const NotificationRepository = require('./repositories/notification.repository');
+const SignupRepository = require('./repositories/signup.repository');
+const TOTPRepository = require('./repositories/totp.repository');
+const BloksRepository = require('./repositories/bloks.repository');
+const ChallengeRepository = require('./repositories/challenge.repository');
+const ShareRepository = require('./repositories/share.repository');
+const TrackRepository = require('./repositories/track.repository');
+const ExploreRepository = require('./repositories/explore.repository');
+const FBSearchRepository = require('./repositories/fbsearch.repository');
+const FundraiserRepository = require('./repositories/fundraiser.repository');
+const MultipleAccountsRepository = require('./repositories/multiple-accounts.repository');
+const CaptchaRepository = require('./repositories/captcha.repository');
+const { SessionHealthMonitor } = require('./realtime/features/session-health-monitor');
+const { PersistentLogger } = require('./realtime/features/persistent-logger');
+module.exports = {
+    IgApiClient,
+    NavChainManager,
+    IgApiClientError,
+    RealtimeClient,
+    IrisHandshake,
+    SkywalkerProtocol,
+    PresenceManager,
+    DMSender,
+    ErrorHandler,
+    GapHandler,
+    EnhancedDirectCommands,
+    PresenceTypingMixin,
+    Topics: constants.Topics,
+    REALTIME: constants.REALTIME,
+    sendmedia,
+    sendRavenPhoto,
+    sendRavenPhotoOnce,
+    sendRavenPhotoReplayable,
+    sendRavenVideo,
+    sendRavenVideoOnce,
+    sendRavenVideoReplayable,
+    useMultiFileAuthState,
+    MultiFileAuthState,
+    extractStateData,
+    applyStateData,
+    downloadContentFromMessage,
+    downloadMediaBuffer,
+    extractMediaUrls,
+    hasMedia,
+    getMediaType,
+    isViewOnceMedia,
+    MEDIA_TYPES,
+    GraphQLSubscriptions,
+    QueryIDs,
+    SkywalkerSubscriptions,
+    FbnsClient,
+    MQTToTClient,
+    mqttotConnectFlow,
+    MQTToTConnection,
+    INSTAGRAM_VERSION,
+    IgApiClientExt,
+    withFbns,
+    withRealtime,
+    withFbnsAndRealtime,
+    APP_VERSION,
+    SessionHealthMonitor,
+    PersistentLogger,
+    AccountRepository,
+    UserRepository,
+    MediaRepository,
+    FeedRepository,
+    UploadRepository,
+    StoryRepository,
+    DirectRepository,
+    DirectThreadRepository,
+    FriendshipRepository,
+    LocationRepository,
+    HashtagRepository,
+    NewsRepository,
+    CollectionRepository,
+    CloseFriendsRepository,
+    HighlightsRepository,
+    ClipRepository,
+    TimelineRepository,
+    InsightsRepository,
+    NoteRepository,
+    NotificationRepository,
+    SignupRepository,
+    TOTPRepository,
+    BloksRepository,
+    ChallengeRepository,
+    ShareRepository,
+    TrackRepository,
+    ExploreRepository,
+    FBSearchRepository,
+    FundraiserRepository,
+    MultipleAccountsRepository,
+    CaptchaRepository,
+};

package/dist-ts/dist/mqtt-shim.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mqtts = require("mqtts");
+exports.PacketType = mqtts.PacketType;
+exports.ConnectResponsePacket = mqtts.ConnectResponsePacket;
+exports.IllegalStateError = mqtts.IllegalStateError;
+exports.MqttClient = mqtts.MqttClient;
+exports.TlsTransport = mqtts.TlsTransport;
+exports.SocksTlsTransport = mqtts.SocksTlsTransport;
+exports.PacketStream = mqtts.PacketStream;
+exports.DefaultPacketReadMap = mqtts.DefaultPacketReadMap;
+exports.DefaultPacketWriteMap = mqtts.DefaultPacketWriteMap;
+exports.isConnAck = mqtts.isConnAck;
+exports.ConnectReturnCode = mqtts.ConnectReturnCode;

package/dist-ts/dist/mqttot/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function (o, m, k, k2) {
+    if (k2 === undefined)
+        k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function () { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function (o, m, k, k2) {
+    if (k2 === undefined)
+        k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function (m, exports) {
+    for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p))
+            __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./mqttot.client"), exports);
+__exportStar(require("./mqttot.connect.request.packet"), exports);
+__exportStar(require("./mqttot.connect.response.packet"), exports);
+__exportStar(require("./mqttot.connection"), exports);