@finch_ren/x-scraper 0.1.0

package/README.md

@@ -0,0 +1,215 @@
+# x-scraper
+
+`x-scraper` 是一个面向 X/Twitter 内部 GraphQL 接口的 TypeScript SDK。  
+重点是让常见场景开箱即用，同时保持类型清晰、便于扩展。
+
+## 特性
+
+- 自动 Guest Token 初始化（无需手动配置 token）
+- 支持 Cookie 登录态客户端
+- 面向常用场景提供开箱即用调用入口（用户、推文、互动等）
+
+## 快速开始
+
+### Guest 模式
+
+```ts
+import { XScraper } from '@finch_ren/x-scraper';
+
+async function main() {
+  const scraper = new XScraper();
+  const client = await scraper.getGuestClient();
+
+  const user = await client.getUserByScreenName({ screenName: 'elonmusk' });
+  console.log(user.data?.user?.legacy?.screenName);
+
+  const tweets = await client.getUserTweets({ userId: '44196397' });
+  console.log(tweets.raw.response.status);
+}
+
+main().catch(console.error);
+```
+
+### Cookie 模式
+
+方式 A：浏览器导出的 Cookie 数组
+
+```ts
+import { XScraper } from '@finch_ren/x-scraper';
+
+async function main() {
+  const scraper = new XScraper();
+
+  const client = await scraper.getClientFromCookies([
+    {
+      domain: '.x.com',
+      name: 'ct0',
+      value: '<csrf_token>',
+    },
+    {
+      domain: '.x.com',
+      name: 'auth_token',
+      value: '<auth_token>',
+    },
+    ...
+  ]);
+
+  const profile = await client.getUserByScreenName({ screenName: 'jack' });
+  console.log(profile.raw.response.status);
+}
+
+main().catch(console.error);
+```
+
+方式 B：对象映射（`name -> value`）
+
+```ts
+import { XScraper } from '@finch_ren/x-scraper';
+
+async function main() {
+  const scraper = new XScraper();
+
+  const client = await scraper.getClientFromCookies({
+    ct0: '<csrf_token>',
+    auth_token: '<auth_token>',
+    ....
+  });
+
+  const profile = await client.getUserByScreenName({ screenName: 'jack' });
+  console.log(profile.raw.response.status);
+}
+
+main().catch(console.error);
+```
+
+## 常用 API 入口
+
+同一能力通常有两种调用方式：
+
+- 顶层快捷方法：`client.getUserByScreenName(...)`
+- 分组方法：`client.user.getUserByScreenName(...)`
+
+### 两种写法对照（等价）
+
+```ts
+// User
+const userA = await client.getUserByScreenName({ screenName: 'elonmusk' });
+const userB = await client.user.getUserByScreenName({ screenName: 'elonmusk' });
+
+// Tweet timeline
+const tweetsA = await client.getUserTweets({ userId: '44196397' });
+const tweetsB = await client.tweet.getUserTweets({ userId: '44196397' });
+
+// Post actions
+await client.createTweet({ tweetText: 'hello' });
+await client.post.postCreateTweet({ tweetText: 'hello' });
+```
+
+### 顶层快捷方法（高频） 
+
+- `client.getUserByScreenName(...)`
+- `client.getUserTweets(...)`
+- `client.getTweetDetail(...)`
+- `client.createTweet(...)`
+- `client.deleteTweet(...)`
+- `client.likeTweet(...)`
+- `client.unlikeTweet(...)`
+- `client.retweet(...)`
+....
+
+### 分组 API（完整入口）
+
+- `client.tweet`
+- `client.user`
+- `client.users`
+- `client.userList`
+- `client.post`
+- `client.space`
+- `client.v11Get`
+- `client.v11Post`
+- `client.v20Get`
+- `client.default`
+- `client.initialState`
+....
+
+## 认证与环境说明
+
+### 1) 关于 Cookie
+
+- 推荐从已登录浏览器导出 `ct0` / `auth_token`（可选 `gt`）。
+- `getClientFromCookies` 支持两种格式：对象映射或浏览器 cookie 数组。
+- 不要把 Cookie 写入仓库，建议走本地文件或环境变量注入。
+
+### 2) 平台 Header 一致性
+
+某些账号 Cookie 与 `sec-ch-ua-platform` 不一致时可能失败，可手动覆盖：
+
+```ts
+import { XScraper } from '@finch_ren/x-scraper';
+
+const scraper = new XScraper();
+scraper.setAdditionalApiHeaders({
+  'sec-ch-ua-platform': '"Windows"',
+});
+```
+
+### 3) 风险与限制
+
+- 该库依赖 X 私有接口，接口字段和行为可能随时变化。
+- 登录态调用存在账号风控风险，请自行评估并使用低风险账号。
+- 可能触发动态限流，建议在业务侧做重试与退避（backoff）。
+
+## 本地开发
+
+```bash
+pnpm install
+pnpm build
+pnpm test
+```
+
+## 重新生成 OpenAPI 代码
+
+```bash
+pnpm generate
+```
+
+## openapi/placeholder.json 说明
+
+`openapi/placeholder.json` 是运行时使用的 GraphQL 操作模板表，不是普通示例文件。  
+SDK 会在请求时读取这里的配置来组装参数与请求上下文。
+
+每个条目通常包含：
+
+- `@path`：接口路径（用于 transaction id 生成等）
+- `@method`：HTTP 方法（用于 transaction id 生成等）
+- `queryId`：GraphQL queryId
+- `variables`：默认变量模板（可被调用参数覆盖）
+- `features` / `fieldToggles`：默认开关参数
+
+代码关联关系：
+
+- `src/api.ts` 会加载该文件作为 `flagData`
+- `src/utils/api.ts#getKwargs` 会把 `variables/features/fieldToggles` 转成请求参数
+- 各 API utils（如 `client.tweet.*`、`client.user.*`、`client.space.*`）通过 `this.flag[...]` 取对应模板
+
+注意：
+
+- `client.space.getAudioSpaceById` 与 `client.space.getBroadcastQuery` 依赖该文件条目
+- `client.getLiveVideoStreamStatus`（v1.1 接口）不依赖 `placeholder.json`
+
+## 鸣谢
+
+本项目核心代码来源于：
+
+- [fa0311/twitter-openapi-typescript](https://github.com/fa0311/twitter-openapi-typescript)
+
+在上游基础上，本项目做了工程整合与二次封装，包括：
+
+- 整合 `twitter-openapi` 相关生成内容到当前 SDK 结构
+- 提供更直接的调用入口与项目化组织方式
+
+另外补充了 Space 相关接口能力（`client.space`）：
+
+- `getAudioSpaceById`
+- `getLiveVideoStreamStatus`
+- `getBroadcastQuery`

package/dist/src/api.d.ts

@@ -0,0 +1,156 @@
+import { DefaultApiUtils, InitialStateApiUtils, PostApiUtils, SpaceApiUtils, TweetApiUtils, UserApiUtils, UserListApiUtils, UsersApiUtils, V11GetApiUtils, V11PostApiUtils, V20GetApiUtils } from './apis';
+import type { DefaultFlag } from './models';
+import { InitOverridesType } from './utils';
+import * as i from './openapi';
+export type XScraperCookieMap = {
+    [key: string]: string;
+};
+export type XScraperBrowserCookie = {
+    name: string;
+    value: string;
+    domain?: string;
+};
+export type XScraperCookiesInput = XScraperCookieMap | XScraperBrowserCookie[];
+export declare class XScraper {
+    static header: string;
+    static twitter: string;
+    static bearer: string;
+    static fetchApi: i.FetchAPI;
+    additionalBrowserHeaders: {
+        [key: string]: string;
+    };
+    additionalApiHeaders: {
+        [key: string]: string;
+    };
+    setAdditionalBrowserHeaders(headers: {
+        [key: string]: string;
+    }): void;
+    setAdditionalApiHeaders(headers: {
+        [key: string]: string;
+    }): void;
+    getHeaders(): Promise<{
+        api: {
+            [key: string]: string;
+        };
+        browser: {
+            [key: string]: string;
+        };
+    }>;
+    cookieNormalize(cookie: string[]): XScraperCookieMap;
+    cookieEncode(cookie: XScraperCookieMap): string;
+    private normalizeCookiesInput;
+    setCookies(context: i.RequestContext, cookies: XScraperCookieMap): i.RequestContext;
+    getGuestClient(): Promise<XScraperClient>;
+    getClientFromCookies(cookies: XScraperCookiesInput): Promise<XScraperClient>;
+    getClient(config: i.Configuration): Promise<XScraperClient>;
+}
+export declare class XScraperClient {
+    readonly config: i.Configuration;
+    readonly flag: DefaultFlag;
+    readonly initOverrides: InitOverridesType;
+    readonly tweet: TweetApiUtils;
+    readonly user: UserApiUtils;
+    readonly users: UsersApiUtils;
+    readonly userList: UserListApiUtils;
+    readonly post: PostApiUtils;
+    readonly space: SpaceApiUtils;
+    readonly v11Get: V11GetApiUtils;
+    readonly v11Post: V11PostApiUtils;
+    readonly v20Get: V20GetApiUtils;
+    readonly default: DefaultApiUtils;
+    readonly initialState: InitialStateApiUtils;
+    constructor(config: i.Configuration, flag: DefaultFlag, initOverrides: InitOverridesType);
+    getUserByScreenName: (...args: Parameters<UserApiUtils["getUserByScreenName"]>) => Promise<{
+        raw: import("./models").TwitterApiUtilsRaw;
+        header: import("./models").ApiUtilsHeader;
+        data: import("./models").UserApiUtilsData;
+    }>;
+    getUserByRestId: (...args: Parameters<UserApiUtils["getUserByRestId"]>) => Promise<{
+        raw: import("./models").TwitterApiUtilsRaw;
+        header: import("./models").ApiUtilsHeader;
+        data: import("./models").UserApiUtilsData;
+    }>;
+    getUsersByRestIds: (...args: Parameters<UsersApiUtils["getUsersByRestIds"]>) => Promise<{
+        raw: import("./models").TwitterApiUtilsRaw;
+        header: import("./models").ApiUtilsHeader;
+        data: import("./models").UserApiUtilsData[];
+    }>;
+    getTweetDetail: (...args: Parameters<TweetApiUtils["getTweetDetail"]>) => Promise<{
+        raw: import("./models").TwitterApiUtilsRaw;
+        header: import("./models").ApiUtilsHeader;
+        data: import("./models").TimelineApiUtilsResponse<import("./models").TweetApiUtilsData>;
+    }>;
+    getTweetByRestId: (...args: Parameters<DefaultApiUtils["getTweetResultByRestId"]>) => Promise<import("./models").TwitterApiUtilsResponse<import("./models").TweetApiUtilsData | undefined>>;
+    getUserTweets: (...args: Parameters<TweetApiUtils["getUserTweets"]>) => Promise<{
+        raw: import("./models").TwitterApiUtilsRaw;
+        header: import("./models").ApiUtilsHeader;
+        data: import("./models").TimelineApiUtilsResponse<import("./models").TweetApiUtilsData>;
+    }>;
+    getUserMedia: (...args: Parameters<TweetApiUtils["getUserMedia"]>) => Promise<{
+        raw: import("./models").TwitterApiUtilsRaw;
+        header: import("./models").ApiUtilsHeader;
+        data: import("./models").TimelineApiUtilsResponse<import("./models").TweetApiUtilsData>;
+    }>;
+    getLikes: (...args: Parameters<TweetApiUtils["getLikes"]>) => Promise<{
+        raw: import("./models").TwitterApiUtilsRaw;
+        header: import("./models").ApiUtilsHeader;
+        data: import("./models").TimelineApiUtilsResponse<import("./models").TweetApiUtilsData>;
+    }>;
+    getBookmarks: (...args: Parameters<TweetApiUtils["getBookmarks"]>) => Promise<{
+        raw: import("./models").TwitterApiUtilsRaw;
+        header: import("./models").ApiUtilsHeader;
+        data: import("./models").TimelineApiUtilsResponse<import("./models").TweetApiUtilsData>;
+    }>;
+    getHomeTimeline: (...args: Parameters<TweetApiUtils["getHomeTimeline"]>) => Promise<{
+        raw: import("./models").TwitterApiUtilsRaw;
+        header: import("./models").ApiUtilsHeader;
+        data: import("./models").TimelineApiUtilsResponse<import("./models").TweetApiUtilsData>;
+    }>;
+    getHomeLatestTimeline: (...args: Parameters<TweetApiUtils["getHomeLatestTimeline"]>) => Promise<{
+        raw: import("./models").TwitterApiUtilsRaw;
+        header: import("./models").ApiUtilsHeader;
+        data: import("./models").TimelineApiUtilsResponse<import("./models").TweetApiUtilsData>;
+    }>;
+    searchTimeline: (...args: Parameters<TweetApiUtils["getSearchTimeline"]>) => Promise<{
+        raw: import("./models").TwitterApiUtilsRaw;
+        header: import("./models").ApiUtilsHeader;
+        data: import("./models").TimelineApiUtilsResponse<import("./models").TweetApiUtilsData>;
+    }>;
+    getFollowers: (...args: Parameters<UserListApiUtils["getFollowers"]>) => Promise<{
+        raw: import("./models").TwitterApiUtilsRaw;
+        header: import("./models").ApiUtilsHeader;
+        data: import("./models").TimelineApiUtilsResponse<import("./models").UserApiUtilsData>;
+    }>;
+    getBlueVerifiedFollowers: (...args: Parameters<UserListApiUtils["getBlueVerifiedFollowers"]>) => Promise<{
+        raw: import("./models").TwitterApiUtilsRaw;
+        header: import("./models").ApiUtilsHeader;
+        data: import("./models").TimelineApiUtilsResponse<import("./models").UserApiUtilsData>;
+    }>;
+    getFollowing: (...args: Parameters<UserListApiUtils["getFollowing"]>) => Promise<{
+        raw: import("./models").TwitterApiUtilsRaw;
+        header: import("./models").ApiUtilsHeader;
+        data: import("./models").TimelineApiUtilsResponse<import("./models").UserApiUtilsData>;
+    }>;
+    getFavoriters: (...args: Parameters<UserListApiUtils["getFavoriters"]>) => Promise<{
+        raw: import("./models").TwitterApiUtilsRaw;
+        header: import("./models").ApiUtilsHeader;
+        data: import("./models").TimelineApiUtilsResponse<import("./models").UserApiUtilsData>;
+    }>;
+    getRetweeters: (...args: Parameters<UserListApiUtils["getRetweeters"]>) => Promise<{
+        raw: import("./models").TwitterApiUtilsRaw;
+        header: import("./models").ApiUtilsHeader;
+        data: import("./models").TimelineApiUtilsResponse<import("./models").UserApiUtilsData>;
+    }>;
+    createTweet: (...args: Parameters<PostApiUtils["postCreateTweet"]>) => Promise<import("./models").TwitterApiUtilsResponse<i.CreateTweetResponse>>;
+    deleteTweet: (...args: Parameters<PostApiUtils["postDeleteTweet"]>) => Promise<import("./models").TwitterApiUtilsResponse<i.DeleteTweetResponse>>;
+    likeTweet: (...args: Parameters<PostApiUtils["postFavoriteTweet"]>) => Promise<import("./models").TwitterApiUtilsResponse<i.FavoriteTweetResponse>>;
+    unlikeTweet: (...args: Parameters<PostApiUtils["postUnfavoriteTweet"]>) => Promise<import("./models").TwitterApiUtilsResponse<i.UnfavoriteTweetResponse>>;
+    retweet: (...args: Parameters<PostApiUtils["postCreateRetweet"]>) => Promise<import("./models").TwitterApiUtilsResponse<i.CreateRetweetResponse>>;
+    deleteRetweet: (...args: Parameters<PostApiUtils["postDeleteRetweet"]>) => Promise<import("./models").TwitterApiUtilsResponse<i.DeleteRetweetResponse>>;
+    follow: (...args: Parameters<V11PostApiUtils["postCreateFriendships"]>) => Promise<import("./models").TwitterApiUtilsResponse<undefined>>;
+    unfollow: (...args: Parameters<V11PostApiUtils["postDestroyFriendships"]>) => Promise<import("./models").TwitterApiUtilsResponse<undefined>>;
+    getAudioSpaceById: (...args: Parameters<SpaceApiUtils["getAudioSpaceById"]>) => Promise<import("./models").TwitterApiUtilsResponse<i.AudioSpaceByIdResponse>>;
+    getBroadcastQuery: (...args: Parameters<SpaceApiUtils["getBroadcastQuery"]>) => Promise<import("./models").TwitterApiUtilsResponse<i.BroadcastQueryResponse>>;
+    getLiveVideoStreamStatus: (...args: Parameters<V11GetApiUtils["getLiveVideoStreamStatus"]>) => Promise<import("./models").TwitterApiUtilsResponse<i.LiveVideoStreamStatusResponse>>;
+}
+//# sourceMappingURL=api.d.ts.map

package/dist/src/api.js

@@ -0,0 +1,245 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XScraperClient = exports.XScraper = void 0;
+const apis_1 = require("./apis");
+const i = __importStar(require("./openapi"));
+// Bypass TS import resolving issue under jest
+const placeholder_json_1 = __importDefault(require("../openapi/placeholder.json"));
+const x_client_transaction_id_generater_1 = require("x-client-transaction-id-generater");
+class XScraper {
+    constructor() {
+        this.additionalBrowserHeaders = {};
+        this.additionalApiHeaders = {};
+    }
+    setAdditionalBrowserHeaders(headers) {
+        this.additionalBrowserHeaders = headers;
+    }
+    setAdditionalApiHeaders(headers) {
+        this.additionalApiHeaders = headers;
+    }
+    async getHeaders() {
+        const raw = await XScraper.fetchApi(XScraper.header, { method: 'GET' });
+        const json = await raw.json();
+        const ignore = ['host', 'connection'];
+        const getHeader = (name) => {
+            return Object.entries(json[name]).reduce((a, [key, value]) => {
+                if (ignore.includes(key))
+                    return a;
+                return { ...a, [key]: value };
+            }, {});
+        };
+        return {
+            api: {
+                ...getHeader('chrome-fetch'),
+                'accept-encoding': 'identity',
+                pragma: 'no-cache',
+                referer: XScraper.twitter,
+                priority: 'u=1, i',
+                'x-twitter-client-language': 'en',
+                'x-twitter-active-user': 'yes',
+                authorization: `Bearer ${XScraper.bearer}`,
+                ...this.additionalApiHeaders,
+            },
+            browser: {
+                ...getHeader('chrome'),
+                ...this.additionalBrowserHeaders,
+            },
+        };
+    }
+    cookieNormalize(cookie) {
+        return cookie.reduce((a, b) => {
+            const [key, value] = b.split('; ')[0].split('=');
+            return { ...a, [key]: value };
+        }, {});
+    }
+    cookieEncode(cookie) {
+        return Object.entries(cookie)
+            .map(([key, value]) => `${key}=${value}`)
+            .join('; ');
+    }
+    normalizeCookiesInput(cookies) {
+        if (!Array.isArray(cookies)) {
+            return cookies;
+        }
+        const allowedDomains = new Set(['.x.com', 'x.com', '.twitter.com', 'twitter.com']);
+        const normalized = {};
+        for (const cookie of cookies) {
+            if (!cookie || typeof cookie.name !== 'string' || typeof cookie.value !== 'string') {
+                continue;
+            }
+            if (typeof cookie.domain === 'string' && !allowedDomains.has(cookie.domain.toLowerCase())) {
+                continue;
+            }
+            normalized[cookie.name] = cookie.value;
+        }
+        return normalized;
+    }
+    setCookies(context, cookies) {
+        if (context.init.headers) {
+            const headers = context.init.headers;
+            headers['cookie'] = this.cookieEncode(cookies);
+        }
+        return context;
+    }
+    async getGuestClient() {
+        let cookies = {};
+        const response = await XScraper.fetchApi(XScraper.twitter, {
+            method: 'GET',
+            redirect: 'manual',
+            headers: { Cookie: this.cookieEncode(cookies), ...(await this.getHeaders()).browser },
+        });
+        if (response.headers.getSetCookie) {
+            cookies = { ...cookies, ...this.cookieNormalize(response.headers.getSetCookie()) };
+        }
+        else {
+            cookies = {
+                ...cookies,
+                ...this.cookieNormalize(response.headers.get('set-cookie')?.split(', ') || []),
+            };
+        }
+        const html = await response.text();
+        const re = /document.cookie="(.*?)";/g;
+        const find = [...html.matchAll(re)].map((e) => e[1]);
+        cookies = { ...cookies, ...this.cookieNormalize(find) };
+        cookies = Object.entries(cookies)
+            .filter(([key]) => key !== 'ct0')
+            .reduce((a, [key, value]) => ({ ...a, [key]: value }), {});
+        if (!cookies['gt']) {
+            const activateHeaders = { ...(await this.getHeaders()).api, cookie: this.cookieEncode(cookies) };
+            const { guest_token } = await XScraper.fetchApi('https://api.x.com/1.1/guest/activate.json', {
+                method: 'POST',
+                headers: activateHeaders,
+            }).then((r) => r.json());
+            cookies['gt'] = guest_token;
+        }
+        return this.getClientFromCookies(cookies);
+    }
+    async getClientFromCookies(cookies) {
+        const normalizedCookies = this.normalizeCookiesInput(cookies);
+        const apiKey = (await this.getHeaders()).api;
+        if (normalizedCookies['ct0']) {
+            apiKey['x-twitter-auth-type'] = 'OAuth2Session';
+            apiKey['x-csrf-token'] = normalizedCookies['ct0'];
+        }
+        if (normalizedCookies['gt']) {
+            apiKey['x-guest-token'] = normalizedCookies['gt'];
+        }
+        const config = {
+            fetchApi: XScraper.fetchApi,
+            middleware: [{ pre: async (context) => this.setCookies(context, normalizedCookies) }],
+            apiKey: (key) => apiKey[key.toLowerCase()],
+            accessToken: XScraper.bearer,
+        };
+        return this.getClient(new i.Configuration(config));
+    }
+    async getClient(config) {
+        const flag = placeholder_json_1.default;
+        const pairUrl = 'https://raw.githubusercontent.com/fa0311/x-client-transaction-pair-dict/refs/heads/main/pair.json';
+        const pair = await XScraper.fetchApi(pairUrl, { method: 'GET' }).then((res) => res.json());
+        const initOverrides = (flag) => {
+            return async ({ init }) => {
+                const randomPair = pair[Math.floor(Math.random() * pair.length)];
+                const { animationKey, verification } = randomPair;
+                const tid = await (0, x_client_transaction_id_generater_1.generateTransactionId)(flag['@method'], flag['@path'], verification, animationKey);
+                init.headers = { ...init.headers, 'x-client-transaction-id': tid };
+                return init;
+            };
+        };
+        return new XScraperClient(config, flag, initOverrides);
+    }
+}
+exports.XScraper = XScraper;
+XScraper.header = 'https://raw.githubusercontent.com/fa0311/latest-user-agent/refs/heads/main/header.json';
+XScraper.twitter = 'https://x.com/home';
+XScraper.bearer = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
+XScraper.fetchApi = fetch.bind(globalThis);
+class XScraperClient {
+    constructor(config, flag, initOverrides) {
+        this.config = config;
+        this.flag = flag;
+        this.initOverrides = initOverrides;
+        // ─── 高频快捷方法（直接挂在 client 顶层） ──────────────────────────────────
+        // User
+        this.getUserByScreenName = (...args) => this.user.getUserByScreenName(...args);
+        this.getUserByRestId = (...args) => this.user.getUserByRestId(...args);
+        this.getUsersByRestIds = (...args) => this.users.getUsersByRestIds(...args);
+        // Tweet
+        this.getTweetDetail = (...args) => this.tweet.getTweetDetail(...args);
+        this.getTweetByRestId = (...args) => this.default.getTweetResultByRestId(...args);
+        this.getUserTweets = (...args) => this.tweet.getUserTweets(...args);
+        this.getUserMedia = (...args) => this.tweet.getUserMedia(...args);
+        this.getLikes = (...args) => this.tweet.getLikes(...args);
+        this.getBookmarks = (...args) => this.tweet.getBookmarks(...args);
+        this.getHomeTimeline = (...args) => this.tweet.getHomeTimeline(...args);
+        this.getHomeLatestTimeline = (...args) => this.tweet.getHomeLatestTimeline(...args);
+        this.searchTimeline = (...args) => this.tweet.getSearchTimeline(...args);
+        // Social graph
+        this.getFollowers = (...args) => this.userList.getFollowers(...args);
+        this.getBlueVerifiedFollowers = (...args) => this.userList.getBlueVerifiedFollowers(...args);
+        this.getFollowing = (...args) => this.userList.getFollowing(...args);
+        this.getFavoriters = (...args) => this.userList.getFavoriters(...args);
+        this.getRetweeters = (...args) => this.userList.getRetweeters(...args);
+        // Actions
+        this.createTweet = (...args) => this.post.postCreateTweet(...args);
+        this.deleteTweet = (...args) => this.post.postDeleteTweet(...args);
+        this.likeTweet = (...args) => this.post.postFavoriteTweet(...args);
+        this.unlikeTweet = (...args) => this.post.postUnfavoriteTweet(...args);
+        this.retweet = (...args) => this.post.postCreateRetweet(...args);
+        this.deleteRetweet = (...args) => this.post.postDeleteRetweet(...args);
+        this.follow = (...args) => this.v11Post.postCreateFriendships(...args);
+        this.unfollow = (...args) => this.v11Post.postDestroyFriendships(...args);
+        // Space
+        this.getAudioSpaceById = (...args) => this.space.getAudioSpaceById(...args);
+        this.getBroadcastQuery = (...args) => this.space.getBroadcastQuery(...args);
+        this.getLiveVideoStreamStatus = (...args) => this.v11Get.getLiveVideoStreamStatus(...args);
+        this.tweet = new apis_1.TweetApiUtils(new i.TweetApi(config), flag, initOverrides);
+        this.user = new apis_1.UserApiUtils(new i.UserApi(config), flag, initOverrides);
+        this.users = new apis_1.UsersApiUtils(new i.UsersApi(config), flag, initOverrides);
+        this.userList = new apis_1.UserListApiUtils(new i.UserListApi(config), flag, initOverrides);
+        this.post = new apis_1.PostApiUtils(new i.PostApi(config), flag, initOverrides);
+        this.space = new apis_1.SpaceApiUtils(new i.OtherApi(config), flag, initOverrides);
+        this.v11Get = new apis_1.V11GetApiUtils(new i.V11GetApi(config), flag, initOverrides);
+        this.v11Post = new apis_1.V11PostApiUtils(new i.V11PostApi(config), flag, initOverrides);
+        this.v20Get = new apis_1.V20GetApiUtils(new i.V20GetApi(config), flag, initOverrides);
+        this.default = new apis_1.DefaultApiUtils(new i.DefaultApi(config), flag, initOverrides);
+        this.initialState = new apis_1.InitialStateApiUtils();
+    }
+}
+exports.XScraperClient = XScraperClient;
+//# sourceMappingURL=api.js.map

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

@@ -0,0 +1,25 @@
+import type { DefaultFlag, RequestParam, TweetApiUtilsData, TwitterApiUtilsResponse } from '../models';
+import { InitOverridesType } from '../utils';
+import type * as i from '../openapi';
+export type ProfileSpotlightsQueryParam = {
+    screenName: string;
+    extraParam?: {
+        [key: string]: any;
+    };
+};
+export type TweetResultByRestIdParam = {
+    tweetId: string;
+    extraParam?: {
+        [key: string]: any;
+    };
+};
+export declare class DefaultApiUtils {
+    api: i.DefaultApi;
+    flag: DefaultFlag;
+    initOverrides: InitOverridesType;
+    constructor(api: i.DefaultApi, flag: DefaultFlag, initOverrides: InitOverridesType);
+    request<T1, T2>(param: RequestParam<T1, T2>): Promise<TwitterApiUtilsResponse<T1>>;
+    getProfileSpotlightsQuery(param: ProfileSpotlightsQueryParam): Promise<TwitterApiUtilsResponse<i.UserResultByScreenName>>;
+    getTweetResultByRestId(param: TweetResultByRestIdParam): Promise<TwitterApiUtilsResponse<TweetApiUtilsData | undefined>>;
+}
+//# sourceMappingURL=defaultApi.d.ts.map