@glagan/rettiwt-api 7.0.0

package/package.json

@@ -0,0 +1,50 @@
+{
+	"name": "@glagan/rettiwt-api",
+	"version": "7.0.0",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"description": "An API for fetching data from TwitterAPI, without any rate limits!",
+	"bin": {
+		"rettiwt": "dist/cli.js"
+	},
+	"scripts": {
+		"build": "bun tsc",
+		"prepare": "bun tsc",
+		"format": "prettier --write .",
+		"format:check": "prettier --check .",
+		"lint": "eslint --max-warnings 0 --fix .",
+		"lint:check": "eslint --max-warnings 0 ."
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/Glagan/Rettiwt-API.git"
+	},
+	"author": {
+		"email": "rishikantsahu181@gmail.com",
+		"name": "Rishikant Sahu"
+	},
+	"license": "ISC",
+	"bugs": {
+		"url": "https://github.com/Glagan/Rettiwt-API/issues"
+	},
+	"homepage": "https://rishikant181.github.io/Rettiwt-API/",
+	"devDependencies": {
+		"@types/cookiejar": "^2.1.5",
+		"@types/jsdom": "^27.0.0",
+		"@types/node": "^22.13.1",
+		"@typescript-eslint/eslint-plugin": "^8.24.0",
+		"@typescript-eslint/parser": "^8.24.0",
+		"eslint": "^9.20.1",
+		"eslint-plugin-import": "^2.31.0",
+		"prettier": "^3.5.1",
+		"typescript": "^5.7.3"
+	},
+	"dependencies": {
+		"commander": "^14.0.2",
+		"cookiejar": "^2.1.4",
+		"https-proxy-agent": "^7.0.6",
+		"jsdom": "^27.2.0",
+		"ofetch": "^1.5.1",
+		"x-client-transaction-id": "^0.1.9"
+	}
+}

package/src/Rettiwt.ts

@@ -0,0 +1,97 @@
+import { RettiwtConfig } from './models/RettiwtConfig';
+import { DirectMessageService } from './services/public/DirectMessageService';
+import { ListService } from './services/public/ListService';
+import { TweetService } from './services/public/TweetService';
+import { UserService } from './services/public/UserService';
+import { IRettiwtConfig } from './types/RettiwtConfig';
+
+/**
+ * The class for accessing Twitter API.
+ *
+ * The created Rettiwt instance can be configured by passing in a configuration object to the constructor.
+ *
+ * For details regarding the available configuration options, refer to {@link IRettiwtConfig}
+ *
+ * @example Creating a Rettiwt instance with 'guest' authentication:
+ * ```
+ * import { Rettiwt } from 'rettiwt-api';
+ *
+ * // Creating a new Rettiwt instance
+ * const rettiwt = new Rettiwt();
+ * ```
+ *
+ * @example Creating a Rettiwt instance with 'guest' authentication, using a pre-generated guest key:
+ * ```
+ * import { Rettiwt } from 'rettiwt-api';
+ *
+ * // Creating a new Rettiwt instance
+ * const rettiwt = new Rettiwt({ guestKey: 'GUEST_KEY' });
+ * ```
+ *
+ * @example Creating a Rettiwt instance with 'user' authentication:
+ * ```
+ * import { Rettiwt } from 'rettiwt-api';
+ *
+ * // Creating a new Rettiwt instance
+ * const rettiwt = new Rettiwt({ apiKey: 'API_KEY' });
+ * ```
+ *
+ * @example Creating a Rettiwt instance with 'user'authentication, along with enabling debug logs and using a proxy:
+ * ```
+ * import { Rettiwt } from 'rettiwt-api';
+ *
+ * // Creating a new Rettiwt instance
+ * const rettiwt = new Rettiwt({ apiKey: 'API_KEY', logging: true, proxyUrl: 'URL_TO_PROXY_SERVER' });
+ * ```
+ *
+ * @public
+ */
+export class Rettiwt {
+	/** The configuration for Rettiwt. */
+	private _config: RettiwtConfig;
+
+	/** The instance used to fetch data related to direct messages. */
+	public dm: DirectMessageService;
+
+	/** The instance used to fetch data related to lists. */
+	public list: ListService;
+
+	/** The instance used to fetch data related to tweets. */
+	public tweet: TweetService;
+
+	/** The instance used to fetch data related to users. */
+	public user: UserService;
+
+	/**
+	 * Initializes a new Rettiwt instance using the given api key.
+	 *
+	 * @param config - The config object for configuring the Rettiwt instance.
+	 */
+	public constructor(config?: IRettiwtConfig) {
+		this._config = new RettiwtConfig(config);
+		this.dm = new DirectMessageService(this._config);
+		this.list = new ListService(this._config);
+		this.tweet = new TweetService(this._config);
+		this.user = new UserService(this._config);
+	}
+
+	/** Get the current API key associated with this instance. */
+	public get apiKey(): string | undefined {
+		return this._config.apiKey;
+	}
+
+	/** Set the API key for the current instance. */
+	public set apiKey(apiKey: string | undefined) {
+		this._config.apiKey = apiKey;
+	}
+
+	/** Set the custom headers for the current instance. */
+	public set headers(headers: { [key: string]: string }) {
+		this._config.headers = headers;
+	}
+
+	/** Set the proxy URL for the current instance. */
+	public set proxyUrl(proxyUrl: URL) {
+		this._config.proxyUrl = proxyUrl;
+	}
+}

package/src/cli.ts

@@ -0,0 +1,48 @@
+#! /usr/bin/env node
+
+import { createCommand } from 'commander';
+
+import dm from './commands/DirectMessage';
+import list from './commands/List';
+import tweet from './commands/Tweet';
+import user from './commands/User';
+import { Rettiwt } from './Rettiwt';
+
+// Creating a new commandline program
+const Program = createCommand('rettiwt')
+	.description('A CLI tool for accessing the Twitter API for free!')
+	.passThroughOptions()
+	.enablePositionalOptions();
+
+// Adding options
+Program.option('-k, --key <string>', 'The API key to use for authentication')
+	.option('-l, --log', 'Enable logging to console')
+	.option('-p, --proxy <string>', 'The URL to the proxy to use')
+	.option('-t, --timeout <number>', 'The timout (in milli-seconds) to use for requests')
+	.option(
+		'-r, --retries <number>',
+		'The maximum number of retries to use, a value of 5 combined with a delay of 1000 is recommended',
+	)
+	.option('-d, --delay <number>', 'The delay in milliseconds to use in-between successive requests');
+
+// Parsing the program to get supplied options
+Program.parse();
+
+// Initializing Rettiwt instance using the given options
+const RettiwtInstance = new Rettiwt({
+	apiKey: process.env.API_KEY ?? (Program.opts().key as string),
+	logging: Program.opts().log ? true : false,
+	proxyUrl: Program.opts().proxy as URL,
+	timeout: Program.opts().timeout ? Number(Program.opts().timeout) : undefined,
+	maxRetries: Program.opts().retries as number,
+	delay: Program.opts().delay as number,
+});
+
+// Adding sub-commands
+Program.addCommand(dm(RettiwtInstance));
+Program.addCommand(list(RettiwtInstance));
+Program.addCommand(tweet(RettiwtInstance));
+Program.addCommand(user(RettiwtInstance));
+
+// Finalizing the CLI
+Program.parse();

package/src/collections/Extractors.ts

@@ -0,0 +1,155 @@
+import { BaseType } from '../enums/Data';
+import { Analytics } from '../models/data/Analytics';
+import { BookmarkFolder } from '../models/data/BookmarkFolder';
+import { Conversation } from '../models/data/Conversation';
+import { CursoredData } from '../models/data/CursoredData';
+import { Inbox } from '../models/data/Inbox';
+import { List } from '../models/data/List';
+import { Notification } from '../models/data/Notification';
+import { Tweet } from '../models/data/Tweet';
+import { User } from '../models/data/User';
+import { IConversationTimelineResponse } from '../types/raw/dm/Conversation';
+import { IInboxInitialResponse } from '../types/raw/dm/InboxInitial';
+import { IInboxTimelineResponse } from '../types/raw/dm/InboxTimeline';
+import { IListMemberAddResponse } from '../types/raw/list/AddMember';
+import { IListDetailsResponse } from '../types/raw/list/Details';
+import { IListMembersResponse } from '../types/raw/list/Members';
+import { IListMemberRemoveResponse } from '../types/raw/list/RemoveMember';
+import { IListTweetsResponse } from '../types/raw/list/Tweets';
+import { IMediaInitializeUploadResponse } from '../types/raw/media/InitalizeUpload';
+import { ITweetBookmarkResponse } from '../types/raw/tweet/Bookmark';
+import { ITweetDetailsResponse } from '../types/raw/tweet/Details';
+import { ITweetDetailsBulkResponse } from '../types/raw/tweet/DetailsBulk';
+import { ITweetLikeResponse } from '../types/raw/tweet/Like';
+import { ITweetLikersResponse } from '../types/raw/tweet/Likers';
+import { ITweetPostResponse } from '../types/raw/tweet/Post';
+import { ITweetRepliesResponse } from '../types/raw/tweet/Replies';
+import { ITweetRetweetResponse } from '../types/raw/tweet/Retweet';
+import { ITweetRetweetersResponse } from '../types/raw/tweet/Retweeters';
+import { ITweetScheduleResponse } from '../types/raw/tweet/Schedule';
+import { ITweetSearchResponse } from '../types/raw/tweet/Search';
+import { ITweetUnbookmarkResponse } from '../types/raw/tweet/Unbookmark';
+import { ITweetUnlikeResponse } from '../types/raw/tweet/Unlike';
+import { ITweetUnpostResponse } from '../types/raw/tweet/Unpost';
+import { ITweetUnretweetResponse } from '../types/raw/tweet/Unretweet';
+import { ITweetUnscheduleResponse } from '../types/raw/tweet/Unschedule';
+import { IUserAffiliatesResponse } from '../types/raw/user/Affiliates';
+import { IUserAnalyticsResponse } from '../types/raw/user/Analytics';
+import { IUserBookmarkFoldersResponse } from '../types/raw/user/BookmarkFolders';
+import { IUserBookmarkFolderTweetsResponse } from '../types/raw/user/BookmarkFolderTweets';
+import { IUserBookmarksResponse } from '../types/raw/user/Bookmarks';
+import { IUserDetailsResponse } from '../types/raw/user/Details';
+import { IUserDetailsBulkResponse } from '../types/raw/user/DetailsBulk';
+import { IUserFollowResponse } from '../types/raw/user/Follow';
+import { IUserFollowedResponse } from '../types/raw/user/Followed';
+import { IUserFollowersResponse } from '../types/raw/user/Followers';
+import { IUserFollowingResponse } from '../types/raw/user/Following';
+import { IUserHighlightsResponse } from '../types/raw/user/Highlights';
+import { IUserLikesResponse } from '../types/raw/user/Likes';
+import { IUserListsResponse } from '../types/raw/user/Lists';
+import { IUserMediaResponse } from '../types/raw/user/Media';
+import { IUserNotificationsResponse } from '../types/raw/user/Notifications';
+import { IUserProfileUpdateResponse } from '../types/raw/user/ProfileUpdate';
+import { IUserRecommendedResponse } from '../types/raw/user/Recommended';
+import { IUserSearchResponse } from '../types/raw/user/Search';
+import { IUserSubscriptionsResponse } from '../types/raw/user/Subscriptions';
+import { IUserTweetsResponse } from '../types/raw/user/Tweets';
+import { IUserTweetsAndRepliesResponse } from '../types/raw/user/TweetsAndReplies';
+import { IUserUnfollowResponse } from '../types/raw/user/Unfollow';
+
+/**
+ * Collection of data extractors for each resource.
+ *
+ * @internal
+ */
+export const Extractors = {
+	/* eslint-disable @typescript-eslint/naming-convention */
+
+	LIST_DETAILS: (response: IListDetailsResponse, id: string): List | undefined => List.single(response, id),
+	LIST_MEMBERS: (response: IListMembersResponse): CursoredData<User> =>
+		new CursoredData<User>(response, BaseType.USER),
+	LIST_MEMBER_ADD: (response: IListMemberAddResponse): number | undefined =>
+		response.data?.list?.member_count ?? undefined,
+	LIST_MEMBER_REMOVE: (response: IListMemberRemoveResponse): number | undefined =>
+		response.data?.list?.member_count ?? undefined,
+	LIST_TWEETS: (response: IListTweetsResponse): CursoredData<Tweet> =>
+		new CursoredData<Tweet>(response, BaseType.TWEET),
+
+	MEDIA_UPLOAD_APPEND: (): void => undefined,
+	MEDIA_UPLOAD_FINALIZE: (): void => undefined,
+	MEDIA_UPLOAD_INITIALIZE: (response: IMediaInitializeUploadResponse): string =>
+		response.media_id_string ?? undefined,
+
+	DM_CONVERSATION: (response: IConversationTimelineResponse): Conversation | undefined =>
+		Conversation.fromConversationTimeline(response),
+	DM_INBOX_INITIAL_STATE: (response: IInboxInitialResponse): Inbox => new Inbox(response),
+	DM_INBOX_TIMELINE: (response: IInboxTimelineResponse): Inbox => new Inbox(response),
+
+	TWEET_BOOKMARK: (response: ITweetBookmarkResponse): boolean => response?.data?.tweet_bookmark_put === 'Done',
+	TWEET_DETAILS: (response: ITweetDetailsResponse, id: string): Tweet | undefined => Tweet.single(response, id),
+	TWEET_DETAILS_ALT: (response: ITweetRepliesResponse, id: string): Tweet | undefined => Tweet.single(response, id),
+	TWEET_DETAILS_BULK: (response: ITweetDetailsBulkResponse, ids: string[]): Tweet[] => Tweet.multiple(response, ids),
+	TWEET_LIKE: (response: ITweetLikeResponse): boolean => (response?.data?.favorite_tweet ? true : false),
+	TWEET_LIKERS: (response: ITweetLikersResponse): CursoredData<User> =>
+		new CursoredData<User>(response, BaseType.USER),
+	TWEET_POST: (response: ITweetPostResponse): string =>
+		response?.data?.create_tweet?.tweet_results?.result?.rest_id ?? undefined,
+	TWEET_REPLIES: (response: ITweetDetailsResponse): CursoredData<Tweet> =>
+		new CursoredData<Tweet>(response, BaseType.TWEET),
+	TWEET_RETWEET: (response: ITweetRetweetResponse): boolean => (response?.data?.create_retweet ? true : false),
+	TWEET_RETWEETERS: (response: ITweetRetweetersResponse): CursoredData<User> =>
+		new CursoredData<User>(response, BaseType.USER),
+	TWEET_SCHEDULE: (response: ITweetScheduleResponse): string => response?.data?.tweet?.rest_id ?? undefined,
+	TWEET_SEARCH: (response: ITweetSearchResponse): CursoredData<Tweet> =>
+		new CursoredData<Tweet>(response, BaseType.TWEET),
+	TWEET_UNBOOKMARK: (response: ITweetUnbookmarkResponse): boolean => response?.data?.tweet_bookmark_delete === 'Done',
+	TWEET_UNLIKE: (response: ITweetUnlikeResponse): boolean => (response?.data?.unfavorite_tweet ? true : false),
+	TWEET_UNPOST: (response: ITweetUnpostResponse): boolean => (response?.data?.delete_tweet ? true : false),
+	TWEET_UNRETWEET: (response: ITweetUnretweetResponse): boolean =>
+		response?.data?.unretweet?.source_tweet_results?.result ? true : false,
+	TWEET_UNSCHEDULE: (response: ITweetUnscheduleResponse): boolean => response?.data?.scheduledtweet_delete == 'Done',
+
+	USER_AFFILIATES: (response: IUserAffiliatesResponse): CursoredData<User> =>
+		new CursoredData<User>(response, BaseType.USER),
+	USER_ANALYTICS: (response: IUserAnalyticsResponse): Analytics =>
+		new Analytics(response.data.viewer_v2.user_results.result),
+	USER_BOOKMARKS: (response: IUserBookmarksResponse): CursoredData<Tweet> =>
+		new CursoredData<Tweet>(response, BaseType.TWEET),
+	USER_BOOKMARK_FOLDERS: (response: IUserBookmarkFoldersResponse): CursoredData<BookmarkFolder> =>
+		new CursoredData<BookmarkFolder>(response, BaseType.BOOKMARK_FOLDER),
+	USER_BOOKMARK_FOLDER_TWEETS: (response: IUserBookmarkFolderTweetsResponse): CursoredData<Tweet> =>
+		new CursoredData<Tweet>(response, BaseType.TWEET),
+	USER_DETAILS_BY_USERNAME: (response: IUserDetailsResponse): User | undefined => User.single(response),
+	USER_DETAILS_BY_ID: (response: IUserDetailsResponse): User | undefined => User.single(response),
+	USER_DETAILS_BY_IDS_BULK: (response: IUserDetailsBulkResponse, ids: string[]): User[] =>
+		User.multiple(response, ids),
+	USER_FEED_FOLLOWED: (response: IUserFollowedResponse): CursoredData<Tweet> =>
+		new CursoredData<Tweet>(response, BaseType.TWEET),
+	USER_FEED_RECOMMENDED: (response: IUserRecommendedResponse): CursoredData<Tweet> =>
+		new CursoredData<Tweet>(response, BaseType.TWEET),
+	USER_FOLLOW: (response: IUserFollowResponse): boolean => (response?.id ? true : false),
+	USER_FOLLOWING: (response: IUserFollowingResponse): CursoredData<User> =>
+		new CursoredData<User>(response, BaseType.USER),
+	USER_FOLLOWERS: (response: IUserFollowersResponse): CursoredData<User> =>
+		new CursoredData<User>(response, BaseType.USER),
+	USER_HIGHLIGHTS: (response: IUserHighlightsResponse): CursoredData<Tweet> =>
+		new CursoredData<Tweet>(response, BaseType.TWEET),
+	USER_LISTS: (response: IUserListsResponse): CursoredData<List> => new CursoredData<List>(response, BaseType.LIST),
+	USER_LIKES: (response: IUserLikesResponse): CursoredData<Tweet> =>
+		new CursoredData<Tweet>(response, BaseType.TWEET),
+	USER_MEDIA: (response: IUserMediaResponse): CursoredData<Tweet> =>
+		new CursoredData<Tweet>(response, BaseType.TWEET),
+	USER_NOTIFICATIONS: (response: IUserNotificationsResponse): CursoredData<Notification> =>
+		new CursoredData<Notification>(response, BaseType.NOTIFICATION),
+	USER_SEARCH: (response: IUserSearchResponse): CursoredData<User> => new CursoredData<User>(response, BaseType.USER),
+	USER_SUBSCRIPTIONS: (response: IUserSubscriptionsResponse): CursoredData<User> =>
+		new CursoredData<User>(response, BaseType.USER),
+	USER_TIMELINE: (response: IUserTweetsResponse): CursoredData<Tweet> =>
+		new CursoredData<Tweet>(response, BaseType.TWEET),
+	USER_TIMELINE_AND_REPLIES: (response: IUserTweetsAndRepliesResponse): CursoredData<Tweet> =>
+		new CursoredData<Tweet>(response, BaseType.TWEET),
+	USER_UNFOLLOW: (response: IUserUnfollowResponse): boolean => (response?.id ? true : false),
+	USER_PROFILE_UPDATE: (response: IUserProfileUpdateResponse): boolean => (response?.name ? true : false),
+
+	/* eslint-enable @typescript-eslint/naming-convention */
+};

package/src/collections/Groups.ts

@@ -0,0 +1,81 @@
+import { ResourceType } from '../enums/Resource';
+
+/**
+ * Collection of resources that allow guest authentication.
+ *
+ * @internal
+ */
+export const AllowGuestAuthenticationGroup = [
+	ResourceType.TWEET_DETAILS,
+	ResourceType.USER_DETAILS_BY_USERNAME,
+	ResourceType.USER_TIMELINE,
+];
+
+/**
+ * Collection of resources that can be fetched.
+ *
+ * @internal
+ */
+export const FetchResourcesGroup = [
+	ResourceType.LIST_DETAILS,
+	ResourceType.LIST_MEMBERS,
+	ResourceType.LIST_TWEETS,
+	ResourceType.DM_CONVERSATION,
+	ResourceType.DM_INBOX_INITIAL_STATE,
+	ResourceType.DM_INBOX_TIMELINE,
+	ResourceType.TWEET_DETAILS,
+	ResourceType.TWEET_DETAILS_ALT,
+	ResourceType.TWEET_DETAILS_BULK,
+	ResourceType.TWEET_LIKERS,
+	ResourceType.TWEET_REPLIES,
+	ResourceType.TWEET_RETWEETERS,
+	ResourceType.TWEET_SEARCH,
+	ResourceType.USER_AFFILIATES,
+	ResourceType.USER_ANALYTICS,
+	ResourceType.USER_BOOKMARKS,
+	ResourceType.USER_BOOKMARK_FOLDERS,
+	ResourceType.USER_BOOKMARK_FOLDER_TWEETS,
+	ResourceType.USER_DETAILS_BY_USERNAME,
+	ResourceType.USER_DETAILS_BY_ID,
+	ResourceType.USER_DETAILS_BY_IDS_BULK,
+	ResourceType.USER_FEED_FOLLOWED,
+	ResourceType.USER_FEED_RECOMMENDED,
+	ResourceType.USER_FOLLOWING,
+	ResourceType.USER_FOLLOWERS,
+	ResourceType.USER_HIGHLIGHTS,
+	ResourceType.USER_LIKES,
+	ResourceType.USER_LISTS,
+	ResourceType.USER_MEDIA,
+	ResourceType.USER_NOTIFICATIONS,
+	ResourceType.USER_SEARCH,
+	ResourceType.USER_SUBSCRIPTIONS,
+	ResourceType.USER_TIMELINE,
+	ResourceType.USER_TIMELINE_AND_REPLIES,
+];
+
+/**
+ * Collection of resources that can be posted.
+ *
+ * @internal
+ */
+export const PostResourcesGroup = [
+	ResourceType.LIST_MEMBER_ADD,
+	ResourceType.LIST_MEMBER_REMOVE,
+	ResourceType.MEDIA_UPLOAD_APPEND,
+	ResourceType.MEDIA_UPLOAD_FINALIZE,
+	ResourceType.MEDIA_UPLOAD_INITIALIZE,
+	ResourceType.DM_DELETE_CONVERSATION,
+	ResourceType.TWEET_BOOKMARK,
+	ResourceType.TWEET_LIKE,
+	ResourceType.TWEET_POST,
+	ResourceType.TWEET_RETWEET,
+	ResourceType.TWEET_SCHEDULE,
+	ResourceType.TWEET_UNBOOKMARK,
+	ResourceType.TWEET_UNLIKE,
+	ResourceType.TWEET_UNPOST,
+	ResourceType.TWEET_UNRETWEET,
+	ResourceType.TWEET_UNSCHEDULE,
+	ResourceType.USER_FOLLOW,
+	ResourceType.USER_UNFOLLOW,
+	ResourceType.USER_PROFILE_UPDATE,
+];

package/src/collections/Requests.ts

@@ -0,0 +1,89 @@
+import { ResourceType } from '../enums/Resource';
+import { DMRequests } from '../requests/DirectMessage';
+import { ListRequests } from '../requests/List';
+import { MediaRequests } from '../requests/Media';
+import { TweetRequests } from '../requests/Tweet';
+import { UserRequests } from '../requests/User';
+import { IFetchArgs } from '../types/args/FetchArgs';
+import { IPostArgs } from '../types/args/PostArgs';
+import { FetchConfig } from '../types/Fetch';
+
+import { TweetRepliesSortTypeMap } from './Tweet';
+
+/**
+ * Collection of requests to various resources.
+ *
+ * @internal
+ */
+export const Requests: { [key in keyof typeof ResourceType]: (args: IFetchArgs | IPostArgs) => FetchConfig } = {
+	/* eslint-disable @typescript-eslint/naming-convention */
+
+	LIST_DETAILS: (args: IFetchArgs) => ListRequests.details(args.id!),
+	LIST_MEMBERS: (args: IFetchArgs) => ListRequests.members(args.id!, args.count, args.cursor),
+	LIST_MEMBER_ADD: (args: IPostArgs) => ListRequests.addMember(args.id!, args.userId!),
+	LIST_MEMBER_REMOVE: (args: IPostArgs) => ListRequests.removeMember(args.id!, args.userId!),
+	LIST_TWEETS: (args: IFetchArgs) => ListRequests.tweets(args.id!, args.count, args.cursor),
+
+	MEDIA_UPLOAD_APPEND: (args: IPostArgs) => MediaRequests.appendUpload(args.upload!.id!, args.upload!.media!),
+	MEDIA_UPLOAD_FINALIZE: (args: IPostArgs) => MediaRequests.finalizeUpload(args.upload!.id!),
+	MEDIA_UPLOAD_INITIALIZE: (args: IPostArgs) => MediaRequests.initializeUpload(args.upload!.size!),
+
+	DM_CONVERSATION: (args: IFetchArgs) => DMRequests.conversation(args.conversationId!, args.maxId),
+	DM_INBOX_INITIAL_STATE: () => DMRequests.inboxInitial(),
+	DM_INBOX_TIMELINE: (args: IFetchArgs) => DMRequests.inboxTimeline(args.maxId),
+	DM_DELETE_CONVERSATION: (args: IPostArgs) => DMRequests.deleteConversation(args.conversationId!),
+
+	TWEET_BOOKMARK: (args: IPostArgs) => TweetRequests.bookmark(args.id!),
+	TWEET_DETAILS: (args: IFetchArgs) => TweetRequests.details(args.id!),
+	TWEET_DETAILS_ALT: (args: IFetchArgs) => TweetRequests.replies(args.id!),
+	TWEET_DETAILS_BULK: (args: IFetchArgs) => TweetRequests.bulkDetails(args.ids!),
+	TWEET_LIKE: (args: IPostArgs) => TweetRequests.like(args.id!),
+	TWEET_LIKERS: (args: IFetchArgs) => TweetRequests.likers(args.id!, args.count, args.cursor),
+	TWEET_POST: (args: IPostArgs) => TweetRequests.post(args.tweet!),
+	TWEET_REPLIES: (args: IFetchArgs) =>
+		TweetRequests.replies(args.id!, args.cursor, args.sortBy ? TweetRepliesSortTypeMap[args.sortBy] : undefined),
+	TWEET_RETWEET: (args: IPostArgs) => TweetRequests.retweet(args.id!),
+	TWEET_RETWEETERS: (args: IFetchArgs) => TweetRequests.retweeters(args.id!, args.count, args.cursor),
+	TWEET_SCHEDULE: (args: IPostArgs) => TweetRequests.schedule(args.tweet!),
+	TWEET_SEARCH: (args: IFetchArgs) => TweetRequests.search(args.filter!, args.count, args.cursor),
+	TWEET_UNBOOKMARK: (args: IPostArgs) => TweetRequests.unbookmark(args.id!),
+	TWEET_UNLIKE: (args: IPostArgs) => TweetRequests.unlike(args.id!),
+	TWEET_UNPOST: (args: IPostArgs) => TweetRequests.unpost(args.id!),
+	TWEET_UNRETWEET: (args: IPostArgs) => TweetRequests.unretweet(args.id!),
+	TWEET_UNSCHEDULE: (args: IPostArgs) => TweetRequests.unschedule(args.id!),
+
+	USER_AFFILIATES: (args: IFetchArgs) => UserRequests.affiliates(args.id!, args.count, args.cursor),
+	USER_ANALYTICS: (args: IFetchArgs) =>
+		UserRequests.analytics(
+			args.fromTime!,
+			args.toTime!,
+			args.granularity!,
+			args.metrics!,
+			args.showVerifiedFollowers!,
+		),
+	USER_BOOKMARKS: (args: IFetchArgs) => UserRequests.bookmarks(args.count, args.cursor),
+	USER_BOOKMARK_FOLDERS: (args: IFetchArgs) => UserRequests.bookmarkFolders(args.cursor),
+	USER_BOOKMARK_FOLDER_TWEETS: (args: IFetchArgs) =>
+		UserRequests.bookmarkFolderTweets(args.id!, args.count, args.cursor),
+	USER_DETAILS_BY_USERNAME: (args: IFetchArgs) => UserRequests.detailsByUsername(args.id!),
+	USER_DETAILS_BY_ID: (args: IFetchArgs) => UserRequests.detailsById(args.id!),
+	USER_DETAILS_BY_IDS_BULK: (args: IFetchArgs) => UserRequests.bulkDetailsByIds(args.ids!),
+	USER_FEED_FOLLOWED: (args: IFetchArgs) => UserRequests.followed(args.count, args.cursor),
+	USER_FEED_RECOMMENDED: (args: IFetchArgs) => UserRequests.recommended(args.count, args.cursor),
+	USER_FOLLOW: (args: IPostArgs) => UserRequests.follow(args.id!),
+	USER_FOLLOWING: (args: IFetchArgs) => UserRequests.following(args.id!, args.count, args.cursor),
+	USER_FOLLOWERS: (args: IFetchArgs) => UserRequests.followers(args.id!, args.count, args.cursor),
+	USER_HIGHLIGHTS: (args: IFetchArgs) => UserRequests.highlights(args.id!, args.count, args.cursor),
+	USER_LIKES: (args: IFetchArgs) => UserRequests.likes(args.id!, args.count, args.cursor),
+	USER_LISTS: (args: IFetchArgs) => UserRequests.lists(args.id!, args.count, args.cursor),
+	USER_MEDIA: (args: IFetchArgs) => UserRequests.media(args.id!, args.count, args.cursor),
+	USER_NOTIFICATIONS: (args: IFetchArgs) => UserRequests.notifications(args.count, args.cursor),
+	USER_SEARCH: (args: IFetchArgs) => UserRequests.search(args.id!, args.count, args.cursor),
+	USER_SUBSCRIPTIONS: (args: IFetchArgs) => UserRequests.subscriptions(args.id!, args.count, args.cursor),
+	USER_TIMELINE: (args: IFetchArgs) => UserRequests.tweets(args.id!, args.count, args.cursor),
+	USER_TIMELINE_AND_REPLIES: (args: IFetchArgs) => UserRequests.tweetsAndReplies(args.id!, args.count, args.cursor),
+	USER_UNFOLLOW: (args: IPostArgs) => UserRequests.unfollow(args.id!),
+	USER_PROFILE_UPDATE: (args: IPostArgs) => UserRequests.updateProfile(args.profileOptions!),
+
+	/* eslint-enable @typescript-eslint/naming-convention */
+};

package/src/collections/Tweet.ts

@@ -0,0 +1,17 @@
+import { RawTweetRepliesSortType } from '../enums/raw/Tweet';
+import { TweetRepliesSortType } from '../enums/Tweet';
+
+/**
+ * Collection of mapping from parsed reply sort type to raw reply sort type.
+ *
+ * @internal
+ */
+export const TweetRepliesSortTypeMap: { [key in keyof typeof TweetRepliesSortType]: RawTweetRepliesSortType } = {
+	/* eslint-disable @typescript-eslint/naming-convention */
+
+	LATEST: RawTweetRepliesSortType.LATEST,
+	LIKES: RawTweetRepliesSortType.LIKES,
+	RELEVANCE: RawTweetRepliesSortType.RELEVACE,
+
+	/* eslint-enable @typescript-eslint/naming-convention */
+};

package/src/commands/DirectMessage.ts

@@ -0,0 +1,62 @@
+import { Command, createCommand } from 'commander';
+
+import { output } from '../helper/CliUtils';
+import { Rettiwt } from '../Rettiwt';
+
+/**
+ * Creates a new 'dm' command which uses the given Rettiwt instance.
+ *
+ * @param rettiwt - The Rettiwt instance to use.
+ * @returns The created 'dm' command.
+ */
+function createDirectMessageCommand(rettiwt: Rettiwt): Command {
+	// Creating the 'dm' command
+	const dm = createCommand('dm').description('Access resources related to direct messages');
+
+	// Conversation
+	dm.command('conversation')
+		.description('Get the full conversation history for a specific conversation')
+		.argument('<conversation-id>', 'The ID of the conversation (e.g., "394028042-1712730991884689408")')
+		.argument('[cursor]', 'The cursor for pagination (maxId from previous response)')
+		.action(async (conversationId: string, cursor?: string) => {
+			try {
+				const conversation = await rettiwt.dm.conversation(conversationId, cursor);
+				output(conversation);
+			} catch (error) {
+				output(error);
+			}
+		});
+
+	// Delete conversation
+	dm.command('delete-conversation')
+		.description('Delete a conversation (you will leave the conversation and it will be removed from your inbox)')
+		.argument('<conversation-id>', 'The ID of the conversation to delete')
+		.action(async (conversationId: string) => {
+			try {
+				await rettiwt.dm.deleteConversation(conversationId);
+				output({ success: true, message: 'Conversation deleted successfully' });
+			} catch (error) {
+				output(error);
+			}
+		});
+
+	// Inbox
+	dm.command('inbox')
+		.description('Get your DM inbox')
+		.argument(
+			'[cursor]',
+			'The cursor to the batch of conversations to fetch. If not provided, initial inbox is fetched',
+		)
+		.action(async (cursor?: string) => {
+			try {
+				const inbox = await rettiwt.dm.inbox(cursor);
+				output(inbox);
+			} catch (error) {
+				output(error);
+			}
+		});
+
+	return dm;
+}
+
+export default createDirectMessageCommand;