fxtwitter 0.0.0-reserved → 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 otoneko.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,206 @@
+# fxtwitter
+
+[![npm](https://img.shields.io/npm/v/fxtwitter)](https://www.npmjs.com/package/fxtwitter)
+[![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/otnc/fxtwitter-wrapper/ci.yml?branch=main)](https://github.com/otnc/fxtwitter-wrapper/actions)
+[![GitHub](https://img.shields.io/github/license/otnc/fxtwitter-wrapper)](https://github.com/otnc/fxtwitter-wrapper/blob/main/LICENSE)
+[![Node](https://img.shields.io/node/v/fxtwitter)](https://www.npmjs.com/package/fxtwitter)
+
+Typed wrapper for the [FxTwitter](https://github.com/FxEmbed/FxEmbed) API.
+
+## Install
+
+```sh
+npm install fxtwitter
+```
+
+## Usage
+
+```ts
+import { FxTwitterV2 } from "fxtwitter/v2";
+
+const fx = new FxTwitterV2();
+
+const { status } = await fx.getStatus("20");
+const { user } = await fx.getProfile("X");
+const { results } = await fx.search("puppies");
+```
+
+Each version ships under its own subpath, where its types are exported
+alongside the client:
+
+```ts
+import { FxTwitterV2, type TwitterStatus } from "fxtwitter/v2";
+import { FxTwitterV1, type Tweet } from "fxtwitter/v1";
+```
+
+If you need both at once, `FxTwitter` bundles them. `v1` is only constructed —
+and so only warns — on first access:
+
+```ts
+import { FxTwitter } from "fxtwitter";
+
+const fx = new FxTwitter({ v1: { silenceDeprecationWarning: true } });
+await fx.v2.getStatus("20");
+await fx.v1.getStatus("20");
+```
+
+## Options
+
+Every client takes the same options:
+
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `baseUrl` | `string` | `https://api.fxtwitter.com` | API host, e.g. a self-hosted instance |
+| `headers` | `Record<string, string>` | — | Extra headers sent with every request |
+| `timeout` | `number` | disabled | Abort a request after this many ms |
+| `retry` | `number \| false` | `1` | Retries for failed requests |
+| `retryDelay` | `number` | `0` | Delay between retries, in ms |
+| `fetch` | `typeof fetch` | global `fetch` | Custom fetch implementation |
+
+Every method takes an optional `signal` for per-call cancellation.
+
+> The API requires a `User-Agent` identifying the caller and answers `401`
+> without one. When you don't set one, a header describing the current runtime
+> is sent — `Node.js/22.16.0`, `Bun/1.3.0`, `Cloudflare-Workers` and so on.
+> Set your own to identify your app instead:
+>
+> ```ts
+> new FxTwitterV2({
+>   headers: { "User-Agent": "MyApp/1.0 (+https://example.com)" },
+> });
+> ```
+>
+> Nothing is sent in browsers, where `User-Agent` is a forbidden header and the
+> browser supplies its own.
+
+## v2
+
+### `new FxTwitterV2(options?)`
+
+| Method | Returns |
+| --- | --- |
+| `getStatus(id, options?)` | A single post |
+| `getThread(id, options?)` | A post with its unrolled thread |
+| `getConversation(id, options?)` | A post, its thread, and ranked replies |
+| `getStatusReposts(id, options?)` | Users who reposted a post |
+| `getStatusQuotes(id, options?)` | Posts quoting a post |
+| `getProfile(handle, options?)` | A user profile |
+| `getProfileStatuses(handle, options?)` | A user's posts |
+| `getProfileArticles(handle, options?)` | A user's long-form articles |
+| `getProfileMedia(handle, options?)` | A user's posts containing media |
+| `getProfileAbout(handle, options?)` | Account metadata |
+| `getProfileFollowers(handle, options?)` | A user's followers |
+| `getProfileFollowing(handle, options?)` | Accounts a user follows |
+| `search(query, options?)` | Post search results |
+| `typeahead(query, options?)` | Autocomplete suggestions |
+| `trends(options?)` | Trending topics |
+
+Common options: `count` and `cursor` paginate list endpoints, `lang` requests an
+inline translation, and `aboutAccount` adds `about_account` to an author.
+
+```ts
+// Paginate
+let cursor: string | undefined;
+do {
+  const page = await fx.search("puppies", { feed: "top", count: 50, cursor });
+  cursor = page.cursor.bottom ?? undefined;
+} while (cursor);
+
+// Look a profile up by numeric ID
+import { byUserId } from "fxtwitter/v2";
+await fx.getProfile(byUserId("783214"));
+```
+
+The list endpoints report "no results" as a `404` carrying an otherwise normal
+body. An empty page is a result rather than an error, so it resolves with
+`results: []`. The API uses that same `404` for an unknown handle, which it does
+not distinguish from an empty timeline.
+
+`getProfileStatuses` resolves to `null` when `since` is set without a `cursor`
+and nothing is newer — the API's documented `204`. Every other method either
+resolves with a body or throws.
+
+## v1
+
+> **Deprecated.** v1 is kept only for backwards compatibility and does not
+> receive new features — use [v2](#v2) instead. Constructing `FxTwitterV1`
+> emits a one-time `DeprecationWarning` (so `--no-deprecation` and
+> `--throw-deprecation` apply); pass `silenceDeprecationWarning: true` to
+> suppress it. `FxTwitter`'s `v1` property only constructs the client, and so
+> only warns, on first access.
+
+### `new FxTwitterV1(options?)`
+
+#### `getStatus(id, options?)`
+
+Fetches a single status by its snowflake ID.
+
+```ts
+const { tweet } = await fx.getStatus("20", { translateTo: "es" });
+tweet?.translation?.text;
+```
+
+| Option | Type | Description |
+| --- | --- | --- |
+| `translateTo` | `string` | Target language — an ISO 639-1 code (`es`) or locale (`zh-cn`). Adds `translation` to the status |
+| `screenName` | `string` | Author handle, for a readable URL. The API resolves the status from `id` alone and never checks it |
+
+Resolves to `{ code, message, tweet }`. `tweet` is `null` when the status could
+not be retrieved.
+
+#### `getUser(handle, options?)`
+
+Fetches a user profile by handle, without a leading `@`.
+
+```ts
+const { user } = await fx.getUser("jack");
+```
+
+Resolves to `{ code, message, user, reason? }`. `user` is absent when the
+profile could not be retrieved, and `reason` is `"suspended"` for a suspended
+account.
+
+On success, `code` mirrors the HTTP status and `message` is one of `OK`,
+`PRIVATE_TWEET`, `NOT_FOUND`, `UPSTREAM_UNAVAILABLE` or `API_FAIL`.
+
+Malformed input is rejected before a request is sent, because v1 answers those
+cases with HTML or a redirect rather than JSON: a status ID must be 2-20 digits,
+and a handle passed to `getUser` must match `\w{1,15}`. A well-formed handle
+that does not exist is a normal `404`.
+
+## Errors
+
+HTTP 4xx/5xx, network failures, timeouts, invalid input, and non-JSON responses
+are thrown as `FxTwitterError`:
+
+```ts
+import { FxTwitterError } from "fxtwitter";
+
+try {
+  await fx.getStatus("20");
+} catch (error) {
+  if (error instanceof FxTwitterError) {
+    error.status; // 404
+    error.code; // 404
+    error.message; // "NOT_FOUND"
+    error.body; // parsed response body, when available
+    error.cause; // underlying error, when available
+  }
+}
+```
+
+For a network failure or a timeout there is no response, so `status`, `code`
+and `body` are all `undefined` and `message` is a generic description. The
+original error is still available as `cause`.
+
+## Requirements
+
+- Node.js >= 22
+
+## Contributing
+
+Contributions are welcome! See [CONTRIBUTING.md](./CONTRIBUTING.md) for details.
+
+## License
+
+Distributed under the [MIT License](./LICENSE).

package/dist/http-BTdKgEdX.mjs

@@ -0,0 +1,147 @@
+import { defu } from "defu";
+import { FetchError, createFetch } from "ofetch";
+import { hasWindow, nodeVersion, runtime } from "std-env";
+//#region src/errors.ts
+/** Thrown for any non-2xx response, network failure, timeout, or unparsable body. */
+var FxTwitterError = class extends Error {
+	status;
+	code;
+	body;
+	constructor(message, options = {}) {
+		super(message, options.cause !== void 0 ? { cause: options.cause } : void 0);
+		this.name = "FxTwitterError";
+		this.status = options.status;
+		this.code = options.code;
+		this.body = options.body;
+	}
+};
+//#endregion
+//#region src/user-agent.ts
+/** Reads a version off a runtime global without assuming it exists. */
+function globalVersion(name, path) {
+	let value = globalThis[name];
+	for (const key of path) {
+		if (typeof value !== "object" || value === null) return null;
+		value = value[key];
+	}
+	return typeof value === "string" ? value : null;
+}
+function product(name, version) {
+	return version ? `${name}/${version}` : name;
+}
+/**
+* A `User-Agent` describing the runtime the request is made from, such as
+* `Node.js/22.16.0`, `Bun/1.3.0` or `Cloudflare-Workers`.
+*
+* The API requires callers to identify themselves and answers `401` otherwise.
+* Runtimes that fill the header in do so very tersely — Node sends just `node`
+* — so this states the runtime and version instead. It deliberately says
+* nothing about this package.
+*
+* Returns `null` in browsers, where `User-Agent` is a forbidden header: the
+* request carries the browser's own regardless, and setting it only logs a
+* warning.
+*/
+function environmentUserAgent() {
+	if (hasWindow) return null;
+	switch (runtime) {
+		case "node": return product("Node.js", nodeVersion);
+		case "bun": return product("Bun", globalVersion("Bun", ["version"]));
+		case "deno": return product("Deno", globalVersion("Deno", ["version", "deno"]));
+		case "workerd": return "Cloudflare-Workers";
+		case "edge-light": return "Vercel-Edge";
+		case "fastly": return "Fastly-Compute";
+		case "netlify": return "Netlify-Edge";
+		default: return runtime || null;
+	}
+}
+/** Header lookup that ignores case, as HTTP header names are case-insensitive. */
+function hasHeader(headers, name) {
+	if (!headers) return false;
+	const wanted = name.toLowerCase();
+	return Object.keys(headers).some((key) => key.toLowerCase() === wanted);
+}
+//#endregion
+//#region src/http.ts
+const DEFAULT_BASE_URL = "https://api.fxtwitter.com";
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+/**
+* Wraps ofetch with the conventions shared by the clients: `null` for 204
+* responses, and `FxTwitterError` for everything that fails.
+*/
+var HttpClient = class {
+	request;
+	constructor(options = {}) {
+		const headers = { ...options.headers };
+		if (!hasHeader(headers, "User-Agent")) {
+			const userAgent = environmentUserAgent();
+			if (userAgent) headers["User-Agent"] = userAgent;
+		}
+		const globalOptions = { defaults: defu({
+			baseURL: options.baseUrl,
+			headers,
+			timeout: options.timeout,
+			retry: options.retry,
+			retryDelay: options.retryDelay
+		}, { baseURL: DEFAULT_BASE_URL }) };
+		if (options.fetch) globalOptions.fetch = options.fetch;
+		this.request = createFetch(globalOptions);
+	}
+	/** Runs a GET request and returns the parsed JSON body, or `null` on a 204. */
+	async get(options) {
+		let response;
+		try {
+			response = await this.request.raw(options.path, {
+				query: options.query,
+				signal: options.signal
+			});
+		} catch (cause) {
+			throw toFxTwitterError(cause);
+		}
+		if (response.status === 204) return null;
+		const body = response._data;
+		if (!isRecord(body)) throw new FxTwitterError(nonJsonMessage(body, response.status), {
+			status: response.status,
+			body
+		});
+		return body;
+	}
+};
+function nonJsonMessage(body, status) {
+	return `Expected a JSON response but got ${typeof body === "string" ? body.trimStart().startsWith("<") ? "an HTML document" : "a plain text body" : `a ${typeof body} body`} (HTTP ${status}). The endpoint may not exist, or the request was redirected.`;
+}
+/** ofetch wraps aborts in a FetchError, so the original name lives on `cause`. */
+function isAbort(error) {
+	const names = /* @__PURE__ */ new Set(["AbortError", "TimeoutError"]);
+	if (names.has(error.name)) return true;
+	const cause = error.cause;
+	return isRecord(cause) && typeof cause.name === "string" ? names.has(cause.name) : false;
+}
+function toFxTwitterError(cause) {
+	if (cause instanceof FxTwitterError) return cause;
+	if (!(cause instanceof Error)) return new FxTwitterError("Network request failed", { cause });
+	if (isAbort(cause)) return new FxTwitterError("Request aborted or timed out", { cause });
+	if (!(cause instanceof FetchError)) return new FxTwitterError(cause.message, { cause });
+	const status = cause.status ?? cause.response?.status;
+	const data = cause.data;
+	if (isRecord(data)) return new FxTwitterError(typeof data.message === "string" ? data.message : typeof data.error === "string" ? data.error : `Request failed with HTTP ${status ?? "error"}`, {
+		status,
+		code: typeof data.code === "number" ? data.code : void 0,
+		body: data,
+		cause
+	});
+	if (data !== void 0 && status !== void 0) return new FxTwitterError(nonJsonMessage(data, status), {
+		status,
+		body: data,
+		cause
+	});
+	return new FxTwitterError(cause.message, {
+		status,
+		body: data,
+		cause
+	});
+}
+//#endregion
+export { FxTwitterError as n, HttpClient as t };

package/dist/http-CidaL0TV.d.cts

@@ -0,0 +1,24 @@
+//#region src/http.d.ts
+/** Options shared by every client, forwarded to ofetch. */
+interface ClientOptions {
+  /** Overrides the API host. Defaults to `https://api.fxtwitter.com`. */
+  baseUrl?: string;
+  /** Custom fetch implementation (e.g. a mock, or undici in older runtimes). */
+  fetch?: typeof fetch;
+  /**
+   * Extra headers sent with every request.
+   *
+   * When no `User-Agent` is given, one describing the current runtime is
+   * added, because the API answers `401` to requests that do not identify
+   * themselves. Set your own here to override it.
+   */
+  headers?: Record<string, string>;
+  /** Abort a request after this many milliseconds. Disabled by default. */
+  timeout?: number;
+  /** Retry count for failed requests. Defaults to ofetch's `1` for GET. */
+  retry?: number | false;
+  /** Delay between retries in milliseconds. Defaults to `0`. */
+  retryDelay?: number;
+}
+//#endregion
+export { ClientOptions as t };

package/dist/http-CidaL0TV.d.mts

@@ -0,0 +1,24 @@
+//#region src/http.d.ts
+/** Options shared by every client, forwarded to ofetch. */
+interface ClientOptions {
+  /** Overrides the API host. Defaults to `https://api.fxtwitter.com`. */
+  baseUrl?: string;
+  /** Custom fetch implementation (e.g. a mock, or undici in older runtimes). */
+  fetch?: typeof fetch;
+  /**
+   * Extra headers sent with every request.
+   *
+   * When no `User-Agent` is given, one describing the current runtime is
+   * added, because the API answers `401` to requests that do not identify
+   * themselves. Set your own here to override it.
+   */
+  headers?: Record<string, string>;
+  /** Abort a request after this many milliseconds. Disabled by default. */
+  timeout?: number;
+  /** Retry count for failed requests. Defaults to ofetch's `1` for GET. */
+  retry?: number | false;
+  /** Delay between retries in milliseconds. Defaults to `0`. */
+  retryDelay?: number;
+}
+//#endregion
+export { ClientOptions as t };

package/dist/http-Cs4GJeg-.cjs

@@ -0,0 +1,158 @@
+let defu = require("defu");
+let ofetch = require("ofetch");
+let std_env = require("std-env");
+//#region src/errors.ts
+/** Thrown for any non-2xx response, network failure, timeout, or unparsable body. */
+var FxTwitterError = class extends Error {
+	status;
+	code;
+	body;
+	constructor(message, options = {}) {
+		super(message, options.cause !== void 0 ? { cause: options.cause } : void 0);
+		this.name = "FxTwitterError";
+		this.status = options.status;
+		this.code = options.code;
+		this.body = options.body;
+	}
+};
+//#endregion
+//#region src/user-agent.ts
+/** Reads a version off a runtime global without assuming it exists. */
+function globalVersion(name, path) {
+	let value = globalThis[name];
+	for (const key of path) {
+		if (typeof value !== "object" || value === null) return null;
+		value = value[key];
+	}
+	return typeof value === "string" ? value : null;
+}
+function product(name, version) {
+	return version ? `${name}/${version}` : name;
+}
+/**
+* A `User-Agent` describing the runtime the request is made from, such as
+* `Node.js/22.16.0`, `Bun/1.3.0` or `Cloudflare-Workers`.
+*
+* The API requires callers to identify themselves and answers `401` otherwise.
+* Runtimes that fill the header in do so very tersely — Node sends just `node`
+* — so this states the runtime and version instead. It deliberately says
+* nothing about this package.
+*
+* Returns `null` in browsers, where `User-Agent` is a forbidden header: the
+* request carries the browser's own regardless, and setting it only logs a
+* warning.
+*/
+function environmentUserAgent() {
+	if (std_env.hasWindow) return null;
+	switch (std_env.runtime) {
+		case "node": return product("Node.js", std_env.nodeVersion);
+		case "bun": return product("Bun", globalVersion("Bun", ["version"]));
+		case "deno": return product("Deno", globalVersion("Deno", ["version", "deno"]));
+		case "workerd": return "Cloudflare-Workers";
+		case "edge-light": return "Vercel-Edge";
+		case "fastly": return "Fastly-Compute";
+		case "netlify": return "Netlify-Edge";
+		default: return std_env.runtime || null;
+	}
+}
+/** Header lookup that ignores case, as HTTP header names are case-insensitive. */
+function hasHeader(headers, name) {
+	if (!headers) return false;
+	const wanted = name.toLowerCase();
+	return Object.keys(headers).some((key) => key.toLowerCase() === wanted);
+}
+//#endregion
+//#region src/http.ts
+const DEFAULT_BASE_URL = "https://api.fxtwitter.com";
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+/**
+* Wraps ofetch with the conventions shared by the clients: `null` for 204
+* responses, and `FxTwitterError` for everything that fails.
+*/
+var HttpClient = class {
+	request;
+	constructor(options = {}) {
+		const headers = { ...options.headers };
+		if (!hasHeader(headers, "User-Agent")) {
+			const userAgent = environmentUserAgent();
+			if (userAgent) headers["User-Agent"] = userAgent;
+		}
+		const globalOptions = { defaults: (0, defu.defu)({
+			baseURL: options.baseUrl,
+			headers,
+			timeout: options.timeout,
+			retry: options.retry,
+			retryDelay: options.retryDelay
+		}, { baseURL: DEFAULT_BASE_URL }) };
+		if (options.fetch) globalOptions.fetch = options.fetch;
+		this.request = (0, ofetch.createFetch)(globalOptions);
+	}
+	/** Runs a GET request and returns the parsed JSON body, or `null` on a 204. */
+	async get(options) {
+		let response;
+		try {
+			response = await this.request.raw(options.path, {
+				query: options.query,
+				signal: options.signal
+			});
+		} catch (cause) {
+			throw toFxTwitterError(cause);
+		}
+		if (response.status === 204) return null;
+		const body = response._data;
+		if (!isRecord(body)) throw new FxTwitterError(nonJsonMessage(body, response.status), {
+			status: response.status,
+			body
+		});
+		return body;
+	}
+};
+function nonJsonMessage(body, status) {
+	return `Expected a JSON response but got ${typeof body === "string" ? body.trimStart().startsWith("<") ? "an HTML document" : "a plain text body" : `a ${typeof body} body`} (HTTP ${status}). The endpoint may not exist, or the request was redirected.`;
+}
+/** ofetch wraps aborts in a FetchError, so the original name lives on `cause`. */
+function isAbort(error) {
+	const names = /* @__PURE__ */ new Set(["AbortError", "TimeoutError"]);
+	if (names.has(error.name)) return true;
+	const cause = error.cause;
+	return isRecord(cause) && typeof cause.name === "string" ? names.has(cause.name) : false;
+}
+function toFxTwitterError(cause) {
+	if (cause instanceof FxTwitterError) return cause;
+	if (!(cause instanceof Error)) return new FxTwitterError("Network request failed", { cause });
+	if (isAbort(cause)) return new FxTwitterError("Request aborted or timed out", { cause });
+	if (!(cause instanceof ofetch.FetchError)) return new FxTwitterError(cause.message, { cause });
+	const status = cause.status ?? cause.response?.status;
+	const data = cause.data;
+	if (isRecord(data)) return new FxTwitterError(typeof data.message === "string" ? data.message : typeof data.error === "string" ? data.error : `Request failed with HTTP ${status ?? "error"}`, {
+		status,
+		code: typeof data.code === "number" ? data.code : void 0,
+		body: data,
+		cause
+	});
+	if (data !== void 0 && status !== void 0) return new FxTwitterError(nonJsonMessage(data, status), {
+		status,
+		body: data,
+		cause
+	});
+	return new FxTwitterError(cause.message, {
+		status,
+		body: data,
+		cause
+	});
+}
+//#endregion
+Object.defineProperty(exports, "FxTwitterError", {
+	enumerable: true,
+	get: function() {
+		return FxTwitterError;
+	}
+});
+Object.defineProperty(exports, "HttpClient", {
+	enumerable: true,
+	get: function() {
+		return HttpClient;
+	}
+});

package/dist/index.cjs

@@ -0,0 +1,50 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_v1 = require("./v1-BFKgLuJi.cjs");
+const require_http = require("./http-Cs4GJeg-.cjs");
+const require_v2 = require("./v2.cjs");
+//#region src/client.ts
+/**
+* Combined client exposing every API version.
+*
+* Prefer importing a single version when you only need one — `FxTwitterV2`
+* from `fxtwitter/v2` — and reach for this only when you use both.
+*
+* ```ts
+* const fx = new FxTwitter();
+* const { status } = await fx.v2.getStatus("20");
+* const { tweet } = await fx.v1.getStatus("20");
+* ```
+*/
+var FxTwitter = class {
+	v2;
+	v1Options;
+	v1Client;
+	constructor(options = {}) {
+		const { v1, v2, ...shared } = options;
+		this.v2 = new require_v2.FxTwitterV2({
+			...shared,
+			baseUrl: v2?.baseUrl
+		});
+		this.v1Options = {
+			...shared,
+			baseUrl: v1?.baseUrl,
+			silenceDeprecationWarning: v1?.silenceDeprecationWarning
+		};
+	}
+	/**
+	* The legacy v1 client, constructed on first access so its deprecation
+	* warning is only emitted if you actually use it.
+	*
+	* @deprecated Use {@link FxTwitter.v2} instead.
+	*/
+	get v1() {
+		this.v1Client ??= new require_v1.FxTwitterV1(this.v1Options);
+		return this.v1Client;
+	}
+};
+//#endregion
+exports.FxTwitter = FxTwitter;
+exports.FxTwitterError = require_http.FxTwitterError;
+exports.FxTwitterV1 = require_v1.FxTwitterV1;
+exports.FxTwitterV2 = require_v2.FxTwitterV2;
+exports.byUserId = require_v2.byUserId;

package/dist/index.d.cts

@@ -0,0 +1,58 @@
+import { t as ClientOptions } from "./http-CidaL0TV.cjs";
+import { AnyMedia, Author, CommunityNote, ExternalMedia, Facet, FxTwitterV1, FxTwitterV1Options, GetStatusOptions, GetUserOptions, MosaicPhoto, Photo, Poll, PollChoice, RawText, RepostedBy, StatusMedia, StatusMessage, StatusRawText, StatusResponse, Translation, Tweet, TwitterCard, User, UserResponse, Verification, VerificationType, Video, VideoFormat, Website } from "./v1.cjs";
+import { FxTwitterV2, FxTwitterV2Options, byUserId, t as v2_d_exports } from "./v2.cjs";
+//#region src/client.d.ts
+type FxTwitterOptions = ClientOptions & {
+  /** Overrides applied only to the v1 client. */
+  v1?: Pick<ClientOptions, "baseUrl"> & {
+    /** Suppresses the one-time deprecation warning emitted when `v1` is first accessed. */
+    silenceDeprecationWarning?: boolean;
+  };
+  /** Overrides applied only to the v2 client. */
+  v2?: Pick<ClientOptions, "baseUrl">;
+};
+/**
+ * Combined client exposing every API version.
+ *
+ * Prefer importing a single version when you only need one — `FxTwitterV2`
+ * from `fxtwitter/v2` — and reach for this only when you use both.
+ *
+ * ```ts
+ * const fx = new FxTwitter();
+ * const { status } = await fx.v2.getStatus("20");
+ * const { tweet } = await fx.v1.getStatus("20");
+ * ```
+ */
+declare class FxTwitter {
+  readonly v2: FxTwitterV2;
+  private readonly v1Options;
+  private v1Client?;
+  constructor(options?: FxTwitterOptions);
+  /**
+   * The legacy v1 client, constructed on first access so its deprecation
+   * warning is only emitted if you actually use it.
+   *
+   * @deprecated Use {@link FxTwitter.v2} instead.
+   */
+  get v1(): FxTwitterV1;
+}
+//#endregion
+//#region src/errors.d.ts
+interface FxTwitterErrorOptions {
+  /** HTTP status code returned by the API. */
+  status?: number;
+  /** `code` field from the JSON response body (mirrors the HTTP status). */
+  code?: number;
+  /** Parsed response body, when available. */
+  body?: unknown;
+  cause?: unknown;
+}
+/** Thrown for any non-2xx response, network failure, timeout, or unparsable body. */
+declare class FxTwitterError extends Error {
+  readonly status?: number;
+  readonly code?: number;
+  readonly body?: unknown;
+  constructor(message: string, options?: FxTwitterErrorOptions);
+}
+//#endregion
+export { type AnyMedia, type Author, type ClientOptions, type CommunityNote, type ExternalMedia, type Facet, FxTwitter, FxTwitterError, type FxTwitterErrorOptions, type FxTwitterOptions, FxTwitterV1, type FxTwitterV1Options, FxTwitterV2, type FxTwitterV2Options, type GetStatusOptions, type GetUserOptions, type MosaicPhoto, type Photo, type Poll, type PollChoice, type RawText, type RepostedBy, type StatusMedia, type StatusMessage, type StatusRawText, type StatusResponse, type Translation, type Tweet, type TwitterCard, type User, type UserResponse, type v2_d_exports as V2, type Verification, type VerificationType, type Video, type VideoFormat, type Website, byUserId };