@youmind-openlab/rettiwt-api 1.0.0

package/dist/services/public/UserService.js

@@ -0,0 +1,920 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserService = void 0;
+const Extractors_1 = require("../../collections/Extractors");
+const Analytics_1 = require("../../enums/raw/Analytics");
+const Resource_1 = require("../../enums/Resource");
+const ProfileArgs_1 = require("../../models/args/ProfileArgs");
+const FetcherService_1 = require("./FetcherService");
+/**
+ * Handles interacting with resources related to user account
+ *
+ * @public
+ */
+class UserService extends FetcherService_1.FetcherService {
+    /**
+     * @param config - The config object for configuring the Rettiwt instance.
+     *
+     * @internal
+     */
+    constructor(config) {
+        super(config);
+    }
+    /**
+     * Get the list affiliates of a user.
+     *
+     * @param id - The ID of the target user. If no id is provided, the logged-in user's id is used.
+     * @param count - The number of affiliates to fetch, must be \<= 100.
+     * @param cursor - The cursor to the batch of affiliates to fetch.
+     *
+     * @returns The list of users affiliated to the target user.
+     *
+     * @example
+     *
+     * ```ts
+     * import { Rettiwt } from 'rettiwt-api';
+     *
+     * // Creating a new Rettiwt instance using the given 'API_KEY'
+     * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+     *
+     * // Fetching the first 100 affiliates of the User with id '1234567890'
+     * rettiwt.user.affiliates('1234567890')
+     * .then(res => {
+     * 	console.log(res);
+     * })
+     * .catch(err => {
+     * 	console.log(err);
+     * });
+     * ```
+     */
+    async affiliates(id, count, cursor) {
+        const resource = Resource_1.ResourceType.USER_AFFILIATES;
+        // Fetching raw list of affiliates
+        const response = await this.request(resource, {
+            id: id ?? this.config.userId,
+            count: count,
+            cursor: cursor,
+        });
+        // Deserializing response
+        const data = Extractors_1.Extractors[resource](response);
+        return data;
+    }
+    /**
+     * Get the analytics overview of the logged in user.
+     *
+     * @param fromTime - The start time of the analytics period. Defaults to 7 days ago.
+     * @param toTime - The end time of the analytics period. Defaults to now.
+     * @param granularity - The granularity of the analytics data. Defaults to daily.
+     * @param metrics - The metrics to include in the analytics data. Defaults to all available metrics available.
+     * @param showVerifiedFollowers - Whether to include verified follower count and relationship counts in the response. Defaults to true.
+     *
+     * @returns The raw analytics data of the user.
+     *
+     * @example
+     *
+     * ```ts
+     * import { Rettiwt } from 'rettiwt-api';
+     *
+     * // Creating a new Rettiwt instance using the given 'API_KEY'
+     * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+     *
+     * // Fetching the analytics overview of the logged in user
+     * rettiwt.user.analytics().then(res => {
+     *  console.log(res);
+     * })
+     * .catch(err => {
+     * 	console.log(err);
+     * });
+     * ```
+     */
+    async analytics(fromTime, toTime, granularity, metrics, showVerifiedFollowers) {
+        const resource = Resource_1.ResourceType.USER_ANALYTICS;
+        // Define default values if not provided
+        fromTime = fromTime ?? new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+        toTime = toTime ?? new Date();
+        granularity = granularity ?? Analytics_1.RawAnalyticsGranularity.DAILY;
+        metrics = metrics ?? Object.values(Analytics_1.RawAnalyticsMetric);
+        showVerifiedFollowers = showVerifiedFollowers ?? true;
+        // Fetching raw analytics
+        const response = await this.request(resource, {
+            fromTime,
+            toTime,
+            granularity,
+            metrics,
+            showVerifiedFollowers,
+        });
+        const data = Extractors_1.Extractors[resource](response);
+        return data;
+    }
+    /**
+     * Get the list of tweets in a specific bookmark folder of the logged in user.
+     *
+     * @param folderId - The ID of the bookmark folder.
+     * @param count - The number of tweets to fetch, must be \<= 100.
+     * @param cursor - The cursor to the batch of tweets to fetch.
+     *
+     * @returns The list of tweets in the bookmark folder.
+     *
+     * @example
+     *
+     * ```ts
+     * import { Rettiwt } from 'rettiwt-api';
+     *
+     * // Creating a new Rettiwt instance using the given 'API_KEY'
+     * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+     *
+     * // Fetching the first 100 tweets from bookmark folder with ID '2001752149647049173'
+     * rettiwt.user.bookmarkFolderTweets('2001752149647049173')
+     * .then(res => {
+     * 	console.log(res);
+     * })
+     * .catch(err => {
+     * 	console.log(err);
+     * });
+     * ```
+     */
+    async bookmarkFolderTweets(folderId, count, cursor) {
+        const resource = Resource_1.ResourceType.USER_BOOKMARK_FOLDER_TWEETS;
+        // Fetching raw list of tweets from folder
+        const response = await this.request(resource, {
+            id: folderId,
+            count: count,
+            cursor: cursor,
+        });
+        // Deserializing response
+        const data = Extractors_1.Extractors[resource](response);
+        return data;
+    }
+    /**
+     * Get the list of bookmark folders of the logged in user.
+     *
+     * @param cursor - The cursor to the batch of bookmark folders to fetch.
+     *
+     * @returns The list of bookmark folders.
+     *
+     * @example
+     *
+     * ```ts
+     * import { Rettiwt } from 'rettiwt-api';
+     *
+     * // Creating a new Rettiwt instance using the given 'API_KEY'
+     * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+     *
+     * // Fetching all bookmark folders of the logged in user
+     * rettiwt.user.bookmarkFolders()
+     * .then(res => {
+     * 	console.log(res);
+     * })
+     * .catch(err => {
+     * 	console.log(err);
+     * });
+     * ```
+     */
+    async bookmarkFolders(cursor) {
+        const resource = Resource_1.ResourceType.USER_BOOKMARK_FOLDERS;
+        // Fetching raw list of bookmark folders
+        const response = await this.request(resource, {
+            cursor: cursor,
+        });
+        // Deserializing response
+        const data = Extractors_1.Extractors[resource](response);
+        return data;
+    }
+    /**
+     * Get the list of bookmarks of the logged in user.
+     *
+     * @param count - The number of bookmakrs to fetch, must be \<= 100.
+     * @param cursor - The cursor to the batch of bookmarks to fetch.
+     *
+     * @returns The list of tweets bookmarked by the target user.
+     *
+     * @example
+     *
+     * ```ts
+     * import { Rettiwt } from 'rettiwt-api';
+     *
+     * // Creating a new Rettiwt instance using the given 'API_KEY'
+     * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+     *
+     * // Fetching the most recent 100 liked Tweets of the logged in User
+     * rettiwt.user.bookmarks()
+     * .then(res => {
+     * 	console.log(res);
+     * })
+     * .catch(err => {
+     * 	console.log(err);
+     * });
+     * ```
+     */
+    async bookmarks(count, cursor) {
+        const resource = Resource_1.ResourceType.USER_BOOKMARKS;
+        // Fetching raw list of likes
+        const response = await this.request(resource, {
+            count: count,
+            cursor: cursor,
+        });
+        // Deserializing response
+        const data = Extractors_1.Extractors[resource](response);
+        return data;
+    }
+    async details(id) {
+        let resource;
+        // If details of multiple users required
+        if (Array.isArray(id)) {
+            resource = Resource_1.ResourceType.USER_DETAILS_BY_IDS_BULK;
+            // Fetching raw details
+            const response = await this.request(resource, { ids: id });
+            // Deserializing response
+            const data = Extractors_1.Extractors[resource](response, id);
+            return data;
+        }
+        // If details of single user required
+        else {
+            // If username is given
+            if (id && isNaN(Number(id))) {
+                resource = Resource_1.ResourceType.USER_DETAILS_BY_USERNAME;
+                if (id?.startsWith('@')) {
+                    id = id.slice(1);
+                }
+            }
+            // If id is given (or not, for self details)
+            else {
+                resource = Resource_1.ResourceType.USER_DETAILS_BY_ID;
+            }
+            // If no ID is given, and not authenticated, skip
+            if (!id && !this.config.userId) {
+                return undefined;
+            }
+            // Fetching raw details
+            const response = await this.request(resource, { id: id ?? this.config.userId });
+            // Deserializing response
+            const data = Extractors_1.Extractors[resource](response);
+            return data;
+        }
+    }
+    /**
+     * Follow a user.
+     *
+     * @param id - The ID the user to be followed.
+     *
+     * @returns Whether following was successful or not.
+     *
+     * @throws Code 108 if given user id is invalid.
+     *
+     * @example
+     *
+     * ```ts
+     * import { Rettiwt } from 'rettiwt-api';
+     *
+     * // Creating a new Rettiwt instance using the given 'API_KEY'
+     * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+     *
+     * // Following the User with id '1234567890'
+     * rettiwt.user.follow('1234567890')
+     * .then(res => {
+     * 	console.log(res);
+     * })
+     * .catch(err => {
+     * 	console.log(err);
+     * });
+     * ```
+     */
+    async follow(id) {
+        const resource = Resource_1.ResourceType.USER_FOLLOW;
+        // Following the user
+        const response = await this.request(Resource_1.ResourceType.USER_FOLLOW, { id: id });
+        // Deserializing the response
+        const data = Extractors_1.Extractors[resource](response) ?? false;
+        return data;
+    }
+    /**
+     * Get the followed feed of the logged in user.
+     *
+     * @param cursor - The cursor to the batch of feed items to fetch.
+     *
+     * @returns - The followed feed of the logged-in user.
+     *
+     * @example
+     *
+     * ```ts
+     * import { Rettiwt } from 'rettiwt-api';
+     *
+     * // Creating a new Rettiwt instance using the given 'API_KEY'
+     * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+     *
+     * // Fetching the first 35 followed feed items of the logged-in user
+     * rettiwt.user.followed()
+     * .then(res => {
+     * 	console.log(res);
+     * })
+     * .catch(err => {
+     * 	console.log(err);
+     * });
+     * ```
+     *
+     * @remarks Always returns 35 feed items, with no way to customize the count.
+     */
+    async followed(cursor) {
+        const resource = Resource_1.ResourceType.USER_FEED_FOLLOWED;
+        // Fetching raw list of tweets
+        const response = await this.request(resource, {
+            cursor: cursor,
+        });
+        // Deserializing response
+        const data = Extractors_1.Extractors[resource](response);
+        return data;
+    }
+    /**
+     * Get the list followers of a user.
+     *
+     * @param id - The ID of the target user. If no ID is provided, the logged-in user's ID is used.
+     * @param count - The number of followers to fetch, must be \<= 100.
+     * @param cursor - The cursor to the batch of followers to fetch.
+     *
+     * @returns The list of users following the target user.
+     *
+     * @example
+     *
+     * ```ts
+     * import { Rettiwt } from 'rettiwt-api';
+     *
+     * // Creating a new Rettiwt instance using the given 'API_KEY'
+     * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+     *
+     * // Fetching the first 100 followers of the User with id '1234567890'
+     * rettiwt.user.followers('1234567890')
+     * .then(res => {
+     * 	console.log(res);
+     * })
+     * .catch(err => {
+     * 	console.log(err);
+     * });
+     * ```
+     */
+    async followers(id, count, cursor) {
+        const resource = Resource_1.ResourceType.USER_FOLLOWERS;
+        // Fetching raw list of followers
+        const response = await this.request(resource, {
+            id: id ?? this.config.userId,
+            count: count,
+            cursor: cursor,
+        });
+        // Deserializing response
+        const data = Extractors_1.Extractors[resource](response);
+        return data;
+    }
+    /**
+     * Get the list of users who are followed by a user.
+     *
+     * @param id - The ID of the target user. If no ID is provided, the logged-in user's ID is used.
+     * @param count - The number of following to fetch, must be \<= 100.
+     * @param cursor - The cursor to the batch of following to fetch.
+     *
+     * @returns The list of users followed by the target user.
+     *
+     * @example
+     *
+     * ```ts
+     * import { Rettiwt } from 'rettiwt-api';
+     *
+     * // Creating a new Rettiwt instance using the given 'API_KEY'
+     * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+     *
+     * // Fetching the first 100 following of the User with id '1234567890'
+     * rettiwt.user.following('1234567890')
+     * .then(res => {
+     * 	console.log(res);
+     * })
+     * .catch(err => {
+     * 	console.log(err);
+     * });
+     * ```
+     */
+    async following(id, count, cursor) {
+        const resource = Resource_1.ResourceType.USER_FOLLOWING;
+        // Fetching raw list of following
+        const response = await this.request(resource, {
+            id: id ?? this.config.userId,
+            count: count,
+            cursor: cursor,
+        });
+        // Deserializing response
+        const data = Extractors_1.Extractors[resource](response);
+        return data;
+    }
+    /**
+     * Get the highlighted tweets of a user.
+     *
+     * @param id - The ID of the target user. If no ID is provided, the logged-in user's ID is used.
+     * @param count - The number of followers to fetch, must be \<= 100.
+     * @param cursor - The cursor to the batch of followers to fetch.
+     *
+     * @returns The list of highlighted tweets of the target user.
+     *
+     * @example
+     *
+     * ```ts
+     * import { Rettiwt } from 'rettiwt-api';
+     *
+     * // Creating a new Rettiwt instance using the given 'API_KEY'
+     * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+     *
+     * // Fetching the top 100 highlights of the User with id '1234567890'
+     * rettiwt.user.highlights('1234567890')
+     * .then(res => {
+     * 	console.log(res);
+     * })
+     * .catch(err => {
+     * 	console.log(err);
+     * });
+     * ```
+     */
+    async highlights(id, count, cursor) {
+        const resource = Resource_1.ResourceType.USER_HIGHLIGHTS;
+        // Fetching raw list of highlights
+        const response = await this.request(resource, {
+            id: id ?? this.config.userId,
+            count: count,
+            cursor: cursor,
+        });
+        // Deserializing response
+        const data = Extractors_1.Extractors[resource](response);
+        return data;
+    }
+    /**
+     * Get the list of tweets liked by the logged in user.
+     *
+     * @param count - The number of likes to fetch, must be \<= 100.
+     * @param cursor - The cursor to the batch of likes to fetch.
+     *
+     * @returns The list of tweets liked by the target user.
+     *
+     * @example
+     *
+     * ```ts
+     * import { Rettiwt } from 'rettiwt-api';
+     *
+     * // Creating a new Rettiwt instance using the given 'API_KEY'
+     * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+     *
+     * // Fetching the most recent 100 liked Tweets of the logged in User
+     * rettiwt.user.likes()
+     * .then(res => {
+     * 	console.log(res);
+     * })
+     * .catch(err => {
+     * 	console.log(err);
+     * });
+     * ```
+     */
+    async likes(count, cursor) {
+        const resource = Resource_1.ResourceType.USER_LIKES;
+        // Fetching raw list of likes
+        const response = await this.request(resource, {
+            id: this.config.userId,
+            count: count,
+            cursor: cursor,
+        });
+        // Deserializing response
+        const data = Extractors_1.Extractors[resource](response);
+        return data;
+    }
+    /**
+     * Get the list of of the the logged in user. Includes both followed and owned.
+     *
+     * @param count - The number of lists to fetch, must be \<= 100.
+     * @param cursor - The cursor to the batch of likes to fetch.
+     *
+     * @returns The list of tweets liked by the target user.
+     *
+     * @example
+     *
+     * ```ts
+     * import { Rettiwt } from 'rettiwt-api';
+     *
+     * // Creating a new Rettiwt instance using the given 'API_KEY'
+     * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+     *
+     * // Fetching the first 100 Lists of the logged in User
+     * rettiwt.user.lists()
+     * .then(res => {
+     * 	console.log(res);
+     * })
+     * .catch(err => {
+     * 	console.log(err);
+     * });
+     * ```
+     */
+    async lists(count, cursor) {
+        const resource = Resource_1.ResourceType.USER_LISTS;
+        // Fetching raw list of lists
+        const response = await this.request(resource, {
+            id: this.config.userId,
+            count: count,
+            cursor: cursor,
+        });
+        // Deserializing response
+        const data = Extractors_1.Extractors[resource](response);
+        return data;
+    }
+    /**
+     * Get the media timeline of a user.
+     *
+     * @param id - The ID of the target user. If no ID is provided, the logged-in user's ID is used.
+     * @param count - The number of media to fetch, must be \<= 100.
+     * @param cursor - The cursor to the batch of media to fetch
+     *
+     * @returns The media timeline of the target user.
+     *
+     * @example
+     *
+     * ```ts
+     * import { Rettiwt } from 'rettiwt-api';
+     *
+     * // Creating a new Rettiwt instance using the given 'API_KEY'
+     * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+     *
+     * // Fetching the first 100 timeline media tweets of the User with id '1234567890'
+     * rettiwt.user.timeline('1234567890')
+     * .then(res => {
+     * 	console.log(res);
+     * })
+     * .catch(err => {
+     * 	console.log(err);
+     * });
+     * ```
+     */
+    async media(id, count, cursor) {
+        const resource = Resource_1.ResourceType.USER_MEDIA;
+        // Fetching raw list of media
+        const response = await this.request(resource, {
+            id: id ?? this.config.userId,
+            count: count,
+            cursor: cursor,
+        });
+        // Deserializing response
+        const data = Extractors_1.Extractors[resource](response);
+        return data;
+    }
+    /**
+     * Stream notifications of the logged in user in pseudo real-time.
+     *
+     * @param pollingInterval - The interval in milliseconds to poll for new tweets. Default interval is 60000 ms.
+     *
+     * @returns An async generator that yields new notifications as they are received.
+     *
+     * @example
+     *
+     * ```ts
+     * import { Rettiwt } from 'rettiwt-api';
+     *
+     * // Creating a new Rettiwt instance using the given 'API_KEY'
+     * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+     *
+     * // Creating a function that streams all new notifications
+     * async function streamNotifications() {
+     * 	try {
+     * 		// Awaiting for the notifications returned by the AsyncGenerator returned by the method
+     * 		for await (const notification of rettiwt.user.notifications(5000)) {
+     * 			console.log(notification.message);
+     * 		}
+     * 	}
+     * 	catch (err) {
+     * 		console.log(err);
+     * 	}
+     * }
+     *
+     * // Calling the function
+     * streamNotifications();
+     * ```
+     */
+    async *notifications(pollingInterval = 60000) {
+        const resource = Resource_1.ResourceType.USER_NOTIFICATIONS;
+        /** Whether it's the first batch of notifications or not. */
+        let first = true;
+        /** The cursor to the last notification received. */
+        let cursor = undefined;
+        while (true) {
+            // Pause execution for the specified polling interval before proceeding to the next iteration
+            await new Promise((resolve) => setTimeout(resolve, pollingInterval));
+            // Get the batch of notifications after the given cursor
+            const response = await this.request(resource, {
+                count: 40,
+                cursor: cursor,
+            });
+            // Deserializing response
+            const notifications = Extractors_1.Extractors[resource](response);
+            // Sorting the notifications by time, from oldest to recent
+            notifications.list.sort((a, b) => new Date(a.receivedAt).valueOf() - new Date(b.receivedAt).valueOf());
+            // If not first batch, return new notifications
+            if (!first) {
+                // Yield the notifications
+                for (const notification of notifications.list) {
+                    yield notification;
+                }
+            }
+            // Else do nothing, do nothing since first batch is notifications that have already been received
+            else {
+                first = false;
+            }
+            cursor = notifications.next;
+        }
+    }
+    /**
+     * Get the recommended feed of the logged in user.
+     *
+     * @param cursor - The cursor to the batch of feed items to fetch.
+     *
+     * @returns - The recommended feed of the logged-in user.
+     *
+     * @example
+     *
+     * ```ts
+     * import { Rettiwt } from 'rettiwt-api';
+     *
+     * // Creating a new Rettiwt instance using the given 'API_KEY'
+     * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+     *
+     * // Fetching the first 35 recommended feed items of the logged-in user
+     * rettiwt.user.recommended()
+     * .then(res => {
+     * 	console.log(res);
+     * })
+     * .catch(err => {
+     * 	console.log(err);
+     * });
+     * ```
+     *
+     * @remarks Always returns 35 feed items, with no way to customize the count.
+     */
+    async recommended(cursor) {
+        const resource = Resource_1.ResourceType.USER_FEED_RECOMMENDED;
+        // Fetching raw list of tweets
+        const response = await this.request(resource, {
+            cursor: cursor,
+        });
+        // Deserializing response
+        const data = Extractors_1.Extractors[resource](response);
+        return data;
+    }
+    /**
+     * Get the reply timeline of a user.
+     *
+     * @param id - The ID of the target user. If no ID is provided, the logged-in user's ID is used.
+     * @param count - The number of replies to fetch, must be \<= 20.
+     * @param cursor - The cursor to the batch of replies to fetch.
+     *
+     * @returns The reply timeline of the target user.
+     *
+     * @example
+     *
+     * ```ts
+     * import { Rettiwt } from 'rettiwt-api';
+     *
+     * // Creating a new Rettiwt instance using the given 'API_KEY'
+     * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+     *
+     * // Fetching the first 100 timeline replies of the User with id '1234567890'
+     * rettiwt.user.replies('1234567890')
+     * .then(res => {
+     * 	console.log(res);
+     * })
+     * .catch(err => {
+     * 	console.log(err);
+     * });
+     * ```
+     *
+     * @remarks
+     *
+     * If the target user has a pinned tweet, the returned reply timeline has one item extra and this is always the pinned tweet.
+     */
+    async replies(id, count, cursor) {
+        const resource = Resource_1.ResourceType.USER_TIMELINE_AND_REPLIES;
+        // Fetching raw list of replies
+        const response = await this.request(resource, {
+            id: id ?? this.config.userId,
+            count: count,
+            cursor: cursor,
+        });
+        // Deserializing response
+        const data = Extractors_1.Extractors[resource](response);
+        return data;
+    }
+    /**
+     * Search for a username.
+     *
+     * @param userName - The username to search for.
+     * @param count - The number of results to fetch, must be \<= 20.
+     * @param cursor - The cursor to the batch of results to fetch.
+     *
+     * @returns The list of users that match the given username.
+     *
+     * @example
+     *
+     * ```ts
+     * import { Rettiwt } from 'rettiwt-api';
+     *
+     * // Creating a new Rettiwt instance using the given 'API_KEY'
+     * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+     *
+     * // Fetching the top 5 matching users for the username 'user1'
+     * rettiwt.user.search('user1')
+     * .then(res => {
+     * 	console.log(res);
+     * })
+     * .catch(err => {
+     * 	console.log(err);
+     * });
+     * ```
+     */
+    async search(userName, count, cursor) {
+        const resource = Resource_1.ResourceType.USER_SEARCH;
+        // Fetching raw list of filtered tweets
+        const response = await this.request(resource, {
+            id: userName,
+            count: count,
+            cursor: cursor,
+        });
+        // Deserializing response
+        const data = Extractors_1.Extractors[resource](response);
+        return data;
+    }
+    /**
+     * Get the list of subscriptions of a user.
+     *
+     * @param id - The ID of the target user. If no ID is provided, the logged-in user's ID is used.
+     * @param count - The number of subscriptions to fetch, must be \<= 100.
+     * @param cursor - The cursor to the batch of subscriptions to fetch.
+     *
+     * @returns The list of subscriptions by the target user.
+     *
+     * @example
+     *
+     * ```ts
+     * import { Rettiwt } from 'rettiwt-api';
+     *
+     * // Creating a new Rettiwt instance using the given 'API_KEY'
+     * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+     *
+     * // Fetching the first 100 subscriptions of the User with id '1234567890'
+     * rettiwt.user.subscriptions('1234567890')
+     * .then(res => {
+     * 	console.log(res);
+     * })
+     * .catch(err => {
+     * 	console.log(err);
+     * });
+     * ```
+     */
+    async subscriptions(id, count, cursor) {
+        const resource = Resource_1.ResourceType.USER_SUBSCRIPTIONS;
+        // Fetching raw list of subscriptions
+        const response = await this.request(resource, {
+            id: id ?? this.config.userId,
+            count: count,
+            cursor: cursor,
+        });
+        // Deserializing response
+        const data = Extractors_1.Extractors[resource](response);
+        return data;
+    }
+    /**
+     * Get the tweet timeline of a user.
+     *
+     * @param id - The ID of the target user. If no ID is provided, the logged-in user's ID is used.
+     * @param count - The number of timeline items to fetch, must be \<= 20.
+     * @param cursor - The cursor to the batch of timeline items to fetch.
+     *
+     * @returns The timeline of the target user.
+     *
+     * @example
+     *
+     * ```ts
+     * import { Rettiwt } from 'rettiwt-api';
+     *
+     * // Creating a new Rettiwt instance using the given 'API_KEY'
+     * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+     *
+     * // Fetching the first 20 timeline tweets of the User with id '1234567890'
+     * rettiwt.user.timeline('1234567890')
+     * .then(res => {
+     * 	console.log(res);
+     * })
+     * .catch(err => {
+     * 	console.log(err);
+     * });
+     * ```
+     *
+     * @remarks
+     *
+     * - If the target user has a pinned tweet, the returned timeline has one item extra and this is always the pinned tweet.
+     * - If timeline is fetched without authenticating, then the most popular tweets of the target user are returned instead.
+     */
+    async timeline(id, count, cursor) {
+        const resource = Resource_1.ResourceType.USER_TIMELINE;
+        // Fetching raw list of tweets
+        const response = await this.request(resource, {
+            id: id ?? this.config.userId,
+            count: count,
+            cursor: cursor,
+        });
+        // Deserializing response
+        const data = Extractors_1.Extractors[resource](response);
+        return data;
+    }
+    /**
+     * Unfollow a user.
+     *
+     * @param id - The ID the user to be unfollowed.
+     *
+     * @returns Whether unfollowing was successful or not.
+     *
+     * @example
+     *
+     * ```ts
+     * import { Rettiwt } from 'rettiwt-api';
+     *
+     * // Creating a new Rettiwt instance using the given 'API_KEY'
+     * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+     *
+     * // Unfollowing the User with id '12345678'
+     * rettiwt.user.unfollow('12345678')
+     * .then(res => {
+     * 	console.log(res);
+     * })
+     * .catch(err => {
+     * 	console.log(err);
+     * });
+     * ```
+     */
+    async unfollow(id) {
+        const resource = Resource_1.ResourceType.USER_UNFOLLOW;
+        // Unfollowing the user
+        const response = await this.request(Resource_1.ResourceType.USER_UNFOLLOW, { id: id });
+        // Deserializing the response
+        const data = Extractors_1.Extractors[resource](response) ?? false;
+        return data;
+    }
+    /**
+     * Update the logged in user's profile.
+     *
+     * @param options - The profile update options.
+     *
+     * @returns Whether the profile update was successful or not.
+     *
+     * @example
+     *
+     * #### Updating only the display name
+     * ```ts
+     * import { Rettiwt } from 'rettiwt-api';
+     *
+     * // Creating a new Rettiwt instance using the given 'API_KEY'
+     * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+     *
+     * // Updating the display name of the logged in user
+     * rettiwt.user.updateProfile({ name: 'New Display Name' })
+     * .then(res => {
+     * 	console.log(res);
+     * })
+     * .catch(err => {
+     * 	console.log(err);
+     * });
+     * ```
+     *
+     * @example
+     *
+     * #### Updating multiple profile fields
+     * ```ts
+     * import { Rettiwt } from 'rettiwt-api';
+     *
+     * // Creating a new Rettiwt instance using the given 'API_KEY'
+     * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+     *
+     * // Updating multiple profile fields
+     * rettiwt.user.updateProfile({
+     * 	name: 'New Display Name',
+     * 	location: 'Istanbul',
+     * 	description: 'Hello world!',
+     * 	url: 'https://example.com'
+     * })
+     * .then(res => {
+     * 	console.log(res);
+     * })
+     * .catch(err => {
+     * 	console.log(err);
+     * });
+     * ```
+     */
+    async updateProfile(options) {
+        const resource = Resource_1.ResourceType.USER_PROFILE_UPDATE;
+        // Validating the options
+        const validatedOptions = new ProfileArgs_1.ProfileUpdateOptions(options);
+        // Updating the profile
+        const response = await this.request(resource, { profileOptions: validatedOptions });
+        // Deserializing the response
+        const data = Extractors_1.Extractors[resource](response) ?? false;
+        return data;
+    }
+}
+exports.UserService = UserService;
+//# sourceMappingURL=UserService.js.map