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

package/dist-ts/dist/realtime/realtime.service.js

@@ -0,0 +1,408 @@
+const EventEmitter = require('events');
+const mqtt = require('mqtt');
+const { v4: uuidv4 } = require('uuid');
+const { Topics, RealtimeTopicsArray, REALTIME } = require('./topic');
+/**
+ * Instagram Realtime MQTT Service
+ *
+ * Implements Instagram's realtime messaging system using MQTT
+ * with the correct endpoint: edge-mqtt.facebook.com
+ *
+ * @class RealtimeService
+ * @extends EventEmitter
+ */
+class RealtimeService extends EventEmitter {
+    constructor(client) {
+        super();
+        this.client = client;
+        this.mqttClient = null;
+        this.isConnected = false;
+        this.isConnecting = false;
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 10;
+        this.reconnectDelay = 5000; // 5 seconds
+        this.keepalive = 60;
+        this.cleanSession = false;
+        // MQTT Configuration
+        this.broker = REALTIME.HOST_NAME_V6;
+        this.port = 443; // TLS
+        this.protocol = 'mqtts';
+        this.username = 'fbns';
+        // Client ID generated
+        this.clientId = `android-${uuidv4().replace(/-/g, '')}`;
+        // Bind methods to preserve context
+        this._onConnect = this._onConnect.bind(this);
+        this._onMessage = this._onMessage.bind(this);
+        this._onError = this._onError.bind(this);
+        this._onClose = this._onClose.bind(this);
+        this._onOffline = this._onOffline.bind(this);
+        this._onReconnect = this._onReconnect.bind(this);
+    }
+    /**
+     * Connect to MQTT broker
+     * @returns {Promise<boolean>} True if connection succeeded
+     */
+    async connect() {
+        if (this.isConnected || this.isConnecting) {
+            return this.isConnected;
+        }
+        this.isConnecting = true;
+        try {
+            // Check if client is authenticated
+            if (!this.client.isLoggedIn()) {
+                throw new Error('Client must be logged in to use realtime service');
+            }
+            // Get authorization token from session
+            const authToken = this._getAuthToken();
+            if (!authToken) {
+                throw new Error('No valid authorization token found in session');
+            }
+            // MQTT connection configuration
+            const mqttOptions = {
+                clientId: this.clientId,
+                username: this.username,
+                password: authToken,
+                keepalive: this.keepalive,
+                clean: this.cleanSession,
+                reconnectPeriod: 0, // Disable automatic reconnection - we handle it manually
+                connectTimeout: 30000,
+                protocolVersion: 4, // MQTT v3.1.1
+                rejectUnauthorized: true
+            };
+            // Broker URL
+            const brokerUrl = `${this.protocol}://${this.broker}:${this.port}`;
+            if (this.client.state.verbose) {
+                console.log(`[Realtime] Connecting to MQTT broker: ${brokerUrl}`);
+                console.log(`[Realtime] Client ID: ${this.clientId}`);
+                console.log(`[Realtime] Username: ${this.username}`);
+            }
+            // Create MQTT connection
+            this.mqttClient = mqtt.connect(brokerUrl, mqttOptions);
+            // Configure event handlers
+            this.mqttClient.on('connect', this._onConnect);
+            this.mqttClient.on('message', this._onMessage);
+            this.mqttClient.on('error', this._onError);
+            this.mqttClient.on('close', this._onClose);
+            this.mqttClient.on('offline', this._onOffline);
+            this.mqttClient.on('reconnect', this._onReconnect);
+            // Wait for connection
+            return new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    this.isConnecting = false;
+                    reject(new Error('MQTT connection timeout'));
+                }, 30000);
+                this.mqttClient.once('connect', () => {
+                    clearTimeout(timeout);
+                    this.isConnecting = false;
+                    resolve(true);
+                });
+                this.mqttClient.once('error', (err) => {
+                    clearTimeout(timeout);
+                    this.isConnecting = false;
+                    reject(err);
+                });
+            });
+        }
+        catch (error) {
+            this.isConnecting = false;
+            if (this.client.state.verbose) {
+                console.error('[Realtime] Connection failed:', error.message);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Disconnect from MQTT broker
+     */
+    disconnect() {
+        if (this.mqttClient && this.isConnected) {
+            if (this.client.state.verbose) {
+                console.log('[Realtime] Disconnecting from MQTT broker...');
+            }
+            this.mqttClient.end();
+            this.isConnected = false;
+            this.reconnectAttempts = 0;
+        }
+    }
+    /**
+     * Check if service is connected
+     * @returns {boolean}
+     */
+    isRealtimeConnected() {
+        return this.isConnected && this.mqttClient && this.mqttClient.connected;
+    }
+    /**
+     * Send ping to broker
+     */
+    ping() {
+        if (this.isRealtimeConnected()) {
+            if (this.client.state.verbose) {
+                console.log('[Realtime] Sending ping...');
+            }
+            // MQTT client handles ping automatically through keepalive
+            // But we can emit an event for debugging
+            this.emit('ping');
+        }
+    }
+    /**
+     * Get authorization token from session
+     * @private
+     */
+    _getAuthToken() {
+        try {
+            // Try to get from state.authorization
+            if (this.client.state.authorization) {
+                return this.client.state.authorization;
+            }
+            // Fallback: try to get from cookies
+            const sessionId = this.client.state.getCookieValueSafe('sessionid');
+            if (sessionId) {
+                return sessionId;
+            }
+            return null;
+        }
+        catch (error) {
+            if (this.client.state.verbose) {
+                console.error('[Realtime] Error getting auth token:', error.message);
+            }
+            return null;
+        }
+    }
+    /**
+     * Handler for MQTT connection
+     * @private
+     */
+    _onConnect() {
+        this.isConnected = true;
+        this.reconnectAttempts = 0;
+        if (this.client.state.verbose) {
+            console.log('[Realtime] Connected to MQTT broker');
+        }
+        // Subscribe to all topics
+        this._subscribeToTopics();
+        // Emit connection event
+        this.emit('connected');
+    }
+    /**
+     * Handler for MQTT messages
+     * @private
+     */
+    _onMessage(topic, payload) {
+        try {
+            const message = payload.toString();
+            if (this.client.state.verbose) {
+                console.log(`[Realtime] Received message on ${topic}: ${message}`);
+            }
+            // Find the topic configuration
+            const topicConfig = this._findTopicByPath(topic);
+            if (topicConfig && topicConfig.parser && !topicConfig.noParse) {
+                // Parse using the topic's parser
+                const parsedData = topicConfig.parser.parse(payload);
+                // Emit generic realtime event
+                this.emit('realtimeEvent', {
+                    topic,
+                    topicId: topicConfig.id,
+                    data: parsedData,
+                    rawPayload: message,
+                    timestamp: new Date().toISOString()
+                });
+                // Emit specific events based on topic
+                this._emitTopicSpecificEvent(topic, parsedData);
+            }
+            else {
+                // No parser or noParse is true, emit raw data
+                this.emit('realtimeEvent', {
+                    topic,
+                    topicId: topicConfig ? topicConfig.id : null,
+                    data: { raw: message },
+                    rawPayload: message,
+                    timestamp: new Date().toISOString()
+                });
+                // Emit specific events based on topic
+                this._emitTopicSpecificEvent(topic, { raw: message });
+            }
+        }
+        catch (error) {
+            if (this.client.state.verbose) {
+                console.error('[Realtime] Error processing message:', error.message);
+            }
+            this.emit('error', error);
+        }
+    }
+    /**
+     * Find topic configuration by path
+     * @private
+     */
+    _findTopicByPath(path) {
+        return RealtimeTopicsArray.find(topic => topic.path === path);
+    }
+    /**
+     * Emit topic-specific events
+     * @private
+     */
+    _emitTopicSpecificEvent(topic, data) {
+        switch (topic) {
+            case '/graphql':
+                this.emit('graphqlMessage', data);
+                break;
+            case '/pubsub':
+                this.emit('pubsubMessage', data);
+                break;
+            case '/ig_send_message_response':
+                this.emit('sendMessageResponse', data);
+                break;
+            case '/ig_sub_iris_response':
+                this.emit('irisSubResponse', data);
+                break;
+            case '/ig_message_sync':
+                this.emit('messageSync', data);
+                break;
+            case '/ig_realtime_sub':
+                this.emit('realtimeSub', data);
+                break;
+            case '/t_region_hint':
+                this.emit('regionHint', data);
+                break;
+            case '/t_fs':
+                this.emit('foregroundState', data);
+                break;
+            case '/ig_send_message':
+                this.emit('sendMessage', data);
+                break;
+            default:
+                this.emit('unknownMessage', { topic, data });
+        }
+    }
+    /**
+     * Handler for MQTT errors
+     * @private
+     */
+    _onError(error) {
+        if (this.client.state.verbose) {
+            console.error('[Realtime] MQTT error:', error.message);
+        }
+        this.emit('error', error);
+        // Try reconnection if not already in process
+        if (!this.isConnecting && this.reconnectAttempts < this.maxReconnectAttempts) {
+            this._scheduleReconnect();
+        }
+    }
+    /**
+     * Handler for connection close
+     * @private
+     */
+    _onClose() {
+        this.isConnected = false;
+        if (this.client.state.verbose) {
+            console.log('[Realtime] MQTT connection closed');
+        }
+        this.emit('disconnected');
+        // Try reconnection if not manually disconnected
+        if (this.reconnectAttempts < this.maxReconnectAttempts) {
+            this._scheduleReconnect();
+        }
+    }
+    /**
+     * Handler for offline
+     * @private
+     */
+    _onOffline() {
+        this.isConnected = false;
+        if (this.client.state.verbose) {
+            console.log('[Realtime] MQTT client offline');
+        }
+        this.emit('offline');
+    }
+    /**
+     * Handler for reconnection
+     * @private
+     */
+    _onReconnect() {
+        if (this.client.state.verbose) {
+            console.log('[Realtime] MQTT client reconnecting...');
+        }
+        this.emit('reconnecting');
+    }
+    /**
+     * Subscribe to all topics
+     * @private
+     */
+    _subscribeToTopics() {
+        if (!this.isRealtimeConnected()) {
+            return;
+        }
+        RealtimeTopicsArray.forEach(topic => {
+            this.mqttClient.subscribe(topic.path, (err) => {
+                if (err) {
+                    if (this.client.state.verbose) {
+                        console.error(`[Realtime] Failed to subscribe to ${topic.path}:`, err.message);
+                    }
+                }
+                else {
+                    if (this.client.state.verbose) {
+                        console.log(`[Realtime] Subscribed to ${topic.path}`);
+                    }
+                }
+            });
+        });
+    }
+    /**
+     * Schedule reconnection
+     * @private
+     */
+    _scheduleReconnect() {
+        if (this.isConnecting) {
+            return;
+        }
+        this.reconnectAttempts++;
+        const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1); // Exponential backoff
+        if (this.client.state.verbose) {
+            console.log(`[Realtime] Scheduling reconnect in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
+        }
+        setTimeout(() => {
+            if (this.reconnectAttempts <= this.maxReconnectAttempts) {
+                this.connect().catch(error => {
+                    if (this.client.state.verbose) {
+                        console.error('[Realtime] Reconnect failed:', error.message);
+                    }
+                });
+            }
+            else {
+                if (this.client.state.verbose) {
+                    console.error('[Realtime] Max reconnect attempts reached');
+                }
+                this.emit('maxReconnectAttemptsReached');
+            }
+        }, delay);
+    }
+    /**
+     * Set reconnection options
+     * @param {Object} options - Reconnection options
+     * @param {number} options.maxAttempts - Maximum number of attempts
+     * @param {number} options.delay - Initial delay in ms
+     */
+    setReconnectOptions(options = {}) {
+        if (typeof options.maxAttempts === 'number') {
+            this.maxReconnectAttempts = options.maxAttempts;
+        }
+        if (typeof options.delay === 'number') {
+            this.reconnectDelay = options.delay;
+        }
+    }
+    /**
+     * Get connection statistics
+     * @returns {Object} Connection statistics
+     */
+    getStats() {
+        return {
+            isConnected: this.isRealtimeConnected(),
+            isConnecting: this.isConnecting,
+            reconnectAttempts: this.reconnectAttempts,
+            maxReconnectAttempts: this.maxReconnectAttempts,
+            clientId: this.clientId,
+            subscribedTopics: RealtimeTopicsArray.map(t => t.path),
+            broker: `${this.protocol}://${this.broker}:${this.port}`
+        };
+    }
+}
+module.exports = RealtimeService;

package/dist-ts/dist/realtime/reconnect.manager.js

@@ -0,0 +1,72 @@
+const debug = require('debug')('ig:reconnect');
+class ReconnectManager {
+    constructor(options = {}) {
+        this.initialDelay = options.initialDelay || 3000;
+        this.maxDelay = options.maxDelay || 300000;
+        this.multiplier = options.multiplier || 2;
+        this.maxAttempts = options.maxAttempts || 0;
+        this.currentAttempt = 0;
+        this.currentDelay = this.initialDelay;
+        this.timerId = null;
+        this.lastErrorType = null;
+    }
+    getNextDelay(errorType) {
+        this.lastErrorType = errorType || this.lastErrorType;
+        if (this.currentAttempt === 0) {
+            this.currentDelay = this.initialDelay;
+        }
+        else {
+            let multiplier = this.multiplier;
+            if (this.lastErrorType === 'rate_limit') {
+                multiplier = 3;
+            }
+            else if (this.lastErrorType === 'auth_failure') {
+                multiplier = 2.5;
+            }
+            this.currentDelay = Math.min(this.currentDelay * multiplier, this.maxDelay);
+        }
+        const jitter = Math.floor(Math.random() * Math.min(this.currentDelay * 0.3, 10000));
+        this.currentAttempt++;
+        const totalDelay = this.currentDelay + jitter;
+        debug(`Reconnect attempt #${this.currentAttempt}, type: ${this.lastErrorType || 'unknown'}, delay: ${totalDelay}ms`);
+        return totalDelay;
+    }
+    scheduleReconnect(callback, errorType) {
+        if (this.maxAttempts > 0 && this.currentAttempt >= this.maxAttempts) {
+            debug('[RECONNECT] Max reconnection attempts reached');
+            return false;
+        }
+        const delay = this.getNextDelay(errorType);
+        this.timerId = setTimeout(() => {
+            debug(`[RECONNECT] Reconnecting... (attempt ${this.currentAttempt}, type: ${this.lastErrorType || 'unknown'})`);
+            callback();
+        }, delay);
+        return true;
+    }
+    reset() {
+        if (this.timerId) {
+            clearTimeout(this.timerId);
+            this.timerId = null;
+        }
+        this.currentAttempt = 0;
+        this.currentDelay = this.initialDelay;
+        this.lastErrorType = null;
+        debug('[RECONNECT] Manager reset');
+    }
+    cancel() {
+        if (this.timerId) {
+            clearTimeout(this.timerId);
+            this.timerId = null;
+        }
+    }
+    getState() {
+        return {
+            currentAttempt: this.currentAttempt,
+            currentDelay: this.currentDelay,
+            maxAttempts: this.maxAttempts,
+            pending: !!this.timerId,
+            lastErrorType: this.lastErrorType
+        };
+    }
+}
+module.exports = ReconnectManager;

package/dist-ts/dist/realtime/session.manager.js

@@ -0,0 +1,106 @@
+const fs = require('fs');
+const path = require('path');
+const debug = require('debug')('ig:session');
+/**
+ * Session Manager - Persistence pentru MQTT sessions
+ * Saves: sessionid, mqtt_session_id, subscription state, seq-ids
+ */
+class SessionManager {
+    constructor(storageFile = '.ig-mqtt-session.json') {
+        this.storageFile = storageFile;
+        this.data = {
+            sessionId: null,
+            mqttSessionId: null,
+            subscriptions: {},
+            seqIds: {},
+            topicAcks: {},
+            lastConnected: null,
+            reconnectAttempts: 0
+        };
+        this.load();
+    }
+    load() {
+        try {
+            if (fs.existsSync(this.storageFile)) {
+                const raw = fs.readFileSync(this.storageFile, 'utf-8');
+                this.data = JSON.parse(raw);
+                debug('✓ Session loaded from disk');
+            }
+        }
+        catch (e) {
+            debug('Session load error (first run?):', e.message);
+        }
+    }
+    save() {
+        try {
+            fs.writeFileSync(this.storageFile, JSON.stringify(this.data, null, 2));
+            debug('✓ Session saved');
+        }
+        catch (e) {
+            debug('Session save error:', e.message);
+        }
+    }
+    setSessionId(sessionId) {
+        this.data.sessionId = sessionId;
+        this.save();
+    }
+    getSessionId() {
+        return this.data.sessionId;
+    }
+    setMqttSessionId(mqttSessionId) {
+        this.data.mqttSessionId = mqttSessionId;
+        this.data.lastConnected = new Date().toISOString();
+        this.save();
+    }
+    getMqttSessionId() {
+        return this.data.mqttSessionId;
+    }
+    recordSubscription(topic, qos = 1) {
+        this.data.subscriptions[topic] = {
+            qos,
+            subscribedAt: new Date().toISOString()
+        };
+        this.save();
+    }
+    getSubscriptions() {
+        return Object.keys(this.data.subscriptions);
+    }
+    recordSeqId(topic, seqId) {
+        this.data.seqIds[topic] = seqId;
+        this.save();
+    }
+    getSeqId(topic) {
+        return this.data.seqIds[topic] || 0;
+    }
+    recordAck(topic, msgId) {
+        this.data.topicAcks[topic] = {
+            msgId,
+            ackedAt: new Date().toISOString()
+        };
+        this.save();
+    }
+    recordReconnectAttempt() {
+        this.data.reconnectAttempts++;
+        this.save();
+    }
+    resetReconnectAttempts() {
+        this.data.reconnectAttempts = 0;
+        this.save();
+    }
+    getReconnectAttempts() {
+        return this.data.reconnectAttempts;
+    }
+    clear() {
+        this.data = {
+            sessionId: null,
+            mqttSessionId: null,
+            subscriptions: {},
+            seqIds: {},
+            topicAcks: {},
+            lastConnected: null,
+            reconnectAttempts: 0
+        };
+        this.save();
+    }
+}
+module.exports = SessionManager;

package/dist-ts/dist/realtime/subscriptions/graphql.subscription.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLSubscriptions = exports.QueryIDs = void 0;
+const Chance = require("chance");
+// src: com.instagram.realtimeclient.RealtimeSubscription
+exports.QueryIDs = {
+    appPresence: '17846944882223835',
+    asyncAdSub: '17911191835112000',
+    clientConfigUpdate: '17849856529644700',
+    directStatus: '17854499065530643',
+    directTyping: '17867973967082385',
+    liveWave: '17882305414154951',
+    interactivityActivateQuestion: '18005526940184517',
+    interactivityRealtimeQuestionSubmissionsStatus: '18027779584026952',
+    interactivitySub: '17907616480241689',
+    liveRealtimeComments: '17855344750227125',
+    liveTypingIndicator: '17926314067024917',
+    mediaFeedback: '17877917527113814',
+    reactNativeOTA: '17861494672288167',
+    videoCallCoWatchControl: '17878679623388956',
+    videoCallInAlert: '17878679623388956',
+    videoCallPrototypePublish: '18031704190010162',
+    zeroProvision: '17913953740109069',
+};
+class GraphQLSubscriptions {
+    static formatSubscriptionString(queryId, inputParams, clientLogged) {
+        return `1/graphqlsubscriptions/${queryId}/${JSON.stringify({
+            input_data: inputParams,
+            ...(clientLogged ? { '%options': { client_logged: clientLogged } } : {}),
+        })}`;
+    }
+}
+exports.GraphQLSubscriptions = GraphQLSubscriptions;
+GraphQLSubscriptions.getAppPresenceSubscription = (options = {}) => GraphQLSubscriptions.formatSubscriptionString(exports.QueryIDs.appPresence, {
+    client_subscription_id: options.subscriptionId || new Chance().guid({ version: 4 }),
+}, options.clientLogged);
+GraphQLSubscriptions.getAsyncAdSubscription = (userId, options = {}) => GraphQLSubscriptions.formatSubscriptionString(exports.QueryIDs.asyncAdSub, {
+    client_subscription_id: options.subscriptionId || new Chance().guid({ version: 4 }),
+    user_id: userId,
+}, options.clientLogged);
+GraphQLSubscriptions.getClientConfigUpdateSubscription = (options = {}) => GraphQLSubscriptions.formatSubscriptionString(exports.QueryIDs.clientConfigUpdate, {
+    client_subscription_id: options.subscriptionId || new Chance().guid({ version: 4 }),
+}, options.clientLogged);
+GraphQLSubscriptions.getDirectStatusSubscription = (options = {}) => GraphQLSubscriptions.formatSubscriptionString(exports.QueryIDs.directStatus, {
+    client_subscription_id: options.subscriptionId || new Chance().guid({ version: 4 }),
+}, options.clientLogged);
+GraphQLSubscriptions.getDirectTypingSubscription = (userId, clientLogged) => GraphQLSubscriptions.formatSubscriptionString(exports.QueryIDs.directTyping, {
+    user_id: userId,
+}, clientLogged);
+GraphQLSubscriptions.getIgLiveWaveSubscription = (broadcastId, receiverId, options = {}) => GraphQLSubscriptions.formatSubscriptionString(exports.QueryIDs.liveWave, {
+    client_subscription_id: options.subscriptionId || new Chance().guid({ version: 4 }),
+    broadcast_id: broadcastId,
+    receiver_id: receiverId,
+}, options.clientLogged);
+GraphQLSubscriptions.getInteractivityActivateQuestionSubscription = (broadcastId, options = {}) => GraphQLSubscriptions.formatSubscriptionString(exports.QueryIDs.interactivityActivateQuestion, {
+    client_subscription_id: options.subscriptionId || new Chance().guid({ version: 4 }),
+    broadcast_id: broadcastId,
+}, options.clientLogged);
+GraphQLSubscriptions.getInteractivityRealtimeQuestionSubmissionsStatusSubscription = (broadcastId, options = {}) => GraphQLSubscriptions.formatSubscriptionString(exports.QueryIDs.interactivityRealtimeQuestionSubmissionsStatus, {
+    client_subscription_id: options.subscriptionId || new Chance().guid({ version: 4 }),
+    broadcast_id: broadcastId,
+}, options.clientLogged);
+GraphQLSubscriptions.getInteractivitySubscription = (broadcastId, options = {}) => GraphQLSubscriptions.formatSubscriptionString(exports.QueryIDs.interactivitySub, {
+    client_subscription_id: options.subscriptionId || new Chance().guid({ version: 4 }),
+    broadcast_id: broadcastId,
+}, options.clientLogged);
+GraphQLSubscriptions.getLiveRealtimeCommentsSubscription = (broadcastId, options = {}) => GraphQLSubscriptions.formatSubscriptionString(exports.QueryIDs.liveRealtimeComments, {
+    client_subscription_id: options.subscriptionId || new Chance().guid({ version: 4 }),
+    broadcast_id: broadcastId,
+}, options.clientLogged);
+GraphQLSubscriptions.getLiveTypingIndicatorSubscription = (broadcastId, options = {}) => GraphQLSubscriptions.formatSubscriptionString(exports.QueryIDs.liveTypingIndicator, {
+    client_subscription_id: options.subscriptionId || new Chance().guid({ version: 4 }),
+    broadcast_id: broadcastId,
+}, options.clientLogged);
+GraphQLSubscriptions.getMediaFeedbackSubscription = (feedbackId, options = {}) => GraphQLSubscriptions.formatSubscriptionString(exports.QueryIDs.mediaFeedback, {
+    client_subscription_id: options.subscriptionId || new Chance().guid({ version: 4 }),
+    feedback_id: feedbackId,
+}, options.clientLogged);
+GraphQLSubscriptions.getReactNativeOTAUpdateSubscription = (buildNumber, options = {}) => GraphQLSubscriptions.formatSubscriptionString(exports.QueryIDs.reactNativeOTA, {
+    client_subscription_id: options.subscriptionId || new Chance().guid({ version: 4 }),
+    build_number: buildNumber,
+}, options.clientLogged);
+GraphQLSubscriptions.getVideoCallCoWatchControlSubscription = (videoCallId, options = {}) => GraphQLSubscriptions.formatSubscriptionString(exports.QueryIDs.videoCallCoWatchControl, {
+    client_subscription_id: options.subscriptionId || new Chance().guid({ version: 4 }),
+    video_call_id: videoCallId,
+}, options.clientLogged);
+GraphQLSubscriptions.getVideoCallInCallAlertSubscription = (videoCallId, options = {}) => GraphQLSubscriptions.formatSubscriptionString(exports.QueryIDs.videoCallInAlert, {
+    client_subscription_id: options.subscriptionId || new Chance().guid({ version: 4 }),
+    video_call_id: videoCallId,
+}, options.clientLogged);
+GraphQLSubscriptions.getVideoCallPrototypePublishSubscription = (videoCallId, options = {}) => GraphQLSubscriptions.formatSubscriptionString(exports.QueryIDs.videoCallPrototypePublish, {
+    client_subscription_id: options.subscriptionId || new Chance().guid({ version: 4 }),
+    video_call_id: videoCallId,
+}, options.clientLogged);
+GraphQLSubscriptions.getZeroProvisionSubscription = (deviceId, options = {}) => GraphQLSubscriptions.formatSubscriptionString(exports.QueryIDs.zeroProvision, {
+    client_subscription_id: options.subscriptionId || new Chance().guid({ version: 4 }),
+    device_id: deviceId,
+}, options.clientLogged);