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

package/dist-ts/dist/repositories/direct-thread.repository.js

@@ -0,0 +1,423 @@
+const Repository = require('../core/repository');
+const Chance = require('chance');
+class DirectThreadRepository extends Repository {
+    constructor(client) {
+        super(client);
+        this.maxRetries = 3; // default max retries for requests
+    }
+    /**
+     * Generic request wrapper with retry and debug logging
+     * @param {Function} requestFn - async function performing request
+     * @param {number} retries - current retry count
+     */
+    async requestWithRetry(requestFn, retries = 0) {
+        var _a, _b, _c;
+        try {
+            if (process.env.DEBUG)
+                console.log(`[DEBUG] Attempt #${retries + 1}`);
+            const result = await requestFn();
+            return result;
+        }
+        catch (error) {
+            const shouldRetry = (((_a = error.data) === null || _a === void 0 ? void 0 : _a.error_type) === 'server_error' ||
+                ((_b = error.data) === null || _b === void 0 ? void 0 : _b.error_type) === 'rate_limited' ||
+                error.name === 'IgActionSpamError' ||
+                error.status === 503 ||
+                error.status === 429) &&
+                retries < this.maxRetries;
+            if (shouldRetry) {
+                const delay = 1000 * (retries + 1);
+                if (process.env.DEBUG)
+                    console.log(`[DEBUG] Retrying after ${delay}ms due to ${((_c = error.data) === null || _c === void 0 ? void 0 : _c.error_type) || error.message || error.name || error.status}`);
+                await new Promise(resolve => setTimeout(resolve, delay));
+                return this.requestWithRetry(requestFn, retries + 1);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Send a text message to a group thread
+     * @param {Object} options - { threadId, message }
+     */
+    async sendToGroup(options) {
+        const { threadId, message } = options;
+        if (!threadId || !message)
+            throw new Error('threadId and message are required');
+        return this.broadcast({
+            threadIds: [threadId],
+            item: 'text',
+            form: { text: message },
+        });
+    }
+    /**
+     * Fetch a specific thread by its ID
+     * @param {string} threadId
+     */
+    async getThread(threadId) {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'GET',
+                url: `/api/v1/direct_v2/threads/${threadId}/`,
+            });
+            return response.body || response.data || response;
+        });
+    }
+    /**
+     * Fetch threads by participants
+     * @param {Array} recipientUsers
+     */
+    async getByParticipants(recipientUsers) {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'GET',
+                url: '/api/v1/direct_v2/threads/get_by_participants/',
+                qs: { recipient_users: JSON.stringify(recipientUsers) },
+            });
+            return response.body || response.data || response;
+        });
+    }
+    /**
+     * Broadcast a message to multiple threads or users
+     */
+    async broadcast(options) {
+        const mutationToken = new Chance().guid();
+        const recipients = options.threadIds || options.userIds;
+        const recipientsType = options.threadIds ? 'thread_ids' : 'recipient_users';
+        const recipientsIds = Array.isArray(recipients) ? recipients : [recipients];
+        const recipientsValue = recipientsType === 'thread_ids'
+            ? JSON.stringify(recipientsIds)
+            : JSON.stringify([recipientsIds]);
+        const form = {
+            action: 'send_item',
+            [recipientsType]: recipientsValue,
+            client_context: mutationToken,
+            _csrftoken: this.client.state.cookieCsrfToken,
+            device_id: this.client.state.deviceId,
+            mutation_token: mutationToken,
+            _uuid: this.client.state.uuid,
+            ...options.form,
+        };
+        return this.requestWithRetry(async () => {
+            const payloadForm = options.signed && this.client.request && typeof this.client.request.sign === 'function'
+                ? this.client.request.sign(form)
+                : form;
+            const response = await this.client.request.send({
+                url: `/api/v1/direct_v2/threads/broadcast/${options.item}/`,
+                method: 'POST',
+                form: payloadForm,
+                qs: options.qs,
+            });
+            return response.body || response.data || response;
+        });
+    }
+    /**
+     * Broadcast a photo to one or more threads (uses REST configure_photo)
+     * Options:
+     *  - uploadId (required) : upload_id returned from rupload
+     *  - threadIds or threadId (required) : target thread id(s)
+     *  - caption (optional) : caption/text to attach
+     *  - signed (optional, default true) : whether to sign the form (if client.request.sign available)
+     */
+    async broadcastPhoto(options) {
+        // normalize inputs
+        const uploadId = options.uploadId || options.upload_id || options.uploadIdStr;
+        const threadIds = options.threadIds || (options.threadId ? [options.threadId] : []);
+        const caption = options.caption || options.text || '';
+        const signed = (options.signed === undefined) ? true : !!options.signed; // default to true for media
+        const mutationToken = new Chance().guid();
+        const clientContext = mutationToken;
+        if (!uploadId)
+            throw new Error('broadcastPhoto: uploadId is required');
+        if (!threadIds || !Array.isArray(threadIds) || threadIds.length === 0)
+            throw new Error('broadcastPhoto: at least one threadId is required');
+        const form = {
+            action: 'send_item',
+            upload_id: uploadId.toString(),
+            thread_ids: JSON.stringify(threadIds),
+            client_context: clientContext,
+            _csrftoken: this.client.state.cookieCsrfToken,
+            mutation_token: mutationToken,
+            offline_threading_id: clientContext,
+            device_id: this.client.state.deviceId,
+            _uuid: this.client.state.uuid,
+        };
+        if (caption) {
+            // Instagram often expects 'text' for the message body
+            form.text = caption;
+        }
+        // perform request with retry wrapper
+        return this.requestWithRetry(async () => {
+            const payloadForm = (signed && this.client.request && typeof this.client.request.sign === 'function')
+                ? this.client.request.sign(form)
+                : form;
+            const response = await this.client.request.send({
+                url: `/api/v1/direct_v2/threads/broadcast/configure_photo/`,
+                method: 'POST',
+                form: payloadForm,
+                qs: {
+                    use_unified_inbox: true,
+                },
+            });
+            // normalize: some wrappers return { body } or axios response
+            const body = response && (response.body || response.data || response);
+            if (!body) {
+                const err = new Error('broadcastPhoto: empty response');
+                throw err;
+            }
+            // parse if string
+            let parsed = null;
+            if (typeof body === 'string') {
+                try {
+                    parsed = JSON.parse(body);
+                }
+                catch (e) {
+                    parsed = null;
+                }
+            }
+            else if (typeof body === 'object') {
+                parsed = body;
+            }
+            // Typical success: parsed.status === 'ok' OR parsed.media/parsed.result/payload present
+            const ok = parsed && (parsed.status === 'ok' || parsed.media || parsed.result || parsed.payload || parsed.items || parsed.thread);
+            if (ok)
+                return parsed;
+            // If we reach here, treat as error to trigger retry logic
+            const error = new Error('broadcastPhoto: Request failed');
+            error.response = response;
+            if (parsed)
+                error.data = parsed;
+            throw error;
+        });
+    }
+    /**
+     * Broadcast a raven (view-once/ephemeral) attachment to one or more threads via REST.
+     * IMPORTANT: Media must be uploaded to rupload.facebook.com/messenger_image/ first!
+     * Uses endpoint: /api/v1/direct_v2/threads/broadcast/raven_attachment/
+     *
+     * Options:
+     *  - uploadId (required): upload_id from messenger_image rupload
+     *  - attachmentFbid (optional): media_id from messenger_image upload response
+     *  - threadIds or threadId (required): target thread id(s)
+     *  - viewMode (optional, default 'replayable'): 'once' or 'replayable'
+     *  - mediaType (optional, default '1'): '1' = photo, '2' = video
+     */
+    async broadcastRaven(options) {
+        var _a, _b, _c, _d;
+        const uploadId = options.uploadId || options.upload_id;
+        const threadIds = options.threadIds || (options.threadId ? [options.threadId] : []);
+        const viewMode = options.viewMode || 'replayable';
+        const mediaType = String(options.mediaType || '1');
+        const attachmentFbid = options.attachmentFbid || options.attachment_fbid || null;
+        if (!uploadId)
+            throw new Error('broadcastRaven: uploadId is required');
+        if (!threadIds || !Array.isArray(threadIds) || threadIds.length === 0)
+            throw new Error('broadcastRaven: at least one threadId is required');
+        const { v4: uuidv4 } = require('uuid');
+        const clientContext = BigInt(Math.floor(Math.random() * 2 ** 62)).toString();
+        const now = Math.floor(Date.now() / 1000);
+        const form = {
+            allow_multi_configures: '1',
+            recipient_users: '[]',
+            view_mode: viewMode,
+            is_shh_mode: '0',
+            camera_entry_point: '3',
+            thread_ids: JSON.stringify(threadIds.map(String)),
+            reshare_mode: 'allow_reshare',
+            original_media_type: mediaType,
+            send_attribution: 'direct_thread_camera',
+            client_context: clientContext,
+            camera_session_id: uuidv4(),
+            include_e2ee_mentioned_user_list: '1',
+            hide_from_profile_grid: 'false',
+            scene_capture_type: '',
+            timezone_offset: String(new Date().getTimezoneOffset() * -60),
+            client_shared_at: String(now),
+            configure_mode: '2',
+            source_type: '4',
+            camera_position: 'unknown',
+            _uid: String(this.client.state.cookieUserId || this.client.state.igUserId),
+            device_id: this.client.state.deviceId,
+            composition_id: uuidv4(),
+            mutation_token: clientContext,
+            _uuid: this.client.state.uuid,
+            creation_tool_info: '[]',
+            creation_surface: 'camera',
+            capture_type: 'normal',
+            audience: 'default',
+            upload_id: uploadId.toString(),
+            client_timestamp: String(now),
+            sampled: 'true',
+            media_transformation_info: JSON.stringify({
+                width: '720', height: '1280',
+                x_transform: '0', y_transform: '0',
+                zoom: '1.0', rotation: '0.0', background_coverage: '0.0',
+            }),
+            edits: JSON.stringify({ filter_type: 0, filter_strength: 0.5, crop_original_size: [720.0, 1280.0] }),
+            extra: JSON.stringify({ source_width: 720, source_height: 1280 }),
+            device: JSON.stringify({
+                manufacturer: ((_a = this.client.state.devicePayload) === null || _a === void 0 ? void 0 : _a.manufacturer) || 'samsung',
+                model: ((_b = this.client.state.devicePayload) === null || _b === void 0 ? void 0 : _b.model) || 'SM-S938B',
+                android_version: ((_c = this.client.state.devicePayload) === null || _c === void 0 ? void 0 : _c.android_version) || 35,
+                android_release: ((_d = this.client.state.devicePayload) === null || _d === void 0 ? void 0 : _d.android_release) || '15',
+            }),
+        };
+        if (attachmentFbid) {
+            form.attachment_fbid = String(attachmentFbid);
+        }
+        return this.requestWithRetry(async () => {
+            const payloadForm = (this.client.request && typeof this.client.request.sign === 'function')
+                ? this.client.request.sign(form)
+                : form;
+            const response = await this.client.request.send({
+                url: `/api/v1/direct_v2/threads/broadcast/raven_attachment/`,
+                method: 'POST',
+                form: payloadForm,
+                qs: {
+                    use_unified_inbox: true,
+                },
+            });
+            const body = response && (response.body || response.data || response);
+            if (!body) {
+                throw new Error('broadcastRaven: empty response');
+            }
+            let parsed = null;
+            if (typeof body === 'string') {
+                try {
+                    parsed = JSON.parse(body);
+                }
+                catch (e) {
+                    parsed = null;
+                }
+            }
+            else if (typeof body === 'object') {
+                parsed = body;
+            }
+            const ok = parsed && (parsed.status === 'ok' || parsed.media || parsed.result || parsed.payload || parsed.items || parsed.thread);
+            if (ok)
+                return parsed;
+            const error = new Error('broadcastRaven: Request failed');
+            error.response = response;
+            if (parsed)
+                error.data = parsed;
+            throw error;
+        });
+    }
+    /**
+     * Mark a specific item in a thread as seen
+     */
+    async markItemSeen(threadId, threadItemId) {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                url: `/api/v1/direct_v2/threads/${threadId}/items/${threadItemId}/seen/`,
+                method: 'POST',
+                form: {
+                    _uuid: this.client.state.uuid,
+                    use_unified_inbox: true,
+                    action: 'mark_seen',
+                    thread_id: threadId,
+                    item_id: threadItemId,
+                },
+            });
+            return response.body || response.data || response;
+        });
+    }
+    /**
+     * Delete an item from a thread
+     */
+    async deleteItem(threadId, itemId) {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                url: `/api/v1/direct_v2/threads/${threadId}/items/${itemId}/delete/`,
+                method: 'POST',
+            });
+            return response.body || response.data || response;
+        });
+    }
+    /**
+     * Approve a pending thread
+     */
+    async approve(threadId) {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                url: `/api/v1/direct_v2/threads/${threadId}/approve/`,
+                method: 'POST',
+            });
+            return response.body || response.data || response;
+        });
+    }
+    /**
+     * Decline a pending thread
+     */
+    async decline(threadId) {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                url: `/api/v1/direct_v2/threads/${threadId}/decline/`,
+                method: 'POST',
+            });
+            return response.body || response.data || response;
+        });
+    }
+    /**
+     * Mute a thread
+     */
+    async mute(threadId) {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                url: `/api/v1/direct_v2/threads/${threadId}/mute/`,
+                method: 'POST',
+            });
+            return response.body || response.data || response;
+        });
+    }
+    /**
+     * Unmute a thread
+     */
+    async unmute(threadId) {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                url: `/api/v1/direct_v2/threads/${threadId}/unmute/`,
+                method: 'POST',
+            });
+            return response.body || response.data || response;
+        });
+    }
+    /**
+     * Add users to a thread
+     */
+    async addUser(threadId, userIds) {
+        if (!Array.isArray(userIds))
+            throw new Error('userIds must be an array');
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                url: `/api/v1/direct_v2/threads/${threadId}/add_user/`,
+                method: 'POST',
+            });
+            return response.body || response.data || response;
+        });
+    }
+    /**
+     * Leave a thread
+     */
+    async leave(threadId) {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                url: `/api/v1/direct_v2/threads/${threadId}/leave/`,
+                method: 'POST',
+            });
+            return response.body || response.data || response;
+        });
+    }
+    /**
+     * Update thread title
+     */
+    async updateTitle(threadId, title) {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                url: `/api/v1/direct_v2/threads/${threadId}/update_title/`,
+                method: 'POST',
+            });
+            return response.body || response.data || response;
+        });
+    }
+}
+module.exports = DirectThreadRepository;

package/dist-ts/dist/repositories/direct.repository.js

@@ -0,0 +1,246 @@
+const Repository = require('../core/repository');
+const fs = require('fs');
+class DirectRepository extends Repository {
+    constructor(client) {
+        super(client);
+        this.maxRetries = 3;
+    }
+    async requestWithRetry(requestFn, retries = 0) {
+        var _a, _b, _c, _d, _e, _f;
+        try {
+            const result = await requestFn();
+            return result;
+        }
+        catch (error) {
+            const errorCode = ((_b = (_a = error.data) === null || _a === void 0 ? void 0 : _a.content) === null || _b === void 0 ? void 0 : _b.error_code) || ((_c = error.data) === null || _c === void 0 ? void 0 : _c.error_code);
+            const errorType = (_d = error.data) === null || _d === void 0 ? void 0 : _d.error_type;
+            const statusCode = error.status || ((_e = error.data) === null || _e === void 0 ? void 0 : _e.status_code);
+            const isPromptContribution = errorCode === 4415001;
+            const isAuthIssue = statusCode === 400 && isPromptContribution;
+            const isServerError = errorType === 'server_error';
+            const isRateLimited = errorType === 'rate_limited';
+            const isLoginRequired = ((_f = error.data) === null || _f === void 0 ? void 0 : _f.message) === 'login_required' || errorType === 'login_required';
+            if ((isAuthIssue || isLoginRequired) && retries < this.maxRetries) {
+                try {
+                    if (this.client.state.authorization) {
+                        this.client.state.updateAuthorization();
+                    }
+                    if (this.client.account && typeof this.client.account.syncPostLoginExperiments === 'function') {
+                        await this.client.account.syncPostLoginExperiments().catch(() => { });
+                    }
+                }
+                catch (syncErr) { }
+                const delay = 2000 * (retries + 1);
+                await new Promise(resolve => setTimeout(resolve, delay));
+                return this.requestWithRetry(requestFn, retries + 1);
+            }
+            const shouldRetry = (isServerError || isRateLimited) && retries < this.maxRetries;
+            if (shouldRetry) {
+                const delay = 1000 * (retries + 1);
+                await new Promise(resolve => setTimeout(resolve, delay));
+                return this.requestWithRetry(requestFn, retries + 1);
+            }
+            throw error;
+        }
+    }
+    async send(options) {
+        const { to, message } = options;
+        if (!to || !message)
+            throw new Error('Recipient (to) and message are required');
+        return this.requestWithRetry(async () => {
+            const user = await this.client.user.infoByUsername(to);
+            const thread = await this.client.directThread.getByParticipants([user.pk]);
+            return this.client.directThread.broadcast({
+                threadIds: [thread.thread_id],
+                item: 'text',
+                form: { text: message },
+            });
+        });
+    }
+    async sendToUserId(userId, message) {
+        return this.requestWithRetry(async () => {
+            return this.client.directThread.broadcast({
+                userIds: [userId],
+                item: 'text',
+                form: { text: message },
+            });
+        });
+    }
+    async sendImage(options) {
+        const { to, imagePath } = options;
+        if (!to || !imagePath)
+            throw new Error('Recipient (to) and imagePath are required');
+        return this.requestWithRetry(async () => {
+            const imageBuffer = fs.readFileSync(imagePath);
+            const uploadResult = await this.client.upload.photo({ file: imageBuffer, uploadId: Date.now() });
+            const user = await this.client.user.infoByUsername(to);
+            const thread = await this.client.directThread.getByParticipants([user.pk]);
+            return this.client.directThread.broadcast({
+                threadIds: [thread.thread_id],
+                item: 'configure_photo',
+                form: { upload_id: uploadResult.upload_id, allow_full_aspect_ratio: true },
+            });
+        });
+    }
+    async sendVideo(options) {
+        const { to, videoPath } = options;
+        if (!to || !videoPath)
+            throw new Error('Recipient (to) and videoPath are required');
+        return this.requestWithRetry(async () => {
+            const videoBuffer = fs.readFileSync(videoPath);
+            const uploadResult = await this.client.upload.video({ video: videoBuffer, uploadId: Date.now() });
+            const user = await this.client.user.infoByUsername(to);
+            const thread = await this.client.directThread.getByParticipants([user.pk]);
+            return this.client.directThread.broadcast({
+                threadIds: [thread.thread_id],
+                item: 'configure_video',
+                form: { upload_id: uploadResult.upload_id, video_result: 'deprecated' },
+            });
+        });
+    }
+    async sendLink(options) {
+        const { to, text, urls } = options;
+        return this.requestWithRetry(async () => {
+            const user = await this.client.user.infoByUsername(to);
+            const thread = await this.client.directThread.getByParticipants([user.pk]);
+            return this.client.directThread.broadcast({
+                threadIds: [thread.thread_id],
+                item: 'link',
+                form: {
+                    link_text: text || '',
+                    link_urls: JSON.stringify(urls || []),
+                },
+            });
+        });
+    }
+    async sendMediaShare(options) {
+        const { to, mediaId } = options;
+        return this.requestWithRetry(async () => {
+            const user = await this.client.user.infoByUsername(to);
+            const thread = await this.client.directThread.getByParticipants([user.pk]);
+            return this.client.directThread.broadcast({
+                threadIds: [thread.thread_id],
+                item: 'media_share',
+                form: { media_id: mediaId },
+            });
+        });
+    }
+    async sendProfile(options) {
+        const { to, profileUserId } = options;
+        return this.requestWithRetry(async () => {
+            const user = await this.client.user.infoByUsername(to);
+            const thread = await this.client.directThread.getByParticipants([user.pk]);
+            return this.client.directThread.broadcast({
+                threadIds: [thread.thread_id],
+                item: 'profile',
+                form: { profile_user_id: profileUserId },
+            });
+        });
+    }
+    async sendHashtag(options) {
+        const { to, hashtag, text } = options;
+        return this.requestWithRetry(async () => {
+            const user = await this.client.user.infoByUsername(to);
+            const thread = await this.client.directThread.getByParticipants([user.pk]);
+            return this.client.directThread.broadcast({
+                threadIds: [thread.thread_id],
+                item: 'hashtag',
+                form: {
+                    hashtag,
+                    text: text || '',
+                },
+            });
+        });
+    }
+    async sendLocation(options) {
+        const { to, locationId, text } = options;
+        return this.requestWithRetry(async () => {
+            const user = await this.client.user.infoByUsername(to);
+            const thread = await this.client.directThread.getByParticipants([user.pk]);
+            return this.client.directThread.broadcast({
+                threadIds: [thread.thread_id],
+                item: 'location',
+                form: {
+                    venue_id: locationId,
+                    text: text || '',
+                },
+            });
+        });
+    }
+    async getInbox(cursor = null, limit = 20) {
+        if (!this.client.state.authorization) {
+            throw new Error('Not authenticated. Please login first before accessing inbox.');
+        }
+        const userId = this.client.state.cookieUserId || this.client.state._userId;
+        if (!userId || userId === '0' || userId === 0) {
+            this.client.state.updateAuthorization();
+            if (this.client.state.parsedAuthorization && this.client.state.parsedAuthorization.ds_user_id) {
+                this.client.state._userId = this.client.state.parsedAuthorization.ds_user_id;
+                this.client.state.cookieUserId = this.client.state.parsedAuthorization.ds_user_id;
+            }
+        }
+        return this.requestWithRetry(async () => {
+            const qs = { persistentBadging: true, limit };
+            if (cursor)
+                qs.cursor = cursor;
+            const response = await this.client.request.send({ method: 'GET', url: '/api/v1/direct_v2/inbox/', qs });
+            return response.body;
+        });
+    }
+    async getPendingInbox(cursor = null) {
+        return this.requestWithRetry(async () => {
+            const qs = cursor ? { cursor } : {};
+            const response = await this.client.request.send({ method: 'GET', url: '/api/v1/direct_v2/pending_inbox/', qs });
+            return response.body;
+        });
+    }
+    async createGroupThread(recipientUsers, threadTitle) {
+        if (!Array.isArray(recipientUsers) || !threadTitle)
+            throw new Error('recipientUsers must be array and threadTitle required');
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'POST',
+                url: '/api/v1/direct_v2/create_group_thread/',
+                form: this.client.request.sign({
+                    _uuid: this.client.state.uuid,
+                    _uid: this.client.state.cookieUserId,
+                    recipient_users: JSON.stringify(recipientUsers),
+                    thread_title: threadTitle,
+                }),
+            });
+            return response.body;
+        });
+    }
+    async rankedRecipients(mode = 'raven', query = '') {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'GET',
+                url: '/api/v1/direct_v2/ranked_recipients/',
+                qs: { mode, query, show_threads: true },
+            });
+            return response.body;
+        });
+    }
+    async getPresence() {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({ method: 'GET', url: '/api/v1/direct_v2/get_presence/' });
+            return response.body;
+        });
+    }
+    async markAsSeen(threadId, itemId) {
+        return this.client.directThread.markItemSeen(threadId, itemId);
+    }
+    async hideThread(threadId) {
+        return this.requestWithRetry(async () => {
+            const response = await this.client.request.send({
+                method: 'POST',
+                url: `/api/v1/direct_v2/threads/${threadId}/hide/`,
+                form: this.client.request.sign({
+                    _uuid: this.client.state.uuid,
+                }),
+            });
+            return response.body;
+        });
+    }
+}
+module.exports = DirectRepository;