scrapebadger 0.1.0

package/dist/index-B3rJn_Jw.d.ts

@@ -0,0 +1,1739 @@
+/**
+ * Configuration management for the ScrapeBadger SDK.
+ */
+interface ScrapeBadgerConfig {
+    /** API key for authentication */
+    apiKey: string;
+    /** Base URL for the API (default: https://api.scrapebadger.com) */
+    baseUrl?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Maximum number of retry attempts (default: 3) */
+    maxRetries?: number;
+    /** Initial retry delay in milliseconds (default: 1000) */
+    retryDelay?: number;
+}
+interface ResolvedConfig {
+    apiKey: string;
+    baseUrl: string;
+    timeout: number;
+    maxRetries: number;
+    retryDelay: number;
+}
+
+/**
+ * Base HTTP client with retry logic and error handling.
+ */
+
+interface RequestOptions {
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    params?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+    headers?: Record<string, string>;
+}
+/**
+ * Base HTTP client for making API requests.
+ */
+declare class BaseClient {
+    private readonly config;
+    constructor(config: ResolvedConfig);
+    /**
+     * Make an HTTP request to the API.
+     */
+    request<T>(path: string, options?: RequestOptions): Promise<T>;
+    /**
+     * Execute request with exponential backoff retry logic.
+     */
+    private executeWithRetry;
+    /**
+     * Fetch with timeout support.
+     */
+    private fetchWithTimeout;
+    /**
+     * Handle HTTP response and convert errors.
+     */
+    private handleResponse;
+    /**
+     * Sleep for a given duration.
+     */
+    private sleep;
+}
+
+/**
+ * Pagination utilities for the ScrapeBadger SDK.
+ */
+/**
+ * Response wrapper for paginated API responses.
+ */
+interface PaginatedResponse<T> {
+    /** Array of items in the current page */
+    data: T[];
+    /** Cursor for the next page, if available */
+    nextCursor?: string;
+    /** Whether there are more pages available */
+    hasMore: boolean;
+}
+/**
+ * Options for paginated requests.
+ */
+interface PaginationOptions {
+    /** Maximum number of items to fetch per request (default: 20) */
+    count?: number;
+    /** Cursor for pagination */
+    cursor?: string;
+}
+/**
+ * Options for async iteration.
+ */
+interface IteratorOptions extends PaginationOptions {
+    /** Maximum total number of items to fetch (default: unlimited) */
+    maxItems?: number;
+}
+/**
+ * Collect all items from an async generator into an array.
+ *
+ * @param generator - Async generator to collect from
+ * @returns Array of all yielded items
+ *
+ * @example
+ * ```typescript
+ * const tweets = await collectAll(client.twitter.tweets.searchAll("query", { maxItems: 100 }));
+ * console.log(`Fetched ${tweets.length} tweets`);
+ * ```
+ */
+declare function collectAll<T>(generator: AsyncGenerator<T, void, undefined>): Promise<T[]>;
+
+/**
+ * TypeScript types for Twitter API responses.
+ *
+ * This module contains all the data types used by the Twitter API client.
+ * Types mirror the Python SDK's Pydantic models.
+ */
+/**
+ * Search query type for tweet searches.
+ */
+type QueryType = "Top" | "Latest" | "Media";
+/**
+ * Category for trending topics.
+ */
+type TrendCategory = "trending" | "for_you" | "news" | "sports" | "entertainment";
+/**
+ * Tweet type filter for community tweets.
+ */
+type CommunityTweetType = "Top" | "Latest" | "Media";
+/**
+ * Media attachment on a tweet.
+ *
+ * Represents images, videos, or animated GIFs attached to tweets.
+ */
+interface Media {
+    /** Unique identifier for the media */
+    media_key?: string;
+    /** Media type ('photo', 'video', 'animated_gif') */
+    type?: string;
+    /** Direct URL to the media */
+    url?: string;
+    /** URL to a preview/thumbnail image */
+    preview_image_url?: string;
+    /** Media width in pixels */
+    width?: number;
+    /** Media height in pixels */
+    height?: number;
+    /** Duration in milliseconds (for videos) */
+    duration_ms?: number;
+    /** Number of views (for videos) */
+    view_count?: number;
+    /** Accessibility description */
+    alt_text?: string;
+}
+/**
+ * A single option in a poll.
+ */
+interface PollOption {
+    /** Option position (1-indexed) */
+    position: number;
+    /** Option text */
+    label: string;
+    /** Number of votes received */
+    votes: number;
+}
+/**
+ * A poll attached to a tweet.
+ */
+interface Poll {
+    /** Unique poll identifier */
+    id?: string;
+    /** Current status ('open' or 'closed') */
+    voting_status?: string;
+    /** When the poll ends/ended */
+    end_datetime?: string;
+    /** Total poll duration */
+    duration_minutes?: number;
+    /** List of poll options with vote counts */
+    options: PollOption[];
+}
+/**
+ * A URL entity in tweet text.
+ */
+interface Url {
+    /** The t.co shortened URL */
+    url?: string;
+    /** The fully expanded URL */
+    expanded_url?: string;
+    /** The display version of the URL */
+    display_url?: string;
+    /** Page title (if available) */
+    title?: string;
+    /** Page description (if available) */
+    description?: string;
+}
+/**
+ * A hashtag entity in tweet text.
+ */
+interface Hashtag {
+    /** The hashtag text (without #) */
+    tag: string;
+}
+/**
+ * A user mention entity in tweet text.
+ */
+interface UserMention {
+    /** User ID of mentioned user */
+    id?: string;
+    /** Username of mentioned user (without @) */
+    username?: string;
+    /** Display name of mentioned user */
+    name?: string;
+}
+/**
+ * Location information attached to a tweet.
+ */
+interface TweetPlace {
+    /** Place ID */
+    id?: string;
+    /** Full place name */
+    full_name?: string;
+    /** Short place name */
+    name?: string;
+    /** Country name */
+    country?: string;
+    /** ISO country code */
+    country_code?: string;
+    /** Type of place ('city', 'country', etc.) */
+    place_type?: string;
+}
+/**
+ * A Twitter tweet with all associated data.
+ *
+ * This is the primary type for tweet data, containing the tweet content,
+ * engagement metrics, author information, and all entities.
+ *
+ * @example
+ * ```typescript
+ * const tweet = await client.twitter.tweets.getById("1234567890");
+ * console.log(`@${tweet.username}: ${tweet.text}`);
+ * console.log(`Likes: ${tweet.favorite_count}, Retweets: ${tweet.retweet_count}`);
+ * ```
+ */
+interface Tweet {
+    /** Unique tweet identifier */
+    id: string;
+    /** Tweet text content */
+    text: string;
+    /** Full tweet text (may differ from text for long tweets) */
+    full_text?: string;
+    /** Tweet creation timestamp (ISO format) */
+    created_at?: string;
+    /** Language code */
+    lang?: string;
+    /** Author's user ID */
+    user_id?: string;
+    /** Author's username */
+    username?: string;
+    /** Author's display name */
+    user_name?: string;
+    /** Number of likes */
+    favorite_count: number;
+    /** Number of retweets */
+    retweet_count: number;
+    /** Number of replies */
+    reply_count: number;
+    /** Number of quote tweets */
+    quote_count: number;
+    /** Number of views */
+    view_count?: number;
+    /** Number of bookmarks */
+    bookmark_count?: number;
+    /** Whether the authenticated user liked this */
+    favorited: boolean;
+    /** Whether the authenticated user retweeted this */
+    retweeted: boolean;
+    /** Whether the authenticated user bookmarked this */
+    bookmarked: boolean;
+    /** Whether the tweet is marked as sensitive */
+    possibly_sensitive: boolean;
+    /** Whether this is a quote tweet */
+    is_quote_status: boolean;
+    /** Whether this is a retweet */
+    is_retweet: boolean;
+    /** ID of the conversation thread */
+    conversation_id?: string;
+    /** ID of the tweet being replied to */
+    in_reply_to_status_id?: string;
+    /** ID of the user being replied to */
+    in_reply_to_user_id?: string;
+    /** List of attached media */
+    media: Media[];
+    /** List of URLs in the tweet */
+    urls: Url[];
+    /** List of hashtags */
+    hashtags: Hashtag[];
+    /** List of user mentions */
+    user_mentions: UserMention[];
+    /** Poll data if present */
+    poll?: Poll;
+    /** Location data if present */
+    place?: TweetPlace;
+    /** ID of the quoted tweet */
+    quoted_status_id?: string;
+    /** ID of the original retweeted tweet */
+    retweeted_status_id?: string;
+    /** IDs of edit history */
+    edit_tweet_ids?: string[];
+    /** Edit deadline timestamp */
+    editable_until_msecs?: number;
+    /** Remaining edit count */
+    edits_remaining?: number;
+    /** Whether the tweet can be edited */
+    is_edit_eligible?: boolean;
+    /** Whether the tweet has a link preview card */
+    has_card?: boolean;
+    /** Card thumbnail URL */
+    thumbnail_url?: string;
+    /** Card title */
+    thumbnail_title?: string;
+    /** Whether the tweet has community notes */
+    has_community_notes?: boolean;
+    /** Client used to post the tweet */
+    source?: string;
+}
+/**
+ * A Twitter user profile.
+ *
+ * Contains all publicly available information about a Twitter user,
+ * including profile details, metrics, and relationship status.
+ *
+ * @example
+ * ```typescript
+ * const user = await client.twitter.users.getByUsername("elonmusk");
+ * console.log(`${user.name} (@${user.username})`);
+ * console.log(`Followers: ${user.followers_count.toLocaleString()}`);
+ * console.log(`Bio: ${user.description}`);
+ * ```
+ */
+interface User {
+    /** Unique user identifier */
+    id: string;
+    /** User's handle (without @) */
+    username: string;
+    /** Display name */
+    name: string;
+    /** User's bio */
+    description?: string;
+    /** User-provided location */
+    location?: string;
+    /** User's website URL */
+    url?: string;
+    /** Profile picture URL */
+    profile_image_url?: string;
+    /** Banner image URL */
+    profile_banner_url?: string;
+    /** Number of followers */
+    followers_count: number;
+    /** Number of accounts followed */
+    following_count: number;
+    /** Total tweets posted */
+    tweet_count: number;
+    /** Number of lists the user is on */
+    listed_count: number;
+    /** Number of tweets liked */
+    favourites_count?: number;
+    /** Number of media posts */
+    media_count?: number;
+    /** Whether the user is verified (legacy) */
+    verified: boolean;
+    /** Type of verification */
+    verified_type?: string;
+    /** Whether the user has Twitter Blue */
+    is_blue_verified?: boolean;
+    /** Account creation timestamp */
+    created_at?: string;
+    /** Default profile */
+    default_profile?: boolean;
+    /** Default profile image */
+    default_profile_image?: boolean;
+    /** Whether the account is protected/private */
+    protected?: boolean;
+    /** Whether content may be sensitive */
+    possibly_sensitive?: boolean;
+    /** Whether they follow the authenticated user */
+    followed_by?: boolean;
+    /** Whether the authenticated user follows them */
+    following?: boolean;
+    /** Whether a follow request was sent */
+    follow_request_sent?: boolean;
+    /** Whether the authenticated user blocks them */
+    blocking?: boolean;
+    /** Whether they block the authenticated user */
+    blocked_by?: boolean;
+    /** Whether the authenticated user mutes them */
+    muting?: boolean;
+    /** Notifications enabled */
+    notifications?: boolean;
+    /** Whether DMs are allowed */
+    can_dm?: boolean;
+    /** Has custom timelines */
+    has_custom_timelines?: boolean;
+    /** Has extended profile */
+    has_extended_profile?: boolean;
+    /** Is translator */
+    is_translator?: boolean;
+    /** Is translation enabled */
+    is_translation_enabled?: boolean;
+    /** Professional type */
+    professional_type?: string;
+    /** Advertiser account type */
+    advertiser_account_type?: string;
+    /** IDs of pinned tweets */
+    pinned_tweet_ids?: string[];
+    /** Countries where withheld */
+    withheld_in_countries?: string[];
+}
+/**
+ * Extended "About" information for a user.
+ *
+ * Contains additional metadata about a user's account, including
+ * account location, username change history, and verification details.
+ *
+ * @example
+ * ```typescript
+ * const about = await client.twitter.users.getAbout("elonmusk");
+ * console.log(`Account based in: ${about.account_based_in}`);
+ * console.log(`Username changes: ${about.username_changes}`);
+ * ```
+ */
+interface UserAbout {
+    /** User ID */
+    id: string;
+    /** REST API user ID */
+    rest_id?: string;
+    /** Username */
+    screen_name?: string;
+    /** Display name */
+    name?: string;
+    /** Region Twitter believes the account is based in */
+    account_based_in?: string;
+    /** Whether the location is verified */
+    location_accurate?: boolean;
+    /** Linked affiliate account */
+    affiliate_username?: string;
+    /** How the source was determined */
+    source?: string;
+    /** Number of username changes */
+    username_changes?: number;
+    /** Last change timestamp (ms) */
+    username_last_changed_at?: number;
+    /** Last change as datetime string */
+    username_last_changed_at_datetime?: string;
+    /** Whether identity is verified */
+    is_identity_verified?: boolean;
+    /** Verification timestamp (ms) */
+    verified_since_msec?: number;
+    /** Verification as datetime string */
+    verified_since_datetime?: string;
+}
+/**
+ * Response containing a list of user IDs.
+ *
+ * Used for endpoints that return ID lists without full user data,
+ * such as follower_ids and following_ids endpoints.
+ *
+ * @example
+ * ```typescript
+ * const ids = await client.twitter.users.getFollowerIds("elonmusk");
+ * console.log(`Found ${ids.ids.length.toLocaleString()} follower IDs`);
+ * ```
+ */
+interface UserIds {
+    /** List of user IDs */
+    ids: number[];
+    /** Cursor for pagination */
+    next_cursor?: string;
+}
+/**
+ * A Twitter list.
+ *
+ * Represents a curated list of Twitter users.
+ *
+ * @example
+ * ```typescript
+ * const lists = await client.twitter.lists.search("tech leaders");
+ * for (const list of lists.data) {
+ *   console.log(`${list.name}: ${list.member_count} members`);
+ * }
+ * ```
+ */
+interface List {
+    /** Unique list identifier */
+    id: string;
+    /** List name */
+    name: string;
+    /** List description */
+    description?: string;
+    /** List creation timestamp */
+    created_at?: string;
+    /** Number of members */
+    member_count?: number;
+    /** Number of subscribers */
+    subscriber_count?: number;
+    /** 'public' or 'private' */
+    mode?: string;
+    /** Owner's user ID */
+    user_id?: string;
+    /** Owner's username */
+    username?: string;
+}
+/**
+ * Banner image for a community.
+ */
+interface CommunityBanner {
+    /** Banner image URL */
+    url?: string;
+    /** Image width */
+    width?: number;
+    /** Image height */
+    height?: number;
+}
+/**
+ * A rule for a community.
+ */
+interface CommunityRule {
+    /** Rule identifier */
+    id?: string;
+    /** Rule name/title */
+    name?: string;
+    /** Rule description */
+    description?: string;
+}
+/**
+ * A Twitter community.
+ *
+ * Represents a community with its members, rules, and settings.
+ *
+ * @example
+ * ```typescript
+ * const community = await client.twitter.communities.getDetail("123456");
+ * console.log(`${community.name}: ${community.member_count?.toLocaleString()} members`);
+ * for (const rule of community.rules || []) {
+ *   console.log(`  - ${rule.name}`);
+ * }
+ * ```
+ */
+interface Community {
+    /** Unique community identifier */
+    id: string;
+    /** Community name */
+    name: string;
+    /** Community description */
+    description?: string;
+    /** Number of members */
+    member_count?: number;
+    /** Whether the authenticated user is a member */
+    is_member?: boolean;
+    /** User's role ('member', 'moderator', 'admin', 'non_member') */
+    role?: string;
+    /** Whether the community contains adult content */
+    is_nsfw?: boolean;
+    /** How users can join ('Open', 'Closed') */
+    join_policy?: string;
+    /** Who can invite members */
+    invites_policy?: string;
+    /** Whether the community is pinned */
+    is_pinned?: boolean;
+    /** Creation timestamp (Unix) */
+    created_at?: number;
+    /** Creation timestamp (ISO) */
+    created_at_datetime?: string;
+    /** Community banner image */
+    banner?: CommunityBanner;
+    /** Profile images of some members */
+    members_facepile_results?: string[];
+    /** Creator's user ID */
+    creator_id?: string;
+    /** Creator's username */
+    creator_username?: string;
+    /** Creator's display name */
+    creator_name?: string;
+    /** Primary admin's user ID */
+    admin_id?: string;
+    /** Primary admin's username */
+    admin_username?: string;
+    /** Primary admin's display name */
+    admin_name?: string;
+    /** List of community rules */
+    rules?: CommunityRule[];
+}
+/**
+ * A member of a community.
+ *
+ * Extends User with community-specific information.
+ */
+interface CommunityMember {
+    /** The user data */
+    user: User;
+    /** Member's role in the community */
+    role?: string;
+    /** When they joined */
+    joined_at?: string;
+}
+/**
+ * A trending topic.
+ *
+ * @example
+ * ```typescript
+ * const trends = await client.twitter.trends.getTrends();
+ * for (const trend of trends.data) {
+ *   console.log(`${trend.name}: ${trend.tweet_count || 'N/A'} tweets`);
+ * }
+ * ```
+ */
+interface Trend {
+    /** Trend name/hashtag */
+    name: string;
+    /** Twitter search URL for the trend */
+    url?: string;
+    /** Search query to find tweets */
+    query?: string;
+    /** Number of tweets (if available) */
+    tweet_count?: number;
+    /** Category context */
+    domain_context?: string;
+}
+/**
+ * A location for trends.
+ *
+ * @example
+ * ```typescript
+ * const locations = await client.twitter.trends.getAvailableLocations();
+ * const usLocations = locations.data.filter(loc => loc.country_code === "US");
+ * ```
+ */
+interface Location {
+    /** Where On Earth ID */
+    woeid: number;
+    /** Location name */
+    name: string;
+    /** Country name */
+    country?: string;
+    /** ISO country code */
+    country_code?: string;
+    /** Type of place */
+    place_type?: string;
+}
+/**
+ * Trends for a specific location.
+ *
+ * @example
+ * ```typescript
+ * const placeTrends = await client.twitter.trends.getPlaceTrends(23424977);  // US
+ * console.log(`Trends in ${placeTrends.name}:`);
+ * for (const trend of placeTrends.trends) {
+ *   console.log(`  - ${trend.name}`);
+ * }
+ * ```
+ */
+interface PlaceTrends {
+    /** Where On Earth ID */
+    woeid: number;
+    /** Location name */
+    name?: string;
+    /** Country name */
+    country?: string;
+    /** List of trends for this location */
+    trends: Trend[];
+}
+/**
+ * A geographic place.
+ *
+ * @example
+ * ```typescript
+ * const places = await client.twitter.geo.search({ query: "San Francisco" });
+ * for (const place of places.data) {
+ *   console.log(`${place.full_name} (${place.place_type})`);
+ * }
+ * ```
+ */
+interface Place {
+    /** Place ID */
+    id: string;
+    /** Short place name */
+    name: string;
+    /** Full place name */
+    full_name?: string;
+    /** Country name */
+    country?: string;
+    /** ISO country code */
+    country_code?: string;
+    /** Type of place ('city', 'country', etc.) */
+    place_type?: string;
+    /** Twitter place URL */
+    url?: string;
+    /** Geographic bounding box */
+    bounding_box?: Record<string, unknown>;
+    /** Additional place attributes */
+    attributes?: Record<string, string>;
+}
+/**
+ * Generic API response with data and optional cursor.
+ */
+interface ApiResponse<T> {
+    /** Response data */
+    data: T;
+    /** Cursor for next page (if paginated) */
+    cursor?: string;
+}
+/**
+ * Paginated list response.
+ */
+interface ListResponse<T> {
+    /** Array of items */
+    data: T[];
+    /** Cursor for next page */
+    cursor?: string;
+}
+
+/**
+ * Twitter Tweets API client.
+ *
+ * Provides methods for fetching tweets, searching, and getting tweet metadata.
+ */
+
+/**
+ * Client for Twitter tweets endpoints.
+ *
+ * Provides async methods for fetching individual tweets, searching tweets,
+ * and getting tweet engagement data (retweeters, favoriters, replies).
+ *
+ * @example
+ * ```typescript
+ * const client = new ScrapeBadger({ apiKey: "key" });
+ *
+ * // Get single tweet
+ * const tweet = await client.twitter.tweets.getById("1234567890");
+ *
+ * // Search tweets
+ * const results = await client.twitter.tweets.search("python programming");
+ * for (const tweet of results.data) {
+ *   console.log(tweet.text);
+ * }
+ *
+ * // Iterate through all results
+ * for await (const tweet of client.twitter.tweets.searchAll("python")) {
+ *   console.log(tweet.text);
+ * }
+ * ```
+ */
+declare class TweetsClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    /**
+     * Get a single tweet by ID.
+     *
+     * @param tweetId - The tweet ID to fetch.
+     * @returns The tweet data.
+     * @throws NotFoundError - If the tweet doesn't exist.
+     * @throws AuthenticationError - If the API key is invalid.
+     *
+     * @example
+     * ```typescript
+     * const tweet = await client.twitter.tweets.getById("1234567890");
+     * console.log(`@${tweet.username}: ${tweet.text}`);
+     * ```
+     */
+    getById(tweetId: string): Promise<Tweet>;
+    /**
+     * Get multiple tweets by their IDs.
+     *
+     * @param tweetIds - List of tweet IDs to fetch.
+     * @returns Paginated response containing the tweets.
+     *
+     * @example
+     * ```typescript
+     * const tweets = await client.twitter.tweets.getByIds([
+     *   "1234567890",
+     *   "0987654321"
+     * ]);
+     * for (const tweet of tweets.data) {
+     *   console.log(tweet.text);
+     * }
+     * ```
+     */
+    getByIds(tweetIds: string[]): Promise<PaginatedResponse<Tweet>>;
+    /**
+     * Get replies to a tweet.
+     *
+     * @param tweetId - The tweet ID to get replies for.
+     * @param options - Pagination options.
+     * @returns Paginated response containing reply tweets.
+     *
+     * @example
+     * ```typescript
+     * const replies = await client.twitter.tweets.getReplies("1234567890");
+     * for (const reply of replies.data) {
+     *   console.log(`@${reply.username}: ${reply.text}`);
+     * }
+     *
+     * // Get next page
+     * if (replies.hasMore) {
+     *   const more = await client.twitter.tweets.getReplies("1234567890", {
+     *     cursor: replies.nextCursor
+     *   });
+     * }
+     * ```
+     */
+    getReplies(tweetId: string, options?: PaginationOptions): Promise<PaginatedResponse<Tweet>>;
+    /**
+     * Get users who retweeted a tweet.
+     *
+     * @param tweetId - The tweet ID to get retweeters for.
+     * @param options - Pagination options.
+     * @returns Paginated response containing users who retweeted.
+     *
+     * @example
+     * ```typescript
+     * const retweeters = await client.twitter.tweets.getRetweeters("1234567890");
+     * for (const user of retweeters.data) {
+     *   console.log(`@${user.username} retweeted`);
+     * }
+     * ```
+     */
+    getRetweeters(tweetId: string, options?: PaginationOptions): Promise<PaginatedResponse<User>>;
+    /**
+     * Get users who liked/favorited a tweet.
+     *
+     * @param tweetId - The tweet ID to get favoriters for.
+     * @param options - Pagination options with optional count.
+     * @returns Paginated response containing users who liked.
+     *
+     * @example
+     * ```typescript
+     * const likers = await client.twitter.tweets.getFavoriters("1234567890");
+     * console.log(`${likers.data.length} users liked this tweet`);
+     * ```
+     */
+    getFavoriters(tweetId: string, options?: PaginationOptions & {
+        count?: number;
+    }): Promise<PaginatedResponse<User>>;
+    /**
+     * Get tweets similar to a given tweet.
+     *
+     * @param tweetId - The tweet ID to find similar tweets for.
+     * @returns Paginated response containing similar tweets.
+     *
+     * @example
+     * ```typescript
+     * const similar = await client.twitter.tweets.getSimilar("1234567890");
+     * for (const tweet of similar.data) {
+     *   console.log(`Similar: ${tweet.text.slice(0, 100)}...`);
+     * }
+     * ```
+     */
+    getSimilar(tweetId: string): Promise<PaginatedResponse<Tweet>>;
+    /**
+     * Search for tweets.
+     *
+     * @param query - Search query string. Supports Twitter advanced search operators.
+     * @param options - Search options including query type and pagination.
+     * @returns Paginated response containing matching tweets.
+     *
+     * @example
+     * ```typescript
+     * // Basic search
+     * const results = await client.twitter.tweets.search("python programming");
+     *
+     * // Latest tweets only
+     * const latest = await client.twitter.tweets.search("python", {
+     *   queryType: "Latest"
+     * });
+     *
+     * // Advanced search operators
+     * const fromUser = await client.twitter.tweets.search("from:elonmusk lang:en");
+     * ```
+     */
+    search(query: string, options?: PaginationOptions & {
+        queryType?: QueryType;
+    }): Promise<PaginatedResponse<Tweet>>;
+    /**
+     * Iterate through all search results with automatic pagination.
+     *
+     * This is a convenience method that automatically handles pagination,
+     * yielding tweets one at a time.
+     *
+     * @param query - Search query string.
+     * @param options - Search and iteration options.
+     * @yields Tweet objects matching the search query.
+     *
+     * @example
+     * ```typescript
+     * // Get up to 1000 tweets
+     * for await (const tweet of client.twitter.tweets.searchAll("python", {
+     *   maxItems: 1000
+     * })) {
+     *   console.log(tweet.text);
+     * }
+     *
+     * // Collect into an array
+     * import { collectAll } from "scrapebadger";
+     * const tweets = await collectAll(
+     *   client.twitter.tweets.searchAll("python", { maxItems: 100 })
+     * );
+     * ```
+     */
+    searchAll(query: string, options?: IteratorOptions & {
+        queryType?: QueryType;
+    }): AsyncGenerator<Tweet, void, undefined>;
+    /**
+     * Get tweets from a user's timeline.
+     *
+     * @param username - Twitter username (without @).
+     * @param options - Pagination options.
+     * @returns Paginated response containing the user's tweets.
+     *
+     * @example
+     * ```typescript
+     * const tweets = await client.twitter.tweets.getUserTweets("elonmusk");
+     * for (const tweet of tweets.data) {
+     *   console.log(`${tweet.created_at}: ${tweet.text.slice(0, 100)}...`);
+     * }
+     * ```
+     */
+    getUserTweets(username: string, options?: PaginationOptions): Promise<PaginatedResponse<Tweet>>;
+    /**
+     * Iterate through all tweets from a user with automatic pagination.
+     *
+     * @param username - Twitter username (without @).
+     * @param options - Iteration options.
+     * @yields Tweet objects from the user's timeline.
+     *
+     * @example
+     * ```typescript
+     * for await (const tweet of client.twitter.tweets.getUserTweetsAll("elonmusk", {
+     *   maxItems: 500
+     * })) {
+     *   console.log(tweet.text);
+     * }
+     * ```
+     */
+    getUserTweetsAll(username: string, options?: IteratorOptions): AsyncGenerator<Tweet, void, undefined>;
+}
+
+/**
+ * Twitter Users API client.
+ *
+ * Provides methods for fetching user profiles, followers, following, and related data.
+ */
+
+/**
+ * Client for Twitter users endpoints.
+ *
+ * Provides async methods for fetching user profiles, followers, following,
+ * and other user-related data.
+ *
+ * @example
+ * ```typescript
+ * const client = new ScrapeBadger({ apiKey: "key" });
+ *
+ * // Get user profile
+ * const user = await client.twitter.users.getByUsername("elonmusk");
+ * console.log(`${user.name}: ${user.followers_count.toLocaleString()} followers`);
+ *
+ * // Get followers
+ * const followers = await client.twitter.users.getFollowers("elonmusk");
+ *
+ * // Iterate through all followers
+ * for await (const follower of client.twitter.users.getFollowersAll("elonmusk")) {
+ *   console.log(follower.username);
+ * }
+ * ```
+ */
+declare class UsersClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    /**
+     * Get a user by their numeric ID.
+     *
+     * @param userId - The user's numeric ID.
+     * @returns The user profile.
+     * @throws NotFoundError - If the user doesn't exist.
+     *
+     * @example
+     * ```typescript
+     * const user = await client.twitter.users.getById("44196397");
+     * console.log(`@${user.username}`);
+     * ```
+     */
+    getById(userId: string): Promise<User>;
+    /**
+     * Get a user by their username.
+     *
+     * @param username - The user's username (without @).
+     * @returns The user profile.
+     * @throws NotFoundError - If the user doesn't exist.
+     *
+     * @example
+     * ```typescript
+     * const user = await client.twitter.users.getByUsername("elonmusk");
+     * console.log(`${user.name} has ${user.followers_count.toLocaleString()} followers`);
+     * ```
+     */
+    getByUsername(username: string): Promise<User>;
+    /**
+     * Get extended "About" information for a user.
+     *
+     * Returns additional metadata including account location,
+     * username change history, and verification details.
+     *
+     * @param username - The user's username (without @).
+     * @returns Extended user information.
+     *
+     * @example
+     * ```typescript
+     * const about = await client.twitter.users.getAbout("elonmusk");
+     * console.log(`Account based in: ${about.account_based_in}`);
+     * console.log(`Username changes: ${about.username_changes}`);
+     * ```
+     */
+    getAbout(username: string): Promise<UserAbout>;
+    /**
+     * Get a user's followers.
+     *
+     * @param username - The user's username (without @).
+     * @param options - Pagination options.
+     * @returns Paginated response containing follower users.
+     *
+     * @example
+     * ```typescript
+     * const followers = await client.twitter.users.getFollowers("elonmusk");
+     * for (const user of followers.data) {
+     *   console.log(`@${user.username}`);
+     * }
+     *
+     * // Get next page
+     * if (followers.hasMore) {
+     *   const more = await client.twitter.users.getFollowers("elonmusk", {
+     *     cursor: followers.nextCursor
+     *   });
+     * }
+     * ```
+     */
+    getFollowers(username: string, options?: PaginationOptions): Promise<PaginatedResponse<User>>;
+    /**
+     * Iterate through all followers with automatic pagination.
+     *
+     * @param username - The user's username (without @).
+     * @param options - Iteration options.
+     * @yields User objects for each follower.
+     *
+     * @example
+     * ```typescript
+     * for await (const follower of client.twitter.users.getFollowersAll("elonmusk", {
+     *   maxItems: 1000
+     * })) {
+     *   console.log(follower.username);
+     * }
+     * ```
+     */
+    getFollowersAll(username: string, options?: IteratorOptions): AsyncGenerator<User, void, undefined>;
+    /**
+     * Get users that a user is following.
+     *
+     * @param username - The user's username (without @).
+     * @param options - Pagination options.
+     * @returns Paginated response containing followed users.
+     *
+     * @example
+     * ```typescript
+     * const following = await client.twitter.users.getFollowing("elonmusk");
+     * for (const user of following.data) {
+     *   console.log(`Follows @${user.username}`);
+     * }
+     * ```
+     */
+    getFollowing(username: string, options?: PaginationOptions): Promise<PaginatedResponse<User>>;
+    /**
+     * Iterate through all following with automatic pagination.
+     *
+     * @param username - The user's username (without @).
+     * @param options - Iteration options.
+     * @yields User objects for each followed account.
+     */
+    getFollowingAll(username: string, options?: IteratorOptions): AsyncGenerator<User, void, undefined>;
+    /**
+     * Get a user's most recent followers.
+     *
+     * @param username - The user's username (without @).
+     * @param options - Pagination options with optional count.
+     * @returns Paginated response containing recent followers.
+     */
+    getLatestFollowers(username: string, options?: PaginationOptions & {
+        count?: number;
+    }): Promise<PaginatedResponse<User>>;
+    /**
+     * Get accounts a user most recently followed.
+     *
+     * @param username - The user's username (without @).
+     * @param options - Pagination options with optional count.
+     * @returns Paginated response containing recently followed users.
+     */
+    getLatestFollowing(username: string, options?: PaginationOptions & {
+        count?: number;
+    }): Promise<PaginatedResponse<User>>;
+    /**
+     * Get follower IDs for a user.
+     *
+     * More efficient than getFollowers when you only need IDs.
+     *
+     * @param username - The user's username (without @).
+     * @param options - Pagination options with optional count.
+     * @returns UserIds containing list of follower IDs.
+     *
+     * @example
+     * ```typescript
+     * const ids = await client.twitter.users.getFollowerIds("elonmusk");
+     * console.log(`Found ${ids.ids.length.toLocaleString()} follower IDs`);
+     * ```
+     */
+    getFollowerIds(username: string, options?: PaginationOptions & {
+        count?: number;
+    }): Promise<UserIds>;
+    /**
+     * Get following IDs for a user.
+     *
+     * More efficient than getFollowing when you only need IDs.
+     *
+     * @param username - The user's username (without @).
+     * @param options - Pagination options with optional count.
+     * @returns UserIds containing list of following IDs.
+     */
+    getFollowingIds(username: string, options?: PaginationOptions & {
+        count?: number;
+    }): Promise<UserIds>;
+    /**
+     * Get verified followers for a user.
+     *
+     * @param userId - The user's numeric ID.
+     * @param options - Pagination options with optional count.
+     * @returns Paginated response containing verified followers.
+     */
+    getVerifiedFollowers(userId: string, options?: PaginationOptions & {
+        count?: number;
+    }): Promise<PaginatedResponse<User>>;
+    /**
+     * Get followers that the authenticated user also follows.
+     *
+     * @param userId - The user's numeric ID.
+     * @param options - Pagination options with optional count.
+     * @returns Paginated response containing mutual connections.
+     */
+    getFollowersYouKnow(userId: string, options?: PaginationOptions & {
+        count?: number;
+    }): Promise<PaginatedResponse<User>>;
+    /**
+     * Get premium accounts that a user subscribes to.
+     *
+     * @param userId - The user's numeric ID.
+     * @param options - Pagination options with optional count.
+     * @returns Paginated response containing subscribed accounts.
+     */
+    getSubscriptions(userId: string, options?: PaginationOptions & {
+        count?: number;
+    }): Promise<PaginatedResponse<User>>;
+    /**
+     * Get a user's highlighted tweets.
+     *
+     * @param userId - The user's numeric ID.
+     * @param options - Pagination options with optional count.
+     * @returns Paginated response containing highlighted tweets.
+     */
+    getHighlights(userId: string, options?: PaginationOptions & {
+        count?: number;
+    }): Promise<PaginatedResponse<Tweet>>;
+    /**
+     * Search for users.
+     *
+     * @param query - Search query string.
+     * @param options - Pagination options.
+     * @returns Paginated response containing matching users.
+     *
+     * @example
+     * ```typescript
+     * const results = await client.twitter.users.search("python developer");
+     * for (const user of results.data) {
+     *   console.log(`@${user.username}: ${user.description}`);
+     * }
+     * ```
+     */
+    search(query: string, options?: PaginationOptions): Promise<PaginatedResponse<User>>;
+    /**
+     * Iterate through all search results with automatic pagination.
+     *
+     * @param query - Search query string.
+     * @param options - Iteration options.
+     * @yields User objects matching the search query.
+     */
+    searchAll(query: string, options?: IteratorOptions): AsyncGenerator<User, void, undefined>;
+}
+
+/**
+ * Twitter Lists API client.
+ *
+ * Provides methods for fetching Twitter lists, list members, and list tweets.
+ */
+
+/**
+ * Client for Twitter lists endpoints.
+ *
+ * Provides async methods for fetching list details, members, subscribers,
+ * and tweets from lists.
+ *
+ * @example
+ * ```typescript
+ * const client = new ScrapeBadger({ apiKey: "key" });
+ *
+ * // Search for lists
+ * const lists = await client.twitter.lists.search("tech leaders");
+ *
+ * // Get list details
+ * const list = await client.twitter.lists.getDetail("123456");
+ * console.log(`${list.name}: ${list.member_count} members`);
+ *
+ * // Get list tweets
+ * const tweets = await client.twitter.lists.getTweets("123456");
+ * ```
+ */
+declare class ListsClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    /**
+     * Get details for a specific list.
+     *
+     * @param listId - The list ID.
+     * @returns The list details.
+     * @throws NotFoundError - If the list doesn't exist.
+     *
+     * @example
+     * ```typescript
+     * const list = await client.twitter.lists.getDetail("123456");
+     * console.log(`${list.name} by @${list.username}`);
+     * console.log(`${list.member_count} members, ${list.subscriber_count} subscribers`);
+     * ```
+     */
+    getDetail(listId: string): Promise<List>;
+    /**
+     * Get tweets from a list's timeline.
+     *
+     * @param listId - The list ID.
+     * @param options - Pagination options.
+     * @returns Paginated response containing tweets from list members.
+     *
+     * @example
+     * ```typescript
+     * const tweets = await client.twitter.lists.getTweets("123456");
+     * for (const tweet of tweets.data) {
+     *   console.log(`@${tweet.username}: ${tweet.text.slice(0, 100)}...`);
+     * }
+     * ```
+     */
+    getTweets(listId: string, options?: PaginationOptions): Promise<PaginatedResponse<Tweet>>;
+    /**
+     * Iterate through all list tweets with automatic pagination.
+     *
+     * @param listId - The list ID.
+     * @param options - Iteration options.
+     * @yields Tweet objects from the list timeline.
+     */
+    getTweetsAll(listId: string, options?: IteratorOptions): AsyncGenerator<Tweet, void, undefined>;
+    /**
+     * Get members of a list.
+     *
+     * @param listId - The list ID.
+     * @param options - Pagination options.
+     * @returns Paginated response containing list members.
+     *
+     * @example
+     * ```typescript
+     * const members = await client.twitter.lists.getMembers("123456");
+     * for (const user of members.data) {
+     *   console.log(`@${user.username}`);
+     * }
+     * ```
+     */
+    getMembers(listId: string, options?: PaginationOptions): Promise<PaginatedResponse<User>>;
+    /**
+     * Iterate through all list members with automatic pagination.
+     *
+     * @param listId - The list ID.
+     * @param options - Iteration options.
+     * @yields User objects for each list member.
+     */
+    getMembersAll(listId: string, options?: IteratorOptions): AsyncGenerator<User, void, undefined>;
+    /**
+     * Get subscribers of a list.
+     *
+     * @param listId - The list ID.
+     * @param options - Pagination options with optional count.
+     * @returns Paginated response containing list subscribers.
+     */
+    getSubscribers(listId: string, options?: PaginationOptions & {
+        count?: number;
+    }): Promise<PaginatedResponse<User>>;
+    /**
+     * Search for lists.
+     *
+     * @param query - Search query string.
+     * @param options - Pagination options with optional count.
+     * @returns Paginated response containing matching lists.
+     *
+     * @example
+     * ```typescript
+     * const results = await client.twitter.lists.search("tech leaders");
+     * for (const list of results.data) {
+     *   console.log(`${list.name}: ${list.member_count} members`);
+     * }
+     * ```
+     */
+    search(query: string, options?: PaginationOptions & {
+        count?: number;
+    }): Promise<PaginatedResponse<List>>;
+    /**
+     * Get lists owned by the authenticated user.
+     *
+     * @param options - Pagination options with optional count.
+     * @returns Paginated response containing the user's lists.
+     */
+    getMyLists(options?: PaginationOptions & {
+        count?: number;
+    }): Promise<PaginatedResponse<List>>;
+}
+
+/**
+ * Twitter Communities API client.
+ *
+ * Provides methods for fetching Twitter communities, members, and tweets.
+ */
+
+/**
+ * Client for Twitter communities endpoints.
+ *
+ * Provides async methods for fetching community details, members,
+ * moderators, and tweets.
+ *
+ * @example
+ * ```typescript
+ * const client = new ScrapeBadger({ apiKey: "key" });
+ *
+ * // Search communities
+ * const communities = await client.twitter.communities.search("python");
+ *
+ * // Get community details
+ * const community = await client.twitter.communities.getDetail("123456");
+ * console.log(`${community.name}: ${community.member_count} members`);
+ *
+ * // Get community tweets
+ * const tweets = await client.twitter.communities.getTweets("123456");
+ * ```
+ */
+declare class CommunitiesClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    /**
+     * Get details for a specific community.
+     *
+     * @param communityId - The community ID.
+     * @returns The community details including rules and admin info.
+     * @throws NotFoundError - If the community doesn't exist.
+     *
+     * @example
+     * ```typescript
+     * const community = await client.twitter.communities.getDetail("123456");
+     * console.log(`${community.name}`);
+     * console.log(`Members: ${community.member_count?.toLocaleString()}`);
+     * console.log(`Join policy: ${community.join_policy}`);
+     *
+     * if (community.rules) {
+     *   console.log("Rules:");
+     *   for (const rule of community.rules) {
+     *     console.log(`  - ${rule.name}`);
+     *   }
+     * }
+     * ```
+     */
+    getDetail(communityId: string): Promise<Community>;
+    /**
+     * Get tweets from a community.
+     *
+     * @param communityId - The community ID.
+     * @param options - Options including tweet type, count, and pagination.
+     * @returns Paginated response containing community tweets.
+     *
+     * @example
+     * ```typescript
+     * // Get top tweets
+     * const tweets = await client.twitter.communities.getTweets("123456");
+     *
+     * // Get latest tweets
+     * const latest = await client.twitter.communities.getTweets("123456", {
+     *   tweetType: "Latest"
+     * });
+     * ```
+     */
+    getTweets(communityId: string, options?: PaginationOptions & {
+        tweetType?: CommunityTweetType;
+        count?: number;
+    }): Promise<PaginatedResponse<Tweet>>;
+    /**
+     * Iterate through all community tweets with automatic pagination.
+     *
+     * @param communityId - The community ID.
+     * @param options - Options including tweet type and iteration limits.
+     * @yields Tweet objects from the community.
+     */
+    getTweetsAll(communityId: string, options?: IteratorOptions & {
+        tweetType?: CommunityTweetType;
+    }): AsyncGenerator<Tweet, void, undefined>;
+    /**
+     * Get members of a community.
+     *
+     * @param communityId - The community ID.
+     * @param options - Pagination options with optional count.
+     * @returns Paginated response containing community members.
+     *
+     * @example
+     * ```typescript
+     * const members = await client.twitter.communities.getMembers("123456");
+     * for (const member of members.data) {
+     *   console.log(`@${member.user.username} (${member.role})`);
+     * }
+     * ```
+     */
+    getMembers(communityId: string, options?: PaginationOptions & {
+        count?: number;
+    }): Promise<PaginatedResponse<CommunityMember>>;
+    /**
+     * Get moderators of a community.
+     *
+     * @param communityId - The community ID.
+     * @param options - Pagination options with optional count.
+     * @returns Paginated response containing community moderators.
+     */
+    getModerators(communityId: string, options?: PaginationOptions & {
+        count?: number;
+    }): Promise<PaginatedResponse<CommunityMember>>;
+    /**
+     * Search for communities.
+     *
+     * @param query - Search query string.
+     * @param options - Pagination options.
+     * @returns Paginated response containing matching communities.
+     *
+     * @example
+     * ```typescript
+     * const results = await client.twitter.communities.search("python developers");
+     * for (const community of results.data) {
+     *   console.log(`${community.name}: ${community.member_count} members`);
+     * }
+     * ```
+     */
+    search(query: string, options?: PaginationOptions): Promise<PaginatedResponse<Community>>;
+    /**
+     * Search for tweets within a community.
+     *
+     * @param communityId - The community ID.
+     * @param query - Search query string.
+     * @param options - Pagination options with optional count.
+     * @returns Paginated response containing matching tweets.
+     */
+    searchTweets(communityId: string, query: string, options?: PaginationOptions & {
+        count?: number;
+    }): Promise<PaginatedResponse<Tweet>>;
+    /**
+     * Get the community timeline (tweets from communities you're in).
+     *
+     * @param options - Pagination options with optional count.
+     * @returns Paginated response containing community timeline tweets.
+     */
+    getTimeline(options?: PaginationOptions & {
+        count?: number;
+    }): Promise<PaginatedResponse<Tweet>>;
+}
+
+/**
+ * Twitter Trends API client.
+ *
+ * Provides methods for fetching trending topics and trend locations.
+ */
+
+/**
+ * Client for Twitter trends endpoints.
+ *
+ * Provides async methods for fetching trending topics, place-specific trends,
+ * and available trend locations.
+ *
+ * @example
+ * ```typescript
+ * const client = new ScrapeBadger({ apiKey: "key" });
+ *
+ * // Get global trends
+ * const trends = await client.twitter.trends.getTrends();
+ * for (const trend of trends.data) {
+ *   console.log(`${trend.name}: ${trend.tweet_count || 'N/A'} tweets`);
+ * }
+ *
+ * // Get trends for a specific location
+ * const usTrends = await client.twitter.trends.getPlaceTrends(23424977);
+ *
+ * // Get available locations
+ * const locations = await client.twitter.trends.getAvailableLocations();
+ * ```
+ */
+declare class TrendsClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    /**
+     * Get trending topics.
+     *
+     * @param options - Options for filtering trends.
+     * @returns Paginated response containing trending topics.
+     *
+     * @example
+     * ```typescript
+     * // Get general trending topics
+     * const trends = await client.twitter.trends.getTrends();
+     *
+     * // Get news trends
+     * const newsTrends = await client.twitter.trends.getTrends({
+     *   category: "news"
+     * });
+     *
+     * for (const trend of trends.data) {
+     *   const count = trend.tweet_count?.toLocaleString() || "N/A";
+     *   console.log(`${trend.name}: ${count} tweets`);
+     * }
+     * ```
+     */
+    getTrends(options?: {
+        category?: TrendCategory;
+        count?: number;
+    }): Promise<PaginatedResponse<Trend>>;
+    /**
+     * Get trends for a specific location.
+     *
+     * @param woeid - Where On Earth ID for the location.
+     *   Common WOEIDs:
+     *   - 1: Worldwide
+     *   - 23424977: United States
+     *   - 23424975: United Kingdom
+     *   - 23424856: Japan
+     *   - 23424829: Germany
+     * @returns PlaceTrends containing location info and trends.
+     * @throws NotFoundError - If the WOEID is invalid.
+     *
+     * @example
+     * ```typescript
+     * // Get US trends
+     * const usTrends = await client.twitter.trends.getPlaceTrends(23424977);
+     * console.log(`Trends in ${usTrends.name}:`);
+     * for (const trend of usTrends.trends) {
+     *   console.log(`  - ${trend.name}`);
+     * }
+     *
+     * // Get worldwide trends
+     * const globalTrends = await client.twitter.trends.getPlaceTrends(1);
+     * ```
+     */
+    getPlaceTrends(woeid: number): Promise<PlaceTrends>;
+    /**
+     * Get all locations where trends are available.
+     *
+     * @returns Paginated response containing available trend locations.
+     *
+     * @example
+     * ```typescript
+     * const locations = await client.twitter.trends.getAvailableLocations();
+     *
+     * // Filter by country
+     * const usLocations = locations.data.filter(
+     *   loc => loc.country_code === "US"
+     * );
+     * console.log(`Found ${usLocations.length} US locations`);
+     *
+     * // Get countries only
+     * const countries = locations.data.filter(
+     *   loc => loc.place_type === "Country"
+     * );
+     * ```
+     */
+    getAvailableLocations(): Promise<PaginatedResponse<Location>>;
+}
+
+/**
+ * Twitter Geo API client.
+ *
+ * Provides methods for fetching geographic place information.
+ */
+
+/**
+ * Options for searching places.
+ */
+interface GeoSearchOptions {
+    /** Latitude coordinate */
+    lat?: number;
+    /** Longitude coordinate */
+    long?: number;
+    /** Free-form text search query (e.g., "San Francisco") */
+    query?: string;
+    /** IP address for location lookup */
+    ip?: string;
+    /** Result granularity ("neighborhood", "city", "admin", "country") */
+    granularity?: string;
+    /** Maximum number of results (1-100) */
+    maxResults?: number;
+}
+/**
+ * Client for Twitter geo/places endpoints.
+ *
+ * Provides async methods for fetching place details and searching
+ * for geographic locations.
+ *
+ * @example
+ * ```typescript
+ * const client = new ScrapeBadger({ apiKey: "key" });
+ *
+ * // Search for places
+ * const places = await client.twitter.geo.search({ query: "San Francisco" });
+ *
+ * // Search by coordinates
+ * const nearby = await client.twitter.geo.search({ lat: 37.7749, long: -122.4194 });
+ *
+ * // Get place details
+ * const place = await client.twitter.geo.getDetail("5a110d312052166f");
+ * ```
+ */
+declare class GeoClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    /**
+     * Get details for a specific place.
+     *
+     * @param placeId - The Twitter place ID.
+     * @returns The place details.
+     * @throws NotFoundError - If the place doesn't exist.
+     *
+     * @example
+     * ```typescript
+     * const place = await client.twitter.geo.getDetail("5a110d312052166f");
+     * console.log(`${place.full_name}`);
+     * console.log(`Type: ${place.place_type}`);
+     * console.log(`Country: ${place.country}`);
+     * ```
+     */
+    getDetail(placeId: string): Promise<Place>;
+    /**
+     * Search for geographic places.
+     *
+     * At least one of lat/long, query, or ip must be provided.
+     *
+     * @param options - Search options.
+     * @returns Paginated response containing matching places.
+     * @throws ValidationError - If no search parameters are provided.
+     *
+     * @example
+     * ```typescript
+     * // Search by name
+     * const places = await client.twitter.geo.search({ query: "San Francisco" });
+     * for (const place of places.data) {
+     *   console.log(`${place.full_name} (${place.place_type})`);
+     * }
+     *
+     * // Search by coordinates
+     * const nearby = await client.twitter.geo.search({
+     *   lat: 37.7749,
+     *   long: -122.4194,
+     *   granularity: "city"
+     * });
+     *
+     * // Search by IP
+     * const ipPlaces = await client.twitter.geo.search({ ip: "8.8.8.8" });
+     * ```
+     */
+    search(options?: GeoSearchOptions): Promise<PaginatedResponse<Place>>;
+}
+
+/**
+ * Twitter API client.
+ *
+ * Provides access to all Twitter API endpoints through specialized sub-clients.
+ */
+
+/**
+ * Twitter API client with access to all Twitter endpoints.
+ *
+ * Provides sub-clients for different resource types:
+ * - `tweets` - Tweet operations (get, search, replies, retweeters, etc.)
+ * - `users` - User operations (profiles, followers, following, search, etc.)
+ * - `lists` - List operations (details, members, tweets, search, etc.)
+ * - `communities` - Community operations (details, members, tweets, search, etc.)
+ * - `trends` - Trending topics and locations
+ * - `geo` - Geographic place information
+ *
+ * @example
+ * ```typescript
+ * const client = new ScrapeBadger({ apiKey: "key" });
+ *
+ * // Access tweets
+ * const tweet = await client.twitter.tweets.getById("1234567890");
+ *
+ * // Access users
+ * const user = await client.twitter.users.getByUsername("elonmusk");
+ *
+ * // Access trends
+ * const trends = await client.twitter.trends.getTrends();
+ *
+ * // Search with automatic pagination
+ * for await (const tweet of client.twitter.tweets.searchAll("python")) {
+ *   console.log(tweet.text);
+ * }
+ * ```
+ */
+declare class TwitterClient {
+    /** Client for tweet operations */
+    readonly tweets: TweetsClient;
+    /** Client for user operations */
+    readonly users: UsersClient;
+    /** Client for list operations */
+    readonly lists: ListsClient;
+    /** Client for community operations */
+    readonly communities: CommunitiesClient;
+    /** Client for trends operations */
+    readonly trends: TrendsClient;
+    /** Client for geo/places operations */
+    readonly geo: GeoClient;
+    /**
+     * Create a new Twitter client.
+     *
+     * @param client - The base HTTP client for making requests.
+     */
+    constructor(client: BaseClient);
+}
+
+export { type ApiResponse as A, CommunitiesClient as C, GeoClient as G, type Hashtag as H, type IteratorOptions as I, ListsClient as L, type Media as M, type PaginatedResponse as P, type QueryType as Q, type ResolvedConfig as R, type ScrapeBadgerConfig as S, TwitterClient as T, UsersClient as U, type PaginationOptions as a, TweetsClient as b, collectAll as c, TrendsClient as d, type GeoSearchOptions as e, type TrendCategory as f, type CommunityTweetType as g, type PollOption as h, type Poll as i, type Url as j, type UserMention as k, type TweetPlace as l, type Tweet as m, type User as n, type UserAbout as o, type UserIds as p, type List as q, type CommunityBanner as r, type CommunityRule as s, type Community as t, type CommunityMember as u, type Trend as v, type Location as w, type PlaceTrends as x, type Place as y, type ListResponse as z };