nodejs-insta-private-api-mqtt 1.0.0

package/dist/downloadMedia.js

@@ -0,0 +1,381 @@
+/**
+ * Download Media from Instagram Messages
+ * 
+ * Similar to Baileys' downloadContentFromMessage() function.
+ * Extracts and downloads media (photos, videos, voice notes) from Instagram DM messages.
+ * 
+ * Supports:
+ * - Regular photos/videos in DMs
+ * - View-once (raven) media - MUST download BEFORE marking as seen
+ * - Voice messages
+ * - Shared reels/posts
+ * 
+ * @author Added for nodejs-insta-private-api
+ * @version 1.0.0
+ */
+
+const axios = require('axios');
+const { Transform } = require('stream');
+
+/**
+ * Media types supported
+ */
+const MEDIA_TYPES = {
+  IMAGE: 'image',
+  VIDEO: 'video', 
+  AUDIO: 'audio',
+  VOICE: 'voice',
+  RAVEN_IMAGE: 'raven_image',
+  RAVEN_VIDEO: 'raven_video',
+  MEDIA_SHARE: 'media_share',
+  REEL_SHARE: 'reel_share',
+  STORY_SHARE: 'story_share',
+  CLIP: 'clip'
+};
+
+/**
+ * Extract media URLs from an Instagram message object
+ * 
+ * @param {Object} message - The Instagram message object from MQTT/API
+ * @returns {Object|null} - Object with urls, type, and metadata or null if no media
+ */
+function extractMediaUrls(message) {
+  if (!message) return null;
+  
+  const result = {
+    urls: [],
+    type: null,
+    width: null,
+    height: null,
+    duration: null,
+    isViewOnce: false,
+    expiresAt: null,
+    originalMessage: message
+  };
+
+  // Check item_type for message type
+  const itemType = message.item_type || message.type;
+  
+  // Handle view-once (raven) media
+  if (itemType === 'raven_media' || message.visual_media) {
+    result.isViewOnce = true;
+    const visualMedia = message.visual_media || message.raven_media;
+    
+    if (visualMedia) {
+      const media = visualMedia.media || visualMedia;
+      result.expiresAt = visualMedia.expiring_media_action_summary?.timestamp;
+      
+      // Extract image
+      if (media.image_versions2?.candidates) {
+        result.type = MEDIA_TYPES.RAVEN_IMAGE;
+        result.urls = media.image_versions2.candidates.map(c => ({
+          url: c.url,
+          width: c.width,
+          height: c.height
+        }));
+        result.width = result.urls[0]?.width;
+        result.height = result.urls[0]?.height;
+      }
+      
+      // Extract video
+      if (media.video_versions) {
+        result.type = MEDIA_TYPES.RAVEN_VIDEO;
+        result.urls = media.video_versions.map(v => ({
+          url: v.url,
+          width: v.width,
+          height: v.height,
+          type: v.type
+        }));
+        result.duration = media.video_duration;
+        result.width = result.urls[0]?.width;
+        result.height = result.urls[0]?.height;
+      }
+    }
+    
+    return result.urls.length > 0 ? result : null;
+  }
+  
+  // Handle regular media message
+  if (itemType === 'media' || message.media) {
+    const media = message.media || message;
+    
+    // Image
+    if (media.image_versions2?.candidates) {
+      result.type = MEDIA_TYPES.IMAGE;
+      result.urls = media.image_versions2.candidates.map(c => ({
+        url: c.url,
+        width: c.width,
+        height: c.height
+      }));
+      result.width = result.urls[0]?.width;
+      result.height = result.urls[0]?.height;
+    }
+    
+    // Video
+    if (media.video_versions) {
+      result.type = MEDIA_TYPES.VIDEO;
+      result.urls = media.video_versions.map(v => ({
+        url: v.url,
+        width: v.width,
+        height: v.height,
+        type: v.type
+      }));
+      result.duration = media.video_duration;
+      result.width = result.urls[0]?.width;
+      result.height = result.urls[0]?.height;
+    }
+    
+    return result.urls.length > 0 ? result : null;
+  }
+  
+  // Handle voice message
+  if (itemType === 'voice_media' || message.voice_media) {
+    const voiceMedia = message.voice_media || message;
+    const audio = voiceMedia.media || voiceMedia;
+    
+    if (audio.audio) {
+      result.type = MEDIA_TYPES.VOICE;
+      result.urls = [{
+        url: audio.audio.audio_src,
+        duration: audio.audio.duration
+      }];
+      result.duration = audio.audio.duration;
+    }
+    
+    return result.urls.length > 0 ? result : null;
+  }
+  
+  // Handle media share (shared post)
+  if (itemType === 'media_share' || message.media_share) {
+    const mediaShare = message.media_share || message;
+    
+    if (mediaShare.image_versions2?.candidates) {
+      result.type = MEDIA_TYPES.MEDIA_SHARE;
+      result.urls = mediaShare.image_versions2.candidates.map(c => ({
+        url: c.url,
+        width: c.width,
+        height: c.height
+      }));
+    }
+    
+    if (mediaShare.video_versions) {
+      result.type = MEDIA_TYPES.MEDIA_SHARE;
+      result.urls = mediaShare.video_versions.map(v => ({
+        url: v.url,
+        width: v.width,
+        height: v.height
+      }));
+      result.duration = mediaShare.video_duration;
+    }
+    
+    return result.urls.length > 0 ? result : null;
+  }
+  
+  // Handle reel share
+  if (itemType === 'clip' || itemType === 'felix_share' || message.clip) {
+    const clip = message.clip?.clip || message.felix_share?.video || message;
+    
+    if (clip.image_versions2?.candidates) {
+      result.type = MEDIA_TYPES.CLIP;
+      result.urls = clip.image_versions2.candidates.map(c => ({
+        url: c.url,
+        width: c.width,
+        height: c.height
+      }));
+    }
+    
+    if (clip.video_versions) {
+      result.type = MEDIA_TYPES.CLIP;
+      result.urls = clip.video_versions.map(v => ({
+        url: v.url,
+        width: v.width,
+        height: v.height
+      }));
+      result.duration = clip.video_duration;
+    }
+    
+    return result.urls.length > 0 ? result : null;
+  }
+  
+  // Handle story share
+  if (itemType === 'story_share' || message.story_share) {
+    const story = message.story_share?.media || message.story_share || message;
+    
+    if (story.image_versions2?.candidates) {
+      result.type = MEDIA_TYPES.STORY_SHARE;
+      result.urls = story.image_versions2.candidates.map(c => ({
+        url: c.url,
+        width: c.width,
+        height: c.height
+      }));
+    }
+    
+    if (story.video_versions) {
+      result.type = MEDIA_TYPES.STORY_SHARE;
+      result.urls = story.video_versions.map(v => ({
+        url: v.url,
+        width: v.width,
+        height: v.height
+      }));
+    }
+    
+    return result.urls.length > 0 ? result : null;
+  }
+  
+  return null;
+}
+
+/**
+ * Download media content from an Instagram message
+ * Similar to Baileys' downloadContentFromMessage()
+ * 
+ * @param {Object} message - The Instagram message object containing media
+ * @param {string} type - Optional: 'image', 'video', 'audio' to specify which type to download
+ * @param {Object} options - Optional download options
+ * @param {number} options.quality - Quality index (0 = highest, default 0)
+ * @param {number} options.timeout - Request timeout in ms (default 30000)
+ * @param {Object} options.headers - Additional headers for the request
+ * @returns {Promise<Transform>} - Readable stream of the media content
+ * 
+ * @example
+ * // Download view-once image before marking as seen
+ * const stream = await downloadContentFromMessage(message, 'image');
+ * let buffer = Buffer.from([]);
+ * for await (const chunk of stream) {
+ *   buffer = Buffer.concat([buffer, chunk]);
+ * }
+ * fs.writeFileSync('saved-viewonce.jpg', buffer);
+ */
+async function downloadContentFromMessage(message, type = null, options = {}) {
+  const mediaInfo = extractMediaUrls(message);
+  
+  if (!mediaInfo || mediaInfo.urls.length === 0) {
+    throw new Error('No media found in message');
+  }
+  
+  // Select quality (0 = best)
+  const qualityIndex = options.quality || 0;
+  const selectedUrl = mediaInfo.urls[Math.min(qualityIndex, mediaInfo.urls.length - 1)];
+  
+  if (!selectedUrl?.url) {
+    throw new Error('Could not extract media URL from message');
+  }
+  
+  const timeout = options.timeout || 30000;
+  const headers = {
+    'User-Agent': 'Instagram 275.0.0.27.98 Android',
+    'Accept': '*/*',
+    'Accept-Encoding': 'gzip, deflate',
+    ...(options.headers || {})
+  };
+  
+  try {
+    const response = await axios({
+      method: 'GET',
+      url: selectedUrl.url,
+      responseType: 'stream',
+      timeout: timeout,
+      headers: headers,
+      maxRedirects: 5
+    });
+    
+    // Create transform stream to pass through
+    const transform = new Transform({
+      transform(chunk, encoding, callback) {
+        this.push(chunk);
+        callback();
+      }
+    });
+    
+    // Attach metadata to stream
+    transform.mediaInfo = {
+      type: mediaInfo.type,
+      isViewOnce: mediaInfo.isViewOnce,
+      width: selectedUrl.width || mediaInfo.width,
+      height: selectedUrl.height || mediaInfo.height,
+      duration: mediaInfo.duration,
+      contentType: response.headers['content-type'],
+      contentLength: parseInt(response.headers['content-length']) || null
+    };
+    
+    response.data.pipe(transform);
+    
+    return transform;
+    
+  } catch (error) {
+    throw new Error(`Failed to download media: ${error.message}`);
+  }
+}
+
+/**
+ * Download media content as a Buffer directly
+ * Convenience wrapper around downloadContentFromMessage
+ * 
+ * @param {Object} message - The Instagram message object containing media
+ * @param {string} type - Optional: 'image', 'video', 'audio' to specify type
+ * @param {Object} options - Optional download options
+ * @returns {Promise<{buffer: Buffer, mediaInfo: Object}>} - Buffer and metadata
+ * 
+ * @example
+ * const { buffer, mediaInfo } = await downloadMediaBuffer(message);
+ * console.log('Downloaded', mediaInfo.type, 'size:', buffer.length);
+ * fs.writeFileSync('media.' + (mediaInfo.type === 'video' ? 'mp4' : 'jpg'), buffer);
+ */
+async function downloadMediaBuffer(message, type = null, options = {}) {
+  const stream = await downloadContentFromMessage(message, type, options);
+  
+  const chunks = [];
+  
+  return new Promise((resolve, reject) => {
+    stream.on('data', (chunk) => chunks.push(chunk));
+    stream.on('end', () => {
+      resolve({
+        buffer: Buffer.concat(chunks),
+        mediaInfo: stream.mediaInfo
+      });
+    });
+    stream.on('error', reject);
+  });
+}
+
+/**
+ * Check if a message contains downloadable media
+ * 
+ * @param {Object} message - The Instagram message object
+ * @returns {boolean} - True if message contains downloadable media
+ */
+function hasMedia(message) {
+  return extractMediaUrls(message) !== null;
+}
+
+/**
+ * Get media type from message without downloading
+ * 
+ * @param {Object} message - The Instagram message object
+ * @returns {string|null} - Media type or null
+ */
+function getMediaType(message) {
+  const info = extractMediaUrls(message);
+  return info?.type || null;
+}
+
+/**
+ * Check if message is view-once (disappearing)
+ * 
+ * @param {Object} message - The Instagram message object
+ * @returns {boolean} - True if view-once media
+ */
+function isViewOnceMedia(message) {
+  const info = extractMediaUrls(message);
+  return info?.isViewOnce || false;
+}
+
+module.exports = {
+  downloadContentFromMessage,
+  downloadMediaBuffer,
+  extractMediaUrls,
+  hasMedia,
+  getMediaType,
+  isViewOnceMedia,
+  MEDIA_TYPES
+};

package/dist/errors/index.d.ts

@@ -0,0 +1,16 @@
+declare class BaseError extends Error {
+    constructor(message?: string);
+}
+export declare class ClientDisconnectedError extends BaseError {
+}
+export declare class EmptyPacketError extends BaseError {
+}
+export declare class InvalidStateError extends BaseError {
+}
+export declare class ConnectionFailedError extends BaseError {
+}
+export declare class IllegalArgumentError extends BaseError {
+}
+export declare class ThriftError extends BaseError {
+}
+export {};

package/dist/errors/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThriftError = exports.IllegalArgumentError = exports.ConnectionFailedError = exports.InvalidStateError = exports.EmptyPacketError = exports.ClientDisconnectedError = void 0;
+class BaseError extends Error {
+    constructor(message) {
+        super(message);
+        // @ts-ignore -- set the name to the class's actual name
+        this.name = this.__proto__.constructor.name;
+    }
+}
+class ClientDisconnectedError extends BaseError {
+}
+exports.ClientDisconnectedError = ClientDisconnectedError;
+class EmptyPacketError extends BaseError {
+}
+exports.EmptyPacketError = EmptyPacketError;
+class InvalidStateError extends BaseError {
+}
+exports.InvalidStateError = InvalidStateError;
+class ConnectionFailedError extends BaseError {
+}
+exports.ConnectionFailedError = ConnectionFailedError;
+class IllegalArgumentError extends BaseError {
+}
+exports.IllegalArgumentError = IllegalArgumentError;
+// TODO: split further
+class ThriftError extends BaseError {
+}
+exports.ThriftError = ThriftError;
+//# sourceMappingURL=index.js.map

package/dist/errors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/errors/index.ts"],"names":[],"mappings":";;;AAAA,MAAM,SAAU,SAAQ,KAAK;IAC1B,YAAY,OAAgB;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,wDAAwD;QACxD,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC;IAC/C,CAAC;CACH;AAED,MAAa,uBAAwB,SAAQ,SAAS;CAAG;AAAzD,0DAAyD;AAEzD,MAAa,gBAAiB,SAAQ,SAAS;CAAG;AAAlD,4CAAkD;AAElD,MAAa,iBAAkB,SAAQ,SAAS;CAAG;AAAnD,8CAAmD;AAEnD,MAAa,qBAAsB,SAAQ,SAAS;CAAG;AAAvD,sDAAuD;AAEvD,MAAa,oBAAqB,SAAQ,SAAS;CAAG;AAAtD,oDAAsD;AAEtD,sBAAsB;AACtB,MAAa,WAAY,SAAQ,SAAS;CAAG;AAA7C,kCAA6C"}

package/dist/fbns/fbns.client.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+import { IgApiClient, StatusResponse } from 'instagram-private-api';
+import { FbnsDeviceAuth } from './fbns.device-auth';
+import { ToEventFn } from '../shared';
+import { FbnsNotificationUnknown } from './fbns.types';
+import { EventEmitter } from 'eventemitter3';
+import { FbnsClientEvents } from './fbns.client.events';
+import { SocksProxy } from 'socks';
+import { ConnectionOptions } from 'tls';
+export declare class FbnsClient extends EventEmitter<ToEventFn<FbnsClientEvents & {
+    [x: string]: FbnsNotificationUnknown;
+}>> {
+    private readonly ig;
+    get auth(): FbnsDeviceAuth;
+    set auth(value: FbnsDeviceAuth);
+    private fbnsDebug;
+    private client?;
+    private conn?;
+    private _auth;
+    private safeDisconnect;
+    constructor(ig: IgApiClient);
+    buildConnection(): void;
+    connect({ enableTrace, autoReconnect, socksOptions, additionalTlsOptions, }?: {
+        enableTrace?: boolean;
+        autoReconnect?: boolean;
+        socksOptions?: SocksProxy;
+        additionalTlsOptions?: ConnectionOptions;
+    }): Promise<any>;
+    disconnect(): Promise<void>;
+    private handleMessage;
+    sendPushRegister(token: string): Promise<StatusResponse>;
+}

package/dist/fbns/fbns.client.events.d.ts

@@ -0,0 +1,41 @@
+import { FbnsMessageData, FbnsNotification, FbnsNotificationUnknown } from './fbns.types';
+import { FbnsDeviceAuth } from './fbns.device-auth';
+export interface FbnsClientEvents extends ToClientEvents<FbnsNotificationEventParams> {
+    auth: FbnsDeviceAuth;
+    push: FbnsNotificationUnknown;
+    error: Error;
+    warning: Error;
+    message: FbnsMessageData;
+    logging: {
+        beacon_id: number;
+    };
+    pp: string;
+    disconnect: string | undefined;
+}
+export type ToClientEvents<T> = {
+    [x in keyof T]: FbnsNotification<T[x]>;
+};
+export interface FbnsNotificationEventParams {
+    post: {
+        id: string;
+    };
+    first_post: {
+        username: string;
+    };
+    resurrected_user_post: {
+        id: string;
+    };
+    recent_follow_post: {
+        id: string;
+    };
+    fb_first_post: {
+        username: string;
+    };
+    first_bestie_post: {
+        id: string;
+    };
+    direct_v2_message: {
+        id: string;
+        x: string;
+    };
+}

package/dist/fbns/fbns.client.events.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=fbns.client.events.js.map

package/dist/fbns/fbns.client.events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fbns.client.events.js","sourceRoot":"","sources":["../../src/fbns/fbns.client.events.ts"],"names":[],"mappings":""}

package/dist/fbns/fbns.client.js

@@ -0,0 +1,179 @@
+"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("mqtts");
+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 mqtts_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;
+        });
+        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;
+        }
+    }
+    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,
+                _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