rettiwt-api 2.7.1 → 3.0.0

package/src/services/public/TweetService.ts

@@ -1,20 +1,32 @@
-// PACKAGES
-import { EResourceType, MediaArgs, TweetFilter } from 'rettiwt-core';
-
-// SERVICES
-import { FetcherService } from '../internal/FetcherService';
-
-// TYPES
-import { IRettiwtConfig } from '../../types/RettiwtConfig';
-
-// MODELS
+import { statSync } from 'fs';
+
+import {
+	IInitializeMediaUploadResponse,
+	IListTweetsResponse,
+	ITweetDetailsResponse,
+	ITweetLikeResponse,
+	ITweetLikersResponse,
+	ITweetPostResponse,
+	ITweetRetweetersResponse,
+	ITweetRetweetResponse,
+	ITweetSearchResponse,
+	ITweetUnlikeResponse,
+	ITweetUnpostResponse,
+	ITweetUnretweetResponse,
+	TweetFilter,
+} from 'rettiwt-core';
+
+import { EResourceType } from '../../enums/Resource';
+import { TweetArgs } from '../../models/args/PostArgs';
+import { CursoredData } from '../../models/data/CursoredData';
 import { Tweet } from '../../models/data/Tweet';
 import { User } from '../../models/data/User';
-import { CursoredData } from '../../models/data/CursoredData';
-import { TweetArgs, TweetMediaArgs } from '../../models/args/TweetArgs';
+import { IRettiwtConfig } from '../../types/RettiwtConfig';
+
+import { FetcherService } from './FetcherService';
 
 /**
- * Handles fetching of data related to tweets.
+ * Handles interacting with resources related to tweets.
  *
  * @public
  */
@@ -32,7 +44,10 @@ export class TweetService extends FetcherService {
 	 * Get the details of a tweet.
 	 *
 	 * @param id - The id of the target tweet.
-	 * @returns The details of a single tweet with the given tweet id.
+	 *
+	 * @returns
+	 * The details of the tweet with the given id.
+	 * If no tweet matches the given id, returns `undefined`.
 	 *
 	 * @example
 	 * ```
@@ -41,8 +56,8 @@ export class TweetService extends FetcherService {
 	 * // Creating a new Rettiwt instance using the given 'API_KEY'
 	 * const rettiwt = new Rettiwt({ apiKey: API_KEY });
 	 *
-	 * // Fetching the details of the tweet with the id '12345678'
-	 * rettiwt.tweet.details('12345678')
+	 * // Fetching the details of the tweet with the id '1234567890'
+	 * rettiwt.tweet.details('1234567890')
 	 * .then(res => {
 	 * 	console.log(res);
 	 * })
@@ -50,23 +65,25 @@ export class TweetService extends FetcherService {
 	 * 	console.log(err);
 	 * });
 	 * ```
-	 *
-	 * @public
 	 */
-	public async details(id: string): Promise<Tweet> {
-		// Fetching the requested data
-		const data = await this.fetch<Tweet>(EResourceType.TWEET_DETAILS, { id: id });
+	public async details(id: string): Promise<Tweet | undefined> {
+		const resource = EResourceType.TWEET_DETAILS;
 
-		return data.list[0];
+		// Fetching raw tweet details
+		const response = await this.request<ITweetDetailsResponse>(resource, { id: id });
+
+		// Deserializing response
+		const data = this.extract<Tweet>(response, resource);
+
+		return data;
 	}
 
 	/**
-	 * Search for tweets using a query.
+	 * Like a tweet.
 	 *
-	 * @param query - The query be used for searching the tweets.
-	 * @param count - The number of tweets to fetch, must be \<= 20.
-	 * @param cursor - The cursor to the batch of tweets to fetch.
-	 * @returns The list of tweets that match the given filter.
+	 * @param id - The id of the tweet to be liked.
+	 *
+	 * @returns Whether liking was successful or not.
 	 *
 	 * @example
 	 * ```
@@ -75,8 +92,8 @@ export class TweetService extends FetcherService {
 	 * // Creating a new Rettiwt instance using the given 'API_KEY'
 	 * const rettiwt = new Rettiwt({ apiKey: API_KEY });
 	 *
-	 * // Fetching the most recent 5 tweets from user 'user1'
-	 * rettiwt.tweet.search({ fromUsers: ['user1'] }, 5)
+	 * // Liking the Tweet with id '1234567890'
+	 * rettiwt.tweet.like('1234567890')
 	 * .then(res => {
 	 * 	console.log(res);
 	 * })
@@ -84,31 +101,27 @@ export class TweetService extends FetcherService {
 	 * 	console.log(err);
 	 * });
 	 * ```
-	 *
-	 * @remarks For details about available filters, refer to {@link TweetFilter}
-	 *
-	 * @public
 	 */
-	public async search(query: TweetFilter, count?: number, cursor?: string): Promise<CursoredData<Tweet>> {
-		// Fetching the requested data
-		const data = await this.fetch<Tweet>(EResourceType.TWEET_SEARCH, {
-			filter: query,
-			count: count,
-			cursor: cursor,
+	public async like(id: string): Promise<boolean> {
+		// Favoriting the tweet
+		const response = await this.request<ITweetLikeResponse>(EResourceType.TWEET_LIKE, {
+			id: id,
 		});
 
-		// Sorting the tweets by date, from recent to oldest
-		data.list.sort((a, b) => new Date(b.createdAt).valueOf() - new Date(a.createdAt).valueOf());
+		// Deserializing response
+		const data = this.extract<boolean>(response, EResourceType.TWEET_LIKE) ?? false;
 
 		return data;
 	}
 
 	/**
-	 * Stream tweets in pseudo real-time using a filter.
+	 * Get the list of users who liked a tweet.
 	 *
-	 * @param filter - The filter to be used for searching the tweets.
-	 * @param pollingInterval - The interval in milliseconds to poll for new tweets. Default interval is 60000 ms.
-	 * @returns An async generator that yields matching tweets as they are found.
+	 * @param id - The id of the target tweet.
+	 * @param count - The number of likers to fetch, must be \<= 100.
+	 * @param cursor - The cursor to the batch of likers to fetch.
+	 *
+	 * @returns The list of users who liked the given tweet.
 	 *
 	 * @example
 	 * ```
@@ -117,64 +130,40 @@ export class TweetService extends FetcherService {
 	 * // Creating a new Rettiwt instance using the given 'API_KEY'
 	 * const rettiwt = new Rettiwt({ apiKey: API_KEY });
 	 *
-	 * // Streaming all upcoming tweets from user 'user1'
-	 * (async () => {
-	 * 	try {
-	 * 		for await (const tweet of rettiwt.tweet.stream({ fromUsers: ['user1'] }, 1000)) {
-	 * 			console.log(tweet.fullText);
-	 * 		}
-	 * 	}
-	 * 	catch (err) {
-	 * 		console.log(err);
-	 * 	}
-	 * })();
+	 * // Fetching the most recent 100 likers of the Tweet with id '1234567890'
+	 * rettiwt.tweet.likers('1234567890')
+	 * .then(res => {
+	 * 	console.log(res);
+	 * })
+	 * .catch(err => {
+	 * 	console.log(err);
+	 * });
 	 * ```
-	 *
-	 * @public
 	 */
-	public async *stream(filter: TweetFilter, pollingInterval: number = 60000): AsyncGenerator<Tweet> {
-		const startDate = new Date();
-
-		let cursor: string | undefined = undefined;
-		let sinceId: string | undefined = undefined;
-		let nextSinceId: string | undefined = undefined;
-
-		while (true) {
-			// Pause execution for the specified polling interval before proceeding to the next iteration
-			await new Promise((resolve) => setTimeout(resolve, pollingInterval));
+	public async likers(id: string, count?: number, cursor?: string): Promise<CursoredData<User>> {
+		const resource = EResourceType.TWEET_LIKERS;
 
-			// Search for tweets
-			const tweets = await this.search({ ...filter, startDate: startDate, sinceId: sinceId }, undefined, cursor);
-
-			// Yield the matching tweets
-			for (const tweet of tweets.list) {
-				yield tweet;
-			}
+		// Fetching raw likers
+		const response = await this.request<ITweetLikersResponse>(resource, {
+			id: id,
+			count: count,
+			cursor: cursor,
+		});
 
-			// Store the most recent tweet ID from this batch
-			if (tweets.list.length > 0 && cursor === undefined) {
-				nextSinceId = tweets.list[0].id;
-			}
+		// Deserializing response
+		const data = this.extract<CursoredData<User>>(response, resource)!;
 
-			// If there are more tweets to fetch, adjust the cursor value
-			if (tweets.list.length > 0 && tweets.next) {
-				cursor = tweets.next.value;
-			}
-			// Else, start the next iteration from this batch's most recent tweet
-			else {
-				sinceId = nextSinceId;
-				cursor = undefined;
-			}
-		}
+		return data;
 	}
 
 	/**
-	 * Get the tweets from the tweet list with the given id.
+	 * Get the list of tweets from a tweet list.
 	 *
-	 * @param listId - The id of list from where the tweets are to be fetched.
+	 * @param id - The id of target list.
 	 * @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 tweets present in the given list.
+	 *
+	 * @returns The list tweets in the given list.
 	 *
 	 * @example
 	 * ```
@@ -183,8 +172,8 @@ export class TweetService extends FetcherService {
 	 * // Creating a new Rettiwt instance using the given 'API_KEY'
 	 * const rettiwt = new Rettiwt({ apiKey: API_KEY });
 	 *
-	 * // Fetching the most recent 100 tweets of the Twitter list with id '12345678'
-	 * rettiwt.tweet.list('12345678')
+	 * // Fetching the most recent 100 tweets of the Twitter list with id '1234567890'
+	 * rettiwt.tweet.list('1234567890')
 	 * .then(res => {
 	 * 	console.log(res);
 	 * })
@@ -195,14 +184,19 @@ export class TweetService extends FetcherService {
 	 *
 	 * @remarks Due a bug in Twitter API, the count is ignored when no cursor is provided and defaults to 100.
 	 */
-	public async list(listId: string, count?: number, cursor?: string): Promise<CursoredData<Tweet>> {
-		// Fetching the requested data
-		const data = await this.fetch<Tweet>(EResourceType.LIST_TWEETS, {
-			id: listId,
+	public async list(id: string, count?: number, cursor?: string): Promise<CursoredData<Tweet>> {
+		const resource = EResourceType.LIST_TWEETS;
+
+		// Fetching raw list tweets
+		const response = await this.request<IListTweetsResponse>(resource, {
+			id: id,
 			count: count,
 			cursor: cursor,
 		});
 
+		// Deserializing response
+		const data = this.extract<CursoredData<Tweet>>(response, resource)!;
+
 		// Sorting the tweets by date, from recent to oldest
 		data.list.sort((a, b) => new Date(b.createdAt).valueOf() - new Date(a.createdAt).valueOf());
 
@@ -210,22 +204,22 @@ export class TweetService extends FetcherService {
 	}
 
 	/**
-	 * Get the list of users who liked a tweet.
+	 * Post a tweet.
 	 *
-	 * @param tweetId - The rest id of the target tweet.
-	 * @param count - The number of favoriters to fetch, must be \<= 100.
-	 * @param cursor - The cursor to the batch of favoriters to fetch.
-	 * @returns The list of users who liked the given tweet.
+	 * @param options - The options describing the tweet to be posted. Check {@link TweetArgs} for available options.
+	 *
+	 * @returns Whether posting was successful or not.
 	 *
 	 * @example
+	 * Posting a simple text
 	 * ```
 	 * 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 likers of the Tweet with id '12345678'
-	 * rettiwt.tweet.favoriters('12345678')
+	 * // Posting a tweet to twitter
+	 * rettiwt.tweet.post({ text: 'Hello World!' })
 	 * .then(res => {
 	 * 	console.log(res);
 	 * })
@@ -234,15 +228,104 @@ export class TweetService extends FetcherService {
 	 * });
 	 * ```
 	 *
-	 * @public
+	 * @example
+	 * Posting a tweet with an image that has been already uploaded
+	 * ```
+	 * import { Rettiwt } from 'rettiwt-api';
+	 *
+	 * // Creating a new Rettiwt instance using the given 'API_KEY'
+	 * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+	 *
+	 * // Posting a tweet, containing an image called 'mountains.jpg', to twitter
+	 * rettiwt.tweet.post({ text: 'What a nice view!', media: [{ id: '1234567890' }] })
+	 * .then(res => {
+	 * 	console.log(res);
+	 * })
+	 * .catch(err => {
+	 * 	console.log(err);
+	 * });
+	 * ```
+	 *
+	 * @example
+	 * Posting a reply to a tweet
+	 * ```
+	 * import { Rettiwt } from 'rettiwt-api';
+	 *
+	 * // Creating a new Rettiwt instance using the given 'API_KEY'
+	 * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+	 *
+	 * // Posting a simple text reply, to a tweet with id "1234567890"
+	 * rettiwt.tweet.post({ text: 'Hello!', replyTo: "1234567890" })
+	 * .then(res => {
+	 * 	console.log(res);
+	 * })
+	 * .catch(err => {
+	 * 	console.log(err);
+	 * });
+	 * ```
+	 *
+	 * * @example
+	 * Posting a tweet that quotes another tweet
+	 * ```
+	 * import { Rettiwt } from 'rettiwt-api';
+	 *
+	 * // Creating a new Rettiwt instance using the given 'API_KEY'
+	 * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+	 *
+	 * // Posting a simple text tweet, quoting a tweet with id "1234567890"
+	 * rettiwt.tweet.post({ text: 'Hello!', quote: "1234567890" })
+	 * .then(res => {
+	 * 	console.log(res);
+	 * })
+	 * .catch(err => {
+	 * 	console.log(err);
+	 * });
+	 * ```
 	 */
-	public async favoriters(tweetId: string, count?: number, cursor?: string): Promise<CursoredData<User>> {
-		// Fetching the requested data
-		const data = await this.fetch<User>(EResourceType.TWEET_FAVORITERS, {
-			id: tweetId,
-			count: count,
-			cursor: cursor,
-		});
+	public async post(options: TweetArgs): Promise<string | undefined> {
+		const resource = EResourceType.TWEET_POST;
+
+		// Posting the tweet
+		const response = await this.request<ITweetPostResponse>(resource, { tweet: options });
+
+		// Deserializing response
+		const data = this.extract<string>(response, resource);
+
+		return data;
+	}
+
+	/**
+	 * Retweet a tweet.
+	 *
+	 * @param id - The id of the target tweet.
+	 *
+	 * @returns Whether retweeting was successful or not.
+	 *
+	 * @example
+	 * ```
+	 * import { Rettiwt } from 'rettiwt-api';
+	 *
+	 * // Creating a new Rettiwt instance using the given 'API_KEY'
+	 * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+	 *
+	 * // Retweeting the Tweet with id '1234567890'
+	 * rettiwt.tweet.retweet('1234567890')
+	 * .then(res => {
+	 * 	console.log(res);
+	 * })
+	 * .catch(err => {
+	 * 	console.log(err);
+	 * });
+	 * ```
+	 */
+	public async retweet(id: string): Promise<boolean> {
+		const resource = EResourceType.TWEET_RETWEET;
+
+		// Retweeting the tweet
+		const response = await this.request<ITweetRetweetResponse>(resource, { id: id });
+
+		// Deserializing response
+		const data = this.extract<boolean>(response, resource) ?? false;
 
 		return data;
 	}
@@ -250,9 +333,10 @@ export class TweetService extends FetcherService {
 	/**
 	 * Get the list of users who retweeted a tweet.
 	 *
-	 * @param tweetId - The rest id of the target tweet.
+	 * @param id - The id of the target tweet.
 	 * @param count - The number of retweeters to fetch, must be \<= 100.
 	 * @param cursor - The cursor to the batch of retweeters to fetch.
+	 *
 	 * @returns The list of users who retweeted the given tweet.
 	 *
 	 * @example
@@ -262,8 +346,8 @@ export class TweetService extends FetcherService {
 	 * // Creating a new Rettiwt instance using the given 'API_KEY'
 	 * const rettiwt = new Rettiwt({ apiKey: API_KEY });
 	 *
-	 * // Fetching the most recent 100 retweeters of the Tweet with id '12345678'
-	 * rettiwt.tweet.retweeters('12345678')
+	 * // Fetching the most recent 100 retweeters of the Tweet with id '1234567890'
+	 * rettiwt.tweet.retweeters('1234567890')
 	 * .then(res => {
 	 * 	console.log(res);
 	 * })
@@ -271,37 +355,41 @@ export class TweetService extends FetcherService {
 	 * 	console.log(err);
 	 * });
 	 * ```
-	 *
-	 * @public
 	 */
-	public async retweeters(tweetId: string, count?: number, cursor?: string): Promise<CursoredData<User>> {
-		// Fetching the requested data
-		const data = await this.fetch<User>(EResourceType.TWEET_RETWEETERS, {
-			id: tweetId,
+	public async retweeters(id: string, count?: number, cursor?: string): Promise<CursoredData<User>> {
+		const resource = EResourceType.TWEET_RETWEETERS;
+
+		// Fetching raw list of retweeters
+		const response = await this.request<ITweetRetweetersResponse>(resource, {
+			id: id,
 			count: count,
 			cursor: cursor,
 		});
 
+		// Deserializing response
+		const data = this.extract<CursoredData<User>>(response, resource)!;
+
 		return data;
 	}
 
 	/**
-	 * Post a tweet.
+	 * Search for tweets using a filter.
 	 *
-	 * @param text - The text to be posted, length must be \<= 280 characters.
-	 * @param media - The list of media to post in the tweet, max number of media must be \<= 4.
-	 * @param replyTo - The id of the tweet to which the reply is to be made.
-	 * @returns Whether posting was successful or not.
+	 * @param filter - The filter to be used for searching the tweets.
+	 * @param count - The number of tweets to fetch, must be \<= 20.
+	 * @param cursor - The cursor to the batch of tweets to fetch.
 	 *
-	 * @example Posting a simple text
+	 * @returns The list of tweets that match the given filter.
+	 *
+	 * @example
 	 * ```
 	 * import { Rettiwt } from 'rettiwt-api';
 	 *
 	 * // Creating a new Rettiwt instance using the given 'API_KEY'
 	 * const rettiwt = new Rettiwt({ apiKey: API_KEY });
 	 *
-	 * // Posting a tweet to twitter
-	 * rettiwt.tweet.tweet('Hello World!')
+	 * // Fetching the most recent 5 tweets from user 'user1'
+	 * rettiwt.tweet.search({ fromUsers: ['user1'] }, 5)
 	 * .then(res => {
 	 * 	console.log(res);
 	 * })
@@ -310,15 +398,107 @@ export class TweetService extends FetcherService {
 	 * });
 	 * ```
 	 *
-	 * @example Posting a tweet with an image
+	 * @remarks For details about available filters, refer to {@link TweetFilter}
+	 */
+	public async search(filter: TweetFilter, count?: number, cursor?: string): Promise<CursoredData<Tweet>> {
+		const resource = EResourceType.TWEET_SEARCH;
+
+		// Fetching raw list of filtered tweets
+		const response = await this.request<ITweetSearchResponse>(resource, {
+			filter: filter,
+			count: count,
+			cursor: cursor,
+		});
+
+		// Deserializing response
+		const data = this.extract<CursoredData<Tweet>>(response, resource)!;
+
+		// Sorting the tweets by date, from recent to oldest
+		data.list.sort((a, b) => new Date(b.createdAt).valueOf() - new Date(a.createdAt).valueOf());
+
+		return data;
+	}
+
+	/**
+	 * Stream tweets in pseudo real-time using a filter.
+	 *
+	 * @param filter - The filter to be used for searching the tweets.
+	 * @param pollingInterval - The interval in milliseconds to poll for new tweets. Default interval is 60000 ms.
+	 *
+	 * @returns An async generator that yields matching tweets as they are found.
+	 *
+	 * @example
 	 * ```
 	 * import { Rettiwt } from 'rettiwt-api';
 	 *
 	 * // Creating a new Rettiwt instance using the given 'API_KEY'
 	 * const rettiwt = new Rettiwt({ apiKey: API_KEY });
 	 *
-	 * // Posting a tweet, containing an image called 'mountains.jpg', to twitter
-	 * rettiwt.tweet.tweet('What a nice view!', [{ path: 'mountains.jpg' }])
+	 * // Streaming all upcoming tweets from user 'user1'
+	 * (async () => {
+	 * 	try {
+	 * 		for await (const tweet of rettiwt.tweet.stream({ fromUsers: ['user1'] }, 1000)) {
+	 * 			console.log(tweet.fullText);
+	 * 		}
+	 * 	}
+	 * 	catch (err) {
+	 * 		console.log(err);
+	 * 	}
+	 * })();
+	 * ```
+	 */
+	public async *stream(filter: TweetFilter, pollingInterval: number = 60000): AsyncGenerator<Tweet> {
+		const startDate = new Date();
+
+		let cursor: string | undefined = undefined;
+		let sinceId: string | undefined = undefined;
+		let nextSinceId: string | undefined = undefined;
+
+		while (true) {
+			// Pause execution for the specified polling interval before proceeding to the next iteration
+			await new Promise((resolve) => setTimeout(resolve, pollingInterval));
+
+			// Search for tweets
+			const tweets = await this.search({ ...filter, startDate: startDate, sinceId: sinceId }, undefined, cursor);
+
+			// Yield the matching tweets
+			for (const tweet of tweets.list) {
+				yield tweet;
+			}
+
+			// Store the most recent tweet ID from this batch
+			if (tweets.list.length > 0 && cursor === undefined) {
+				nextSinceId = tweets.list[0].id;
+			}
+
+			// If there are more tweets to fetch, adjust the cursor value
+			if (tweets.list.length > 0 && tweets.next) {
+				cursor = tweets.next.value;
+			}
+			// Else, start the next iteration from this batch's most recent tweet
+			else {
+				sinceId = nextSinceId;
+				cursor = undefined;
+			}
+		}
+	}
+
+	/**
+	 * Unlike a tweet.
+	 *
+	 * @param id - The id of the target tweet.
+	 *
+	 * @returns Whether unliking was successful or not.
+	 *
+	 * @example
+	 * ```
+	 * import { Rettiwt } from 'rettiwt-api';
+	 *
+	 * // Creating a new Rettiwt instance using the given 'API_KEY'
+	 * const rettiwt = new Rettiwt({ apiKey: API_KEY });
+	 *
+	 * // Unliking the Tweet with id '1234567890'
+	 * rettiwt.tweet.unlike('1234567890')
 	 * .then(res => {
 	 * 	console.log(res);
 	 * })
@@ -326,16 +506,35 @@ export class TweetService extends FetcherService {
 	 * 	console.log(err);
 	 * });
 	 * ```
+	 */
+	public async unlike(id: string): Promise<boolean> {
+		const resource = EResourceType.TWEET_UNLIKE;
+
+		// Unliking the tweet
+		const response = await this.request<ITweetUnlikeResponse>(resource, { id: id });
+
+		// Deserializing the response
+		const data = this.extract<boolean>(response, resource) ?? false;
+
+		return data;
+	}
+
+	/**
+	 * Unpost a tweet.
 	 *
-	 * @example Posting a reply to a tweet
+	 * @param id - The id of the target tweet.
+	 *
+	 * @returns Whether unposting was successful or not.
+	 *
+	 * @example
 	 * ```
 	 * import { Rettiwt } from 'rettiwt-api';
 	 *
 	 * // Creating a new Rettiwt instance using the given 'API_KEY'
 	 * const rettiwt = new Rettiwt({ apiKey: API_KEY });
 	 *
-	 * // Posting a simple text reply, to a tweet with id "1234567890"
-	 * rettiwt.tweet.tweet('Hello!', undefined, "1234567890")
+	 * // Unposting the Tweet with id '1234567890'
+	 * rettiwt.tweet.unpost('1234567890')
 	 * .then(res => {
 	 * 	console.log(res);
 	 * })
@@ -343,40 +542,25 @@ export class TweetService extends FetcherService {
 	 * 	console.log(err);
 	 * });
 	 * ```
-	 *
-	 * @public
 	 */
-	public async tweet(text: string, media?: TweetMediaArgs[], replyTo?: string): Promise<boolean> {
-		// Converting  JSON args to object
-		const tweet: TweetArgs = new TweetArgs({ text: text, media: media });
-
-		/** Stores the list of media that has been uploaded */
-		const uploadedMedia: MediaArgs[] = [];
+	public async unpost(id: string): Promise<boolean> {
+		const resource = EResourceType.TWEET_UNPOST;
 
-		// If tweet includes media, upload the media items
-		if (tweet.media) {
-			for (const item of tweet.media) {
-				// Uploading the media item and getting it's allocated id
-				const id: string = await this.upload(item.path);
-
-				// Storing the uploaded media item
-				uploadedMedia.push(new MediaArgs({ id: id, tags: item.tags }));
-			}
-		}
+		// Unposting the tweet
+		const response = await this.request<ITweetUnpostResponse>(resource, { id: id });
 
-		// Posting the tweet
-		const data = await this.post(EResourceType.CREATE_TWEET, {
-			tweet: { text: text, media: uploadedMedia, replyTo: replyTo },
-		});
+		// Deserializing the response
+		const data = this.extract<boolean>(response, resource) ?? false;
 
 		return data;
 	}
 
 	/**
-	 * Favorite the tweet with the given id.
+	 * Unretweet a tweet.
+	 *
+	 * @param id - The id of the target tweet.
 	 *
-	 * @param tweetId - The id of the tweet to be favorited.
-	 * @returns Whether favoriting was successful or not.
+	 * @returns Whether unretweeting was successful or not.
 	 *
 	 * @example
 	 * ```
@@ -385,8 +569,8 @@ export class TweetService extends FetcherService {
 	 * // Creating a new Rettiwt instance using the given 'API_KEY'
 	 * const rettiwt = new Rettiwt({ apiKey: API_KEY });
 	 *
-	 * // Liking the Tweet with id '12345678'
-	 * rettiwt.tweet.favorite('12345678')
+	 * // Unretweeting the Tweet with id '1234567890'
+	 * rettiwt.tweet.unretweet('1234567890')
 	 * .then(res => {
 	 * 	console.log(res);
 	 * })
@@ -394,21 +578,25 @@ export class TweetService extends FetcherService {
 	 * 	console.log(err);
 	 * });
 	 * ```
-	 *
-	 * @public
 	 */
-	public async favorite(tweetId: string): Promise<boolean> {
-		// Favoriting the tweet
-		const data = await this.post(EResourceType.FAVORITE_TWEET, { id: tweetId });
+	public async unretweet(id: string): Promise<boolean> {
+		const resource = EResourceType.TWEET_UNRETWEET;
+
+		// Unretweeting the tweet
+		const response = await this.request<ITweetUnretweetResponse>(resource, { id: id });
+
+		// Deserializing the response
+		const data = this.extract<boolean>(response, resource) ?? false;
 
 		return data;
 	}
 
 	/**
-	 * Retweet the tweet with the given id.
+	 * Upload a media file to Twitter.
 	 *
-	 * @param tweetId - The id of the tweet with the given id.
-	 * @returns Whether retweeting was successful or not.
+	 * @param media - The path or ArrayBuffer to the media file to upload.
+	 *
+	 * @returns The id of the uploaded media.
 	 *
 	 * @example
 	 * ```
@@ -417,8 +605,8 @@ export class TweetService extends FetcherService {
 	 * // Creating a new Rettiwt instance using the given 'API_KEY'
 	 * const rettiwt = new Rettiwt({ apiKey: API_KEY });
 	 *
-	 * // Retweeting the Tweet with id '12345678'
-	 * rettiwt.tweet.retweet('12345678')
+	 * // Uploading a file called mountains.jpg
+	 * rettiwt.tweet.upload('mountains.jpg')
 	 * .then(res => {
 	 * 	console.log(res);
 	 * })
@@ -427,12 +615,26 @@ export class TweetService extends FetcherService {
 	 * });
 	 * ```
 	 *
-	 * @public
+	 * @remarks
+	 * - The uploaded media exists for 24 hrs within which it can be included in a tweet to be posted.
+	 * If not posted in a tweet within this period, the uploaded media is removed.
+	 * - Instead of a path to the media, an ArrayBuffer containing the media can also be uploaded.
 	 */
-	public async retweet(tweetId: string): Promise<boolean> {
-		// Retweeting the tweet
-		const data = await this.post(EResourceType.CREATE_RETWEET, { id: tweetId });
-
-		return data;
+	public async upload(media: string | ArrayBuffer): Promise<string> {
+		// INITIALIZE
+		const size = typeof media == 'string' ? statSync(media).size : media.byteLength;
+		const id: string = (
+			await this.request<IInitializeMediaUploadResponse>(EResourceType.MEDIA_UPLOAD_INITIALIZE, {
+				upload: { size: size },
+			})
+		).media_id_string;
+
+		// APPEND
+		await this.request<unknown>(EResourceType.MEDIA_UPLOAD_APPEND, { upload: { id: id, media: media } });
+
+		// FINALIZE
+		await this.request<unknown>(EResourceType.MEDIA_UPLOAD_FINALIZE, { upload: { id: id } });
+
+		return id;
 	}
 }