@finch_ren/x-scraper 0.1.0

package/dist/src/apis/defaultApi.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultApiUtils = void 0;
+const utils_1 = require("../utils");
+class DefaultApiUtils {
+    constructor(api, flag, initOverrides) {
+        this.api = api;
+        this.flag = flag;
+        this.initOverrides = initOverrides;
+    }
+    async request(param) {
+        const apiFn = param.apiFn.bind(this.api);
+        const args = (0, utils_1.getKwargs)(this.flag[param.key], param.param);
+        const response = await apiFn(args, this.initOverrides(this.flag[param.key]));
+        const data = param.convertFn(await response.value());
+        return {
+            raw: { response: response.raw },
+            header: (0, utils_1.buildHeader)(response.raw.headers),
+            data: data,
+        };
+    }
+    async getProfileSpotlightsQuery(param) {
+        const args = { screenName: param.screenName, ...param.extraParam };
+        const response = await this.request({
+            key: 'ProfileSpotlightsQuery',
+            apiFn: this.api.getProfileSpotlightsQueryRaw,
+            convertFn: (e) => (0, utils_1.errorCheck)(e.data.userResultByScreenName, e.errors),
+            param: args,
+        });
+        return response;
+    }
+    async getTweetResultByRestId(param) {
+        const args = { tweetId: param.tweetId, ...param.extraParam };
+        const response = await this.request({
+            key: 'TweetResultByRestId',
+            apiFn: this.api.getTweetResultByRestIdRaw,
+            convertFn: (e) => (0, utils_1.errorCheck)((0, utils_1.buildTweetApiUtils)({ result: (0, utils_1.errorCheck)(e.data.tweetResult, e.errors) }), e.errors),
+            param: args,
+        });
+        return response;
+    }
+}
+exports.DefaultApiUtils = DefaultApiUtils;
+//# sourceMappingURL=defaultApi.js.map

package/dist/src/apis/index.d.ts

@@ -0,0 +1,12 @@
+export { DefaultApiUtils } from './defaultApi';
+export { InitialStateApiUtils } from './initialStateApi';
+export { PostApiUtils } from './postApi';
+export { SpaceApiUtils } from './spaceApi';
+export { TweetApiUtils } from './tweetApi';
+export { UserApiUtils } from './userApi';
+export { UserListApiUtils } from './userListApi';
+export { UsersApiUtils } from './usersApi';
+export { V11GetApiUtils } from './v11GetApi';
+export { V11PostApiUtils } from './v11PostApi';
+export { V20GetApiUtils } from './v20GetApi';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/apis/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.V20GetApiUtils = exports.V11PostApiUtils = exports.V11GetApiUtils = exports.UsersApiUtils = exports.UserListApiUtils = exports.UserApiUtils = exports.TweetApiUtils = exports.SpaceApiUtils = exports.PostApiUtils = exports.InitialStateApiUtils = exports.DefaultApiUtils = void 0;
+var defaultApi_1 = require("./defaultApi");
+Object.defineProperty(exports, "DefaultApiUtils", { enumerable: true, get: function () { return defaultApi_1.DefaultApiUtils; } });
+var initialStateApi_1 = require("./initialStateApi");
+Object.defineProperty(exports, "InitialStateApiUtils", { enumerable: true, get: function () { return initialStateApi_1.InitialStateApiUtils; } });
+var postApi_1 = require("./postApi");
+Object.defineProperty(exports, "PostApiUtils", { enumerable: true, get: function () { return postApi_1.PostApiUtils; } });
+var spaceApi_1 = require("./spaceApi");
+Object.defineProperty(exports, "SpaceApiUtils", { enumerable: true, get: function () { return spaceApi_1.SpaceApiUtils; } });
+var tweetApi_1 = require("./tweetApi");
+Object.defineProperty(exports, "TweetApiUtils", { enumerable: true, get: function () { return tweetApi_1.TweetApiUtils; } });
+var userApi_1 = require("./userApi");
+Object.defineProperty(exports, "UserApiUtils", { enumerable: true, get: function () { return userApi_1.UserApiUtils; } });
+var userListApi_1 = require("./userListApi");
+Object.defineProperty(exports, "UserListApiUtils", { enumerable: true, get: function () { return userListApi_1.UserListApiUtils; } });
+var usersApi_1 = require("./usersApi");
+Object.defineProperty(exports, "UsersApiUtils", { enumerable: true, get: function () { return usersApi_1.UsersApiUtils; } });
+var v11GetApi_1 = require("./v11GetApi");
+Object.defineProperty(exports, "V11GetApiUtils", { enumerable: true, get: function () { return v11GetApi_1.V11GetApiUtils; } });
+var v11PostApi_1 = require("./v11PostApi");
+Object.defineProperty(exports, "V11PostApiUtils", { enumerable: true, get: function () { return v11PostApi_1.V11PostApiUtils; } });
+var v20GetApi_1 = require("./v20GetApi");
+Object.defineProperty(exports, "V20GetApiUtils", { enumerable: true, get: function () { return v20GetApi_1.V20GetApiUtils; } });
+//# sourceMappingURL=index.js.map

package/dist/src/apis/initialStateApi.d.ts

@@ -0,0 +1,3 @@
+export declare class InitialStateApiUtils {
+}
+//# sourceMappingURL=initialStateApi.d.ts.map

package/dist/src/apis/initialStateApi.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InitialStateApiUtils = void 0;
+class InitialStateApiUtils {
+}
+exports.InitialStateApiUtils = InitialStateApiUtils;
+//# sourceMappingURL=initialStateApi.js.map

package/dist/src/apis/postApi.d.ts

@@ -0,0 +1,58 @@
+import { DefaultFlag, TwitterApiUtilsResponse } from '../models';
+import { InitOverridesType } from '../utils';
+import * as i from '../openapi';
+type PostCreateTweetParam = {
+    tweetText: string;
+    mediaIds?: string[];
+    taggedUsers?: string[][];
+    inReplyToTweetId?: string;
+    attachmentUrl?: string;
+    conversationControl?: 'Community' | 'Verified' | 'ByInvitation' | (string & {});
+    extraParam?: {
+        [key: string]: any;
+    };
+};
+type PostDeleteTweetParam = {
+    tweetId: string;
+    extraParam?: {
+        [key: string]: any;
+    };
+};
+type PostCreateRetweetParam = {
+    tweetId: string;
+    extraParam?: {
+        [key: string]: any;
+    };
+};
+type PostDeleteRetweetParam = {
+    sourceTweetId: string;
+    extraParam?: {
+        [key: string]: any;
+    };
+};
+type PostFavoriteTweetParam = {
+    tweetId: string;
+    extraParam?: {
+        [key: string]: any;
+    };
+};
+type PostUnfavoriteTweetParam = {
+    tweetId: string;
+    extraParam?: {
+        [key: string]: any;
+    };
+};
+export declare class PostApiUtils {
+    api: i.PostApi;
+    flag: DefaultFlag;
+    initOverrides: InitOverridesType;
+    constructor(api: i.PostApi, flag: DefaultFlag, initOverrides: InitOverridesType);
+    postCreateTweet(param: PostCreateTweetParam): Promise<TwitterApiUtilsResponse<i.CreateTweetResponse>>;
+    postDeleteTweet(param: PostDeleteTweetParam): Promise<TwitterApiUtilsResponse<i.DeleteTweetResponse>>;
+    postCreateRetweet(param: PostCreateRetweetParam): Promise<TwitterApiUtilsResponse<i.CreateRetweetResponse>>;
+    postDeleteRetweet(param: PostDeleteRetweetParam): Promise<TwitterApiUtilsResponse<i.DeleteRetweetResponse>>;
+    postFavoriteTweet(param: PostFavoriteTweetParam): Promise<TwitterApiUtilsResponse<i.FavoriteTweetResponse>>;
+    postUnfavoriteTweet(param: PostUnfavoriteTweetParam): Promise<TwitterApiUtilsResponse<i.UnfavoriteTweetResponse>>;
+}
+export {};
+//# sourceMappingURL=postApi.d.ts.map

package/dist/src/apis/postApi.js

@@ -0,0 +1,130 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostApiUtils = void 0;
+const utils_1 = require("../utils");
+const i = __importStar(require("../openapi"));
+class PostApiUtils {
+    constructor(api, flag, initOverrides) {
+        this.api = api;
+        this.flag = flag;
+        this.initOverrides = initOverrides;
+    }
+    async postCreateTweet(param) {
+        const args = { tweetText: param.tweetText, ...param.extraParam };
+        const queryId = 'CreateTweet';
+        const features = i.PostCreateTweetRequestFeaturesFromJSON(this.flag[queryId]['features']);
+        const variables = i.PostCreateTweetRequestVariablesFromJSON(this.flag[queryId]['variables']);
+        if (param.mediaIds) {
+            variables.media.mediaEntities = param.mediaIds.map((mediaId, index) => ({
+                mediaId,
+                taggedUsers: param.taggedUsers?.[index] || [],
+            }));
+        }
+        variables.attachmentUrl = param.attachmentUrl;
+        if (param.conversationControl) {
+            variables.conversationControl = { mode: param.conversationControl };
+        }
+        if (param.inReplyToTweetId) {
+            variables.reply = { excludeReplyUserIds: [], inReplyToTweetId: param.inReplyToTweetId };
+        }
+        variables.disallowedReplyOptions = null;
+        const response = await this.api.postCreateTweetRaw({
+            pathQueryId: this.flag[queryId]['queryId'],
+            postCreateTweetRequest: {
+                queryId: this.flag[queryId]['queryId'],
+                features,
+                variables: { ...variables, ...args },
+            },
+        });
+        return {
+            raw: { response: response.raw },
+            header: (0, utils_1.buildHeader)(response.raw.headers),
+            data: await response.value(),
+        };
+    }
+    async postDeleteTweet(param) {
+        const args = { tweetId: param.tweetId, ...param.extraParam };
+        const queryId = 'DeleteTweet';
+        const variables = i.PostCreateRetweetRequestVariablesFromJSON(this.flag[queryId]['variables']);
+        const response = await this.api.postDeleteTweetRaw({
+            pathQueryId: this.flag[queryId]['queryId'],
+            postDeleteTweetRequest: { queryId: this.flag[queryId]['queryId'], variables: { ...variables, ...args } },
+        });
+        return { raw: { response: response.raw }, header: (0, utils_1.buildHeader)(response.raw.headers), data: await response.value() };
+    }
+    async postCreateRetweet(param) {
+        const args = { tweetId: param.tweetId, ...param.extraParam };
+        const queryId = 'CreateRetweet';
+        const variables = i.PostCreateRetweetRequestVariablesFromJSON(this.flag[queryId]['variables']);
+        const response = await this.api.postCreateRetweetRaw({
+            pathQueryId: this.flag[queryId]['queryId'],
+            postCreateRetweetRequest: { queryId: this.flag[queryId]['queryId'], variables: { ...variables, ...args } },
+        });
+        return { raw: { response: response.raw }, header: (0, utils_1.buildHeader)(response.raw.headers), data: await response.value() };
+    }
+    async postDeleteRetweet(param) {
+        const args = { sourceTweetId: param.sourceTweetId, ...param.extraParam };
+        const queryId = 'DeleteRetweet';
+        const variables = i.PostDeleteRetweetRequestVariablesFromJSON(this.flag[queryId]['variables']);
+        const response = await this.api.postDeleteRetweetRaw({
+            pathQueryId: this.flag[queryId]['queryId'],
+            postDeleteRetweetRequest: { queryId: this.flag[queryId]['queryId'], variables: { ...variables, ...args } },
+        });
+        return { raw: { response: response.raw }, header: (0, utils_1.buildHeader)(response.raw.headers), data: await response.value() };
+    }
+    async postFavoriteTweet(param) {
+        const args = { tweetId: param.tweetId, ...param.extraParam };
+        const queryId = 'FavoriteTweet';
+        const variables = i.PostCreateRetweetRequestVariablesFromJSON(this.flag[queryId]['variables']);
+        const response = await this.api.postFavoriteTweetRaw({
+            pathQueryId: this.flag[queryId]['queryId'],
+            postFavoriteTweetRequest: { queryId: this.flag[queryId]['queryId'], variables: { ...variables, ...args } },
+        });
+        return { raw: { response: response.raw }, header: (0, utils_1.buildHeader)(response.raw.headers), data: await response.value() };
+    }
+    async postUnfavoriteTweet(param) {
+        const args = { tweetId: param.tweetId, ...param.extraParam };
+        const queryId = 'UnfavoriteTweet';
+        const variables = i.PostCreateRetweetRequestVariablesFromJSON(this.flag[queryId]['variables']);
+        const response = await this.api.postUnfavoriteTweetRaw({
+            pathQueryId: this.flag[queryId]['queryId'],
+            postUnfavoriteTweetRequest: { queryId: this.flag[queryId]['queryId'], variables: { ...variables, ...args } },
+        });
+        return { raw: { response: response.raw }, header: (0, utils_1.buildHeader)(response.raw.headers), data: await response.value() };
+    }
+}
+exports.PostApiUtils = PostApiUtils;
+//# sourceMappingURL=postApi.js.map

package/dist/src/apis/spaceApi.d.ts

@@ -0,0 +1,28 @@
+import { DefaultFlag, TwitterApiUtilsResponse } from '../models';
+import { InitOverridesType } from '../utils';
+import * as i from '../openapi';
+type GetAudioSpaceByIdParam = {
+    id: string;
+    isMetatagsQuery?: boolean;
+    withReplays?: boolean;
+    withListeners?: boolean;
+    extraParam?: {
+        [key: string]: any;
+    };
+};
+type GetBroadcastQueryParam = {
+    id: string;
+    extraParam?: {
+        [key: string]: any;
+    };
+};
+export declare class SpaceApiUtils {
+    api: i.OtherApi;
+    flag: DefaultFlag;
+    initOverrides: InitOverridesType;
+    constructor(api: i.OtherApi, flag: DefaultFlag, initOverrides: InitOverridesType);
+    getAudioSpaceById(param: GetAudioSpaceByIdParam): Promise<TwitterApiUtilsResponse<i.AudioSpaceByIdResponse>>;
+    getBroadcastQuery(param: GetBroadcastQueryParam): Promise<TwitterApiUtilsResponse<i.BroadcastQueryResponse>>;
+}
+export {};
+//# sourceMappingURL=spaceApi.d.ts.map

package/dist/src/apis/spaceApi.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpaceApiUtils = void 0;
+const utils_1 = require("../utils");
+class SpaceApiUtils {
+    constructor(api, flag, initOverrides) {
+        this.api = api;
+        this.flag = flag;
+        this.initOverrides = initOverrides;
+    }
+    async getAudioSpaceById(param) {
+        const args = {
+            id: param.id,
+            ...(param.isMetatagsQuery !== undefined ? { isMetatagsQuery: param.isMetatagsQuery } : {}),
+            ...(param.withReplays !== undefined ? { withReplays: param.withReplays } : {}),
+            ...(param.withListeners !== undefined ? { withListeners: param.withListeners } : {}),
+            ...param.extraParam,
+        };
+        const kwargs = (0, utils_1.getKwargs)(this.flag['AudioSpaceById'], args);
+        const response = await this.api.getAudioSpaceByIdRaw(kwargs, this.initOverrides(this.flag['AudioSpaceById']));
+        return {
+            raw: { response: response.raw },
+            header: (0, utils_1.buildHeader)(response.raw.headers),
+            data: await response.value(),
+        };
+    }
+    async getBroadcastQuery(param) {
+        const args = {
+            id: param.id,
+            ...param.extraParam,
+        };
+        const kwargs = (0, utils_1.getKwargs)(this.flag['BroadcastQuery'], args);
+        const response = await this.api.getBroadcastQueryRaw(kwargs, this.initOverrides(this.flag['BroadcastQuery']));
+        return {
+            raw: { response: response.raw },
+            header: (0, utils_1.buildHeader)(response.raw.headers),
+            data: await response.value(),
+        };
+    }
+}
+exports.SpaceApiUtils = SpaceApiUtils;
+//# sourceMappingURL=spaceApi.js.map

package/dist/src/apis/tweetApi.d.ts

@@ -0,0 +1,118 @@
+import { DefaultFlag, RequestParam, TimelineApiUtilsResponse, TweetApiUtilsData, TwitterApiUtilsResponse } from '../models';
+import { InitOverridesType } from '../utils';
+import * as i from '../openapi';
+type GetTweetDetailParam = {
+    focalTweetId: string;
+    cursor?: string;
+    controllerData?: string;
+    extraParam?: {
+        [key: string]: any;
+    };
+};
+type GetSearchTimelineParam = {
+    rawQuery: string;
+    product?: 'Top' | 'Latest' | 'People' | 'Photos' | 'Videos' | (string & {});
+    cursor?: string;
+    count?: number;
+    extraParam?: {
+        [key: string]: any;
+    };
+};
+type GetHomeTimelineParam = {
+    cursor?: string;
+    count?: number;
+    extraParam?: {
+        [key: string]: any;
+    };
+};
+type GetHomeLatestTimelineParam = {
+    cursor?: string;
+    count?: number;
+    extraParam?: {
+        [key: string]: any;
+    };
+};
+type GetListLatestTweetsTimelineParam = {
+    listId: string;
+    cursor?: string;
+    count?: number;
+    extraParam?: {
+        [key: string]: any;
+    };
+};
+type GetUserTweetsParam = {
+    userId: string;
+    cursor?: string;
+    count?: number;
+    extraParam?: {
+        [key: string]: any;
+    };
+};
+type GetUserTweetsAndRepliesParam = {
+    userId: string;
+    cursor?: string;
+    count?: number;
+    extraParam?: {
+        [key: string]: any;
+    };
+};
+type GetUserMediaParam = {
+    userId: string;
+    cursor?: string;
+    count?: number;
+    extraParam?: {
+        [key: string]: any;
+    };
+};
+type GetLikesParam = {
+    userId: string;
+    cursor?: string;
+    count?: number;
+    extraParam?: {
+        [key: string]: any;
+    };
+};
+type GetBookmarksParam = {
+    cursor?: string;
+    count?: number;
+    extraParam?: {
+        [key: string]: any;
+    };
+};
+type GetCommunityTweetsTimelineParam = {
+    cursor?: string;
+    count?: number;
+    rankingMode?: 'Recency' | 'Relevance' | (string & {});
+    extraParam?: {
+        [key: string]: any;
+    };
+};
+type GetCommunityMediaTimelineParam = {
+    cursor?: string;
+    count?: number;
+    extraParam?: {
+        [key: string]: any;
+    };
+};
+type ResponseType = TwitterApiUtilsResponse<TimelineApiUtilsResponse<TweetApiUtilsData>>;
+export declare class TweetApiUtils {
+    api: i.TweetApi;
+    flag: DefaultFlag;
+    initOverrides: InitOverridesType;
+    constructor(api: i.TweetApi, flag: DefaultFlag, initOverrides: InitOverridesType);
+    request<T>(param: RequestParam<i.InstructionUnion[], T>): Promise<ResponseType>;
+    getTweetDetail(param: GetTweetDetailParam): Promise<ResponseType>;
+    getSearchTimeline(param: GetSearchTimelineParam): Promise<ResponseType>;
+    getHomeTimeline(param?: GetHomeTimelineParam): Promise<ResponseType>;
+    getHomeLatestTimeline(param?: GetHomeLatestTimelineParam): Promise<ResponseType>;
+    getListLatestTweetsTimeline(param: GetListLatestTweetsTimelineParam): Promise<ResponseType>;
+    getUserTweets(param: GetUserTweetsParam): Promise<ResponseType>;
+    getUserTweetsAndReplies(param: GetUserTweetsAndRepliesParam): Promise<ResponseType>;
+    getUserMedia(param: GetUserMediaParam): Promise<ResponseType>;
+    getLikes(param: GetLikesParam): Promise<ResponseType>;
+    getBookmarks(param?: GetBookmarksParam): Promise<ResponseType>;
+    getCommunityTweetsTimeline(param?: GetCommunityTweetsTimelineParam): Promise<ResponseType>;
+    getCommunityMediaTimeline(param?: GetCommunityMediaTimelineParam): Promise<ResponseType>;
+}
+export {};
+//# sourceMappingURL=tweetApi.d.ts.map

package/dist/src/apis/tweetApi.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TweetApiUtils = void 0;
+const utils_1 = require("../utils");
+class TweetApiUtils {
+    constructor(api, flag, initOverrides) {
+        this.api = api;
+        this.flag = flag;
+        this.initOverrides = initOverrides;
+    }
+    async request(param) {
+        const apiFn = param.apiFn.bind(this.api);
+        const args = (0, utils_1.getKwargs)(this.flag[param.key], param.param);
+        const response = await apiFn(args, this.initOverrides(this.flag[param.key]));
+        const instruction = param.convertFn(await response.value());
+        const entry = (0, utils_1.instructionToEntry)(instruction);
+        const data = [...(0, utils_1.tweetEntriesConverter)(entry), ...(0, utils_1.instructionConverter)(instruction)];
+        return {
+            raw: { response: response.raw },
+            header: (0, utils_1.buildHeader)(response.raw.headers),
+            data: {
+                raw: { instruction, entry },
+                cursor: (0, utils_1.entriesCursor)(entry),
+                data: data,
+            },
+        };
+    }
+    async getTweetDetail(param) {
+        const args = {
+            focalTweetId: param.focalTweetId,
+            ...(param.cursor == undefined ? {} : { cursor: param.cursor }),
+            ...(param.controllerData == undefined ? {} : { controller_data: param.controllerData }),
+            ...param.extraParam,
+        };
+        return this.request({
+            apiFn: this.api.getTweetDetailRaw,
+            convertFn: (e) => (0, utils_1.errorCheck)(e.data.threadedConversationWithInjectionsV2, e.errors).instructions,
+            key: 'TweetDetail',
+            param: args,
+        });
+    }
+    async getSearchTimeline(param) {
+        const args = {
+            rawQuery: param.rawQuery,
+            ...(param.product == undefined ? {} : { product: param.product }),
+            ...(param.cursor == undefined ? {} : { cursor: param.cursor }),
+            ...(param.count == undefined ? {} : { count: param.count }),
+            ...param.extraParam,
+        };
+        return this.request({
+            apiFn: this.api.getSearchTimelineRaw,
+            convertFn: (e) => (0, utils_1.errorCheck)(e.data.searchByRawQuery, e.errors).searchTimeline.timeline.instructions,
+            key: 'SearchTimeline',
+            param: args,
+        });
+    }
+    async getHomeTimeline(param = {}) {
+        const args = {
+            ...(param.count == undefined ? {} : { count: param.count }),
+            ...(param.cursor == undefined ? {} : { cursor: param.cursor }),
+            ...param.extraParam,
+        };
+        return this.request({
+            apiFn: this.api.getHomeTimelineRaw,
+            convertFn: (e) => (0, utils_1.errorCheck)(e.data.home, e.errors).homeTimelineUrt.instructions,
+            key: 'HomeTimeline',
+            param: args,
+        });
+    }
+    async getHomeLatestTimeline(param = {}) {
+        const args = {
+            ...(param.count == undefined ? {} : { count: param.count }),
+            ...(param.cursor == undefined ? {} : { cursor: param.cursor }),
+            ...param.extraParam,
+        };
+        return this.request({
+            apiFn: this.api.getHomeLatestTimelineRaw,
+            convertFn: (e) => (0, utils_1.errorCheck)(e.data.home, e.errors).homeTimelineUrt.instructions,
+            key: 'HomeLatestTimeline',
+            param: args,
+        });
+    }
+    async getListLatestTweetsTimeline(param) {
+        const args = {
+            listId: param.listId,
+            ...(param.count == undefined ? {} : { count: param.count }),
+            ...(param.cursor == undefined ? {} : { cursor: param.cursor }),
+            ...param.extraParam,
+        };
+        return this.request({
+            apiFn: this.api.getListLatestTweetsTimelineRaw,
+            convertFn: (e) => (0, utils_1.errorCheck)(e.data.list?.tweetsTimeline.timeline, e.errors).instructions,
+            key: 'ListLatestTweetsTimeline',
+            param: args,
+        });
+    }
+    async getUserTweets(param) {
+        const args = {
+            userId: param.userId,
+            ...(param.count == undefined ? {} : { count: param.count }),
+            ...(param.cursor == undefined ? {} : { cursor: param.cursor }),
+            ...param.extraParam,
+        };
+        return this.request({
+            apiFn: this.api.getUserTweetsRaw,
+            convertFn: (e) => (0, utils_1.errorCheck)(e.data.user?.result.timeline.timeline, e.errors).instructions,
+            key: 'UserTweets',
+            param: args,
+        });
+    }
+    async getUserTweetsAndReplies(param) {
+        const args = {
+            userId: param.userId,
+            ...(param.count == undefined ? {} : { count: param.count }),
+            ...(param.cursor == undefined ? {} : { cursor: param.cursor }),
+            ...param.extraParam,
+        };
+        return this.request({
+            apiFn: this.api.getUserTweetsAndRepliesRaw,
+            convertFn: (e) => (0, utils_1.errorCheck)(e.data.user?.result.timeline.timeline, e.errors).instructions,
+            key: 'UserTweetsAndReplies',
+            param: args,
+        });
+    }
+    async getUserMedia(param) {
+        const args = {
+            userId: param.userId,
+            ...(param.count == undefined ? {} : { count: param.count }),
+            ...(param.cursor == undefined ? {} : { cursor: param.cursor }),
+            ...param.extraParam,
+        };
+        return this.request({
+            apiFn: this.api.getUserMediaRaw,
+            convertFn: (e) => (0, utils_1.errorCheck)(e.data.user?.result.timeline.timeline, e.errors).instructions,
+            key: 'UserMedia',
+            param: args,
+        });
+    }
+    async getLikes(param) {
+        const args = {
+            userId: param.userId,
+            ...(param.count == undefined ? {} : { count: param.count }),
+            ...(param.cursor == undefined ? {} : { cursor: param.cursor }),
+            ...param.extraParam,
+        };
+        return this.request({
+            apiFn: this.api.getLikesRaw,
+            convertFn: (e) => (0, utils_1.errorCheck)(e.data.user?.result.timeline.timeline, e.errors).instructions,
+            key: 'Likes',
+            param: args,
+        });
+    }
+    async getBookmarks(param = {}) {
+        const args = {
+            ...(param.count == undefined ? {} : { count: param.count }),
+            ...(param.cursor == undefined ? {} : { cursor: param.cursor }),
+            ...param.extraParam,
+        };
+        return this.request({
+            apiFn: this.api.getBookmarksRaw,
+            convertFn: (e) => (0, utils_1.errorCheck)(e.data?.bookmarkTimelineV2.timeline, e.errors).instructions,
+            key: 'Bookmarks',
+            param: args,
+        });
+    }
+    async getCommunityTweetsTimeline(param = {}) {
+        const args = {
+            ...(param.count == undefined ? {} : { count: param.count }),
+            ...(param.cursor == undefined ? {} : { cursor: param.cursor }),
+            ...(param.rankingMode == undefined ? {} : { rankingMode: param.rankingMode }),
+            ...param.extraParam,
+        };
+        return this.request({
+            apiFn: this.api.getCommunityTweetsTimelineRaw,
+            convertFn: (e) => (0, utils_1.errorCheck)(e.data?.communityResults.result.rankedCommunityTimeline.timeline, e.errors).instructions,
+            key: 'CommunityTweetsTimeline',
+            param: args,
+        });
+    }
+    async getCommunityMediaTimeline(param = {}) {
+        const args = {
+            ...(param.count == undefined ? {} : { count: param.count }),
+            ...(param.cursor == undefined ? {} : { cursor: param.cursor }),
+            ...param.extraParam,
+        };
+        return this.request({
+            apiFn: this.api.getCommunityMediaTimelineRaw,
+            convertFn: (e) => (0, utils_1.errorCheck)(e.data?.communityResults.result.communityMediaTimeline.timeline, e.errors).instructions,
+            key: 'CommunityMediaTimeline',
+            param: args,
+        });
+    }
+}
+exports.TweetApiUtils = TweetApiUtils;
+//# sourceMappingURL=tweetApi.js.map