abmqtts 0.0.5 → 0.0.6

package/dist/fbns/fbns.client.js

@@ -6,176 +6,222 @@ 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 obmqtt_1 = require("obmqtt");
+const obmqtt_1 = require("abmqtt-dist");
 const errors_1 = require("../errors");
 const eventemitter3_1 = require("eventemitter3");
 const fbns_utilities_1 = require("./fbns.utilities");
 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,
-        });
-    }
-    async connect({ enableTrace, autoReconnect, socksOptions, additionalTlsOptions, } = {}) {
-        this.fbnsDebug('Connecting to FBNS...');
-        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 ?? true,
-            requirePayload: true,
-            socksOptions,
-            additionalOptions: additionalTlsOptions,
-        });
-        this.client.on('warning', w => this.emit('warning', w));
-        this.client.on('error', e => this.emit('error', e));
-        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)}`)));
-        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()));
-        this.client.on('connect', async (res) => {
-            if (!this.client) {
-                throw new obmqtt_1.IllegalStateError('No client registered but an event was received');
-            }
-            this.fbnsDebug('Connected to MQTT');
-            if (!res?.payload?.length) {
-                this.fbnsDebug(`Received empty connect packet. Reason: ${res.errorName}; Try resetting your fbns state!`);
-                this.emit('error', new errors_1.EmptyPacketError('Received empty connect packet. Try resetting your fbns state!'));
-                await this.client.disconnect();
-                return;
-            }
-            const payload = res.payload.toString('utf8');
-            this.fbnsDebug(`Received auth: ${payload}`);
-            this._auth.read(payload);
-            this.emit('auth', this.auth);
-            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,
-            });
-            // this.buildConnection(); ?
-        });
-        await this.client
-            .connect({
-            keepAlive: 60,
-            protocolLevel: 3,
-            clean: true,
-            connectDelay: 60 * 1000,
-        })
-            .catch(e => {
-            this.fbnsDebug(`Connection failed: ${e}`);
-            throw e;
-        });
-        if (!this.client.ready)
-            throw new Error('OB Connection failed');
-        await this.client.subscribe({ topic: constants_1.FbnsTopics.FBNS_MESSAGE.id });
-        const msg = await (0, shared_1.listenOnce)(this.client, constants_1.FbnsTopics.FBNS_REG_RESP.id);
-        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;
+  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,
+    });
+  }
+  async connect({
+    enableTrace,
+    autoReconnect,
+    socksOptions,
+    additionalTlsOptions,
+  } = {}) {
+    this.fbnsDebug("Connecting to FBNS...");
+    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 ?? true,
+      requirePayload: true,
+      socksOptions,
+      additionalOptions: additionalTlsOptions,
+    });
+    this.client.on("warning", (w) => this.emit("warning", w));
+    this.client.on("error", (e) => this.emit("error", e));
+    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)
+              }`
+            )
+          )
+    );
+    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())
+    );
+    this.client.on("connect", async (res) => {
+      if (!this.client) {
+        throw new obmqtt_1.IllegalStateError(
+          "No client registered but an event was received"
+        );
+      }
+      this.fbnsDebug("Connected to MQTT");
+      if (!res?.payload?.length) {
+        this.fbnsDebug(
+          `Received empty connect packet. Reason: ${res.errorName}; Try resetting your fbns state!`
+        );
+        this.emit(
+          "error",
+          new errors_1.EmptyPacketError(
+            "Received empty connect packet. Try resetting your fbns state!"
+          )
+        );
+        await this.client.disconnect();
+        return;
+      }
+      const payload = res.payload.toString("utf8");
+      this.fbnsDebug(`Received auth: ${payload}`);
+      this._auth.read(payload);
+      this.emit("auth", this.auth);
+      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,
+      });
+      // this.buildConnection(); ?
+    });
+    await this.client
+      .connect({
+        keepAlive: 60,
+        protocolLevel: 3,
+        clean: true,
+        connectDelay: 60 * 1000,
+      })
+      .catch((e) => {
+        this.fbnsDebug(`Connection failed: ${e}`);
+        throw e;
+      });
+    if (!this.client.ready) throw new Error("OB Connection failed");
+    await this.client.subscribe({
+      topic: constants_1.FbnsTopics.FBNS_MESSAGE.id,
+    });
+    const msg = await (0, shared_1.listenOnce)(
+      this.client,
+      constants_1.FbnsTopics.FBNS_REG_RESP.id
+    );
+    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;
     }
-    disconnect() {
-        this.safeDisconnect = true;
-        if (!this.client) {
-            return Promise.resolve();
-        }
-        return this.client.disconnect();
+    try {
+      await this.sendPushRegister(token);
+    } catch (e) {
+      if (e instanceof Error) {
+        this.emit("error", e);
+      }
+      throw e;
     }
-    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);
-        }
+  }
+  disconnect() {
+    this.safeDisconnect = true;
+    if (!this.client) {
+      return Promise.resolve();
     }
-    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,
-                _csrftoken: this.ig.state.cookieCsrfToken,
-                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;
+    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,
+        _csrftoken: this.ig.state.cookieCsrfToken,
+        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;
-//# sourceMappingURL=fbns.client.js.map
+//# sourceMappingURL=fbns.client.js.map

package/dist/mqttot/mqttot.client.d.ts

@@ -1,5 +1,5 @@
 import { MQTToTConnectPacketOptions } from './mqttot.connect.request.packet';
-import { ConnectRequestOptions, DefaultPacketReadResultMap, DefaultPacketWriteOptions, MqttClient, MqttMessage, MqttMessageOutgoing, PacketFlowFunc, PacketType } from 'obmqtt';
+import { ConnectRequestOptions, DefaultPacketReadResultMap, DefaultPacketWriteOptions, MqttClient, MqttMessage, MqttMessageOutgoing, PacketFlowFunc, PacketType } from 'abmqtt-dist';
 import { MQTToTConnectResponsePacket } from './mqttot.connect.response.packet';
 import { SocksProxy } from 'socks';
 import { ConnectionOptions } from 'tls';
@@ -34,4 +34,4 @@ export declare class MQTToTClient extends MqttClient<MQTToTReadMap, MQTToTWriteM
     mqttotPublish(message: MqttMessage): Promise<MqttMessageOutgoing>;
 }
 export declare function mqttotConnectFlow(payload: Buffer, requirePayload: boolean): PacketFlowFunc<MQTToTReadMap, MQTToTWriteMap, MQTToTConnectResponsePacket>;
-export {};
+export { };

package/dist/mqttot/mqttot.client.js

@@ -4,98 +4,110 @@ exports.MQTToTClient = void 0;
 exports.mqttotConnectFlow = mqttotConnectFlow;
 const shared_1 = require("../shared");
 const mqttot_connect_request_packet_1 = require("./mqttot.connect.request.packet");
-const obmqtt_1 = require("obmqtt");
+const obmqtt_1 = require("abmqtt-dist");
 const errors_1 = require("../errors");
 const mqttot_connect_response_packet_1 = require("./mqttot.connect.response.packet");
 class MQTToTClient extends obmqtt_1.MqttClient {
-    constructor(options) {
-        super({
-            autoReconnect: options.autoReconnect,
-            readMap: {
-                ...obmqtt_1.DefaultPacketReadMap,
-                [obmqtt_1.PacketType.ConnAck]: mqttot_connect_response_packet_1.readConnectResponsePacket,
-            },
-            writeMap: {
-                ...obmqtt_1.DefaultPacketWriteMap,
-                [obmqtt_1.PacketType.Connect]: mqttot_connect_request_packet_1.writeConnectRequestPacket,
-            },
-            transport: options.socksOptions
-                ? new obmqtt_1.SocksTlsTransport({
-                    host: options.url,
-                    port: 443,
-                    proxyOptions: options.socksOptions,
-                    additionalOptions: options.additionalOptions,
-                })
-                : new obmqtt_1.TlsTransport({
-                    host: options.url,
-                    port: 443,
-                    additionalOptions: options.additionalOptions,
-                }),
-        });
-        this.mqttotDebug = (msg, ...args) => (0, shared_1.debugChannel)('mqttot')(`${options.url}: ${msg}`, ...args);
-        this.connectPayloadProvider = options.payloadProvider;
-        this.mqttotDebug(`Creating client`);
-        this.registerListeners();
-        this.requirePayload = options.requirePayload;
-    }
-    registerListeners() {
-        const printErrorOrWarning = (type) => (e) => {
-            if (typeof e === 'string') {
-                this.mqttotDebug(`${type}: ${e}`);
-            }
-            else {
-                this.mqttotDebug(`${type}: ${e.message}\n\tStack: ${e.stack}`);
-            }
-        };
-        this.on('error', printErrorOrWarning('Error'));
-        this.on('warning', printErrorOrWarning('Warning'));
-        this.on('disconnect', e => this.mqttotDebug(`Disconnected. ${e}`));
-    }
-    async connect(options) {
-        this.connectPayload = await this.connectPayloadProvider();
-        return super.connect(options);
-    }
-    getConnectFlow() {
-        if (!this.connectPayload) {
-            throw new obmqtt_1.IllegalStateError('Called getConnectFlow() before calling connect()');
-        }
-        return mqttotConnectFlow(this.connectPayload, this.requirePayload);
-    }
-    /**
-     * Compresses the payload
-     * @param {MqttMessage} message
-     * @returns {Promise<MqttMessageOutgoing>}
-     */
-    async mqttotPublish(message) {
-        this.mqttotDebug(`Publishing ${message.payload.byteLength}bytes to topic ${message.topic}`);
-        return await this.publish({
-            topic: message.topic,
-            payload: await (0, shared_1.compressDeflate)(message.payload),
-            qosLevel: message.qosLevel,
-        });
+  constructor(options) {
+    super({
+      autoReconnect: options.autoReconnect,
+      readMap: {
+        ...obmqtt_1.DefaultPacketReadMap,
+        [obmqtt_1.PacketType.ConnAck]:
+          mqttot_connect_response_packet_1.readConnectResponsePacket,
+      },
+      writeMap: {
+        ...obmqtt_1.DefaultPacketWriteMap,
+        [obmqtt_1.PacketType.Connect]:
+          mqttot_connect_request_packet_1.writeConnectRequestPacket,
+      },
+      transport: options.socksOptions
+        ? new obmqtt_1.SocksTlsTransport({
+            host: options.url,
+            port: 443,
+            proxyOptions: options.socksOptions,
+            additionalOptions: options.additionalOptions,
+          })
+        : new obmqtt_1.TlsTransport({
+            host: options.url,
+            port: 443,
+            additionalOptions: options.additionalOptions,
+          }),
+    });
+    this.mqttotDebug = (msg, ...args) =>
+      (0, shared_1.debugChannel)("mqttot")(`${options.url}: ${msg}`, ...args);
+    this.connectPayloadProvider = options.payloadProvider;
+    this.mqttotDebug(`Creating client`);
+    this.registerListeners();
+    this.requirePayload = options.requirePayload;
+  }
+  registerListeners() {
+    const printErrorOrWarning = (type) => (e) => {
+      if (typeof e === "string") {
+        this.mqttotDebug(`${type}: ${e}`);
+      } else {
+        this.mqttotDebug(`${type}: ${e.message}\n\tStack: ${e.stack}`);
+      }
+    };
+    this.on("error", printErrorOrWarning("Error"));
+    this.on("warning", printErrorOrWarning("Warning"));
+    this.on("disconnect", (e) => this.mqttotDebug(`Disconnected. ${e}`));
+  }
+  async connect(options) {
+    this.connectPayload = await this.connectPayloadProvider();
+    return super.connect(options);
+  }
+  getConnectFlow() {
+    if (!this.connectPayload) {
+      throw new obmqtt_1.IllegalStateError(
+        "Called getConnectFlow() before calling connect()"
+      );
     }
+    return mqttotConnectFlow(this.connectPayload, this.requirePayload);
+  }
+  /**
+   * Compresses the payload
+   * @param {MqttMessage} message
+   * @returns {Promise<MqttMessageOutgoing>}
+   */
+  async mqttotPublish(message) {
+    this.mqttotDebug(
+      `Publishing ${message.payload.byteLength}bytes to topic ${message.topic}`
+    );
+    return await this.publish({
+      topic: message.topic,
+      payload: await (0, shared_1.compressDeflate)(message.payload),
+      qosLevel: message.qosLevel,
+    });
+  }
 }
 exports.MQTToTClient = MQTToTClient;
 function mqttotConnectFlow(payload, requirePayload) {
-    return (success, error) => ({
-        start: () => ({
-            type: obmqtt_1.PacketType.Connect,
-            options: {
-                payload,
-                keepAlive: 60,
-            },
-        }),
-        accept: obmqtt_1.isConnAck,
-        next: (packet) => {
-            if (packet.isSuccess) {
-                if (packet.payload?.length || !requirePayload)
-                    success(packet);
-                else
-                    error(new errors_1.EmptyPacketError(`CONNACK: no payload (payloadExpected): ${packet.payload}`));
-            }
-            else
-                error(new errors_1.ConnectionFailedError(`CONNACK returnCode: ${packet.returnCode} errorName: ${packet.errorName}`));
-        },
-    });
+  return (success, error) => ({
+    start: () => ({
+      type: obmqtt_1.PacketType.Connect,
+      options: {
+        payload,
+        keepAlive: 60,
+      },
+    }),
+    accept: obmqtt_1.isConnAck,
+    next: (packet) => {
+      if (packet.isSuccess) {
+        if (packet.payload?.length || !requirePayload) success(packet);
+        else
+          error(
+            new errors_1.EmptyPacketError(
+              `CONNACK: no payload (payloadExpected): ${packet.payload}`
+            )
+          );
+      } else
+        error(
+          new errors_1.ConnectionFailedError(
+            `CONNACK returnCode: ${packet.returnCode} errorName: ${packet.errorName}`
+          )
+        );
+    },
+  });
 }
-//# sourceMappingURL=mqttot.client.js.map
+//# sourceMappingURL=mqttot.client.js.map

package/dist/mqttot/mqttot.connect.request.packet.d.ts

@@ -1,4 +1,4 @@
-import { PacketStream, PacketWriteResult } from 'obmqtt';
+import { PacketStream, PacketWriteResult } from 'abmqtt-dist';
 export interface MQTToTConnectPacketOptions {
     keepAlive: number;
     payload: Buffer;

package/dist/mqttot/mqttot.connect.response.packet.d.ts

@@ -1,4 +1,4 @@
-import { ConnectResponsePacket, PacketStream, ConnectReturnCode } from 'obmqtt';
+import { ConnectResponsePacket, PacketStream, ConnectReturnCode } from 'abmqtt-dist';
 export declare class MQTToTConnectResponsePacket extends ConnectResponsePacket {
     readonly payload: Buffer;
     constructor(ackFlags: number, returnCode: ConnectReturnCode, payload: Buffer);

package/dist/mqttot/mqttot.connect.response.packet.js

@@ -2,23 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MQTToTConnectResponsePacket = void 0;
 exports.readConnectResponsePacket = readConnectResponsePacket;
-const obmqtt_1 = require("obmqtt");
+const obmqtt_1 = require("abmqtt-dist");
 class MQTToTConnectResponsePacket extends obmqtt_1.ConnectResponsePacket {
-    constructor(ackFlags, returnCode, payload) {
-        super(ackFlags, returnCode);
-        this.payload = payload;
-    }
+  constructor(ackFlags, returnCode, payload) {
+    super(ackFlags, returnCode);
+    this.payload = payload;
+  }
 }
 exports.MQTToTConnectResponsePacket = MQTToTConnectResponsePacket;
 function readConnectResponsePacket(stream, remaining) {
-    const ack = stream.readByte();
-    const returnCode = stream.readByte();
-    if (ack > 1) {
-        throw new Error('Invalid ack');
-    }
-    else if (returnCode > 5) {
-        throw new Error('Invalid return code');
-    }
-    return new MQTToTConnectResponsePacket(ack, returnCode, remaining > 2 ? stream.readStringAsBuffer() : Buffer.alloc(0));
+  const ack = stream.readByte();
+  const returnCode = stream.readByte();
+  if (ack > 1) {
+    throw new Error("Invalid ack");
+  } else if (returnCode > 5) {
+    throw new Error("Invalid return code");
+  }
+  return new MQTToTConnectResponsePacket(
+    ack,
+    returnCode,
+    remaining > 2 ? stream.readStringAsBuffer() : Buffer.alloc(0)
+  );
 }
-//# sourceMappingURL=mqttot.connect.response.packet.js.map
+//# sourceMappingURL=mqttot.connect.response.packet.js.map

package/dist/realtime/commands/commands.d.ts

@@ -1,6 +1,6 @@
 import { Topic } from '../../topic';
 import { MQTToTClient } from '../../mqttot';
-import { MqttMessageOutgoing } from 'obmqtt';
+import { MqttMessageOutgoing } from 'abmqtt-dist';
 export declare class Commands {
     private client;
     constructor(client: MQTToTClient);