@elizaos/plugin-twitter 1.2.5 → 1.2.7

package/dist/index.d.ts

@@ -1,1224 +1,5 @@
-import * as _elizaos_core from '@elizaos/core';
-import { IAgentRuntime, Memory, UUID, State, ChannelType, Service } from '@elizaos/core';
-import * as twitter_api_v2 from 'twitter-api-v2';
-import { TwitterApi, PollV2, TTweetv2Expansion, TTweetv2TweetField, TTweetv2PollField, TTweetv2MediaField, TTweetv2UserField, TTweetv2PlaceField } from 'twitter-api-v2';
+import { Plugin } from '@elizaos/core';
 
-/**
- * Twitter API v2 authentication using developer credentials
- */
-declare class TwitterAuth {
-    private appKey;
-    private appSecret;
-    private accessToken;
-    private accessSecret;
-    private v2Client;
-    private authenticated;
-    private profile?;
-    constructor(appKey: string, appSecret: string, accessToken: string, accessSecret: string);
-    private initializeClient;
-    /**
-     * Get the Twitter API v2 client
-     */
-    getV2Client(): TwitterApi;
-    /**
-     * Check if authenticated
-     */
-    isLoggedIn(): Promise<boolean>;
-    /**
-     * Get current user profile
-     */
-    me(): Promise<Profile | undefined>;
-    /**
-     * Logout (clear credentials)
-     */
-    logout(): Promise<void>;
-    /**
-     * For compatibility - always returns true since we use API keys
-     */
-    hasToken(): boolean;
-}
+declare const TwitterPlugin: Plugin;
 
-/**
- * Interface representing a mention.
- * @typedef {Object} Mention
- * @property {string} id - The unique identifier for the mention.
- * @property {string} [username] - The username associated with the mention.
- * @property {string} [name] - The name associated with the mention.
- */
-interface Mention {
-    id: string;
-    username?: string;
-    name?: string;
-}
-/**
- * Interface representing a photo object.
- * @interface
- * @property {string} id - The unique identifier for the photo.
- * @property {string} url - The URL for the photo image.
- * @property {string} [alt_text] - The alternative text for the photo image. Optional.
- */
-interface Photo {
-    id: string;
-    url: string;
-    alt_text: string | undefined;
-}
-/**
- * Interface representing a video object.
- * @typedef {Object} Video
- * @property {string} id - The unique identifier for the video.
- * @property {string} preview - The URL for the preview image of the video.
- * @property {string} [url] - The optional URL for the video.
- */
-interface Video {
-    id: string;
-    preview: string;
-    url?: string;
-}
-/**
- * Interface representing a raw place object.
- * @typedef {Object} PlaceRaw
- * @property {string} [id] - The unique identifier of the place.
- * @property {string} [place_type] - The type of the place.
- * @property {string} [name] - The name of the place.
- * @property {string} [full_name] - The full name of the place.
- * @property {string} [country_code] - The country code of the place.
- * @property {string} [country] - The country name of the place.
- * @property {Object} [bounding_box] - The bounding box coordinates of the place.
- * @property {string} [bounding_box.type] - The type of the bounding box.
- * @property {number[][][]} [bounding_box.coordinates] - The coordinates of the bounding box in an array format.
- */
-interface PlaceRaw {
-    id?: string;
-    place_type?: string;
-    name?: string;
-    full_name?: string;
-    country_code?: string;
-    country?: string;
-    bounding_box?: {
-        type?: string;
-        coordinates?: number[][][];
-    };
-}
-/**
- * Interface representing poll data.
- *
- * @property {string} [id] - The unique identifier for the poll.
- * @property {string} [end_datetime] - The end date and time for the poll.
- * @property {string} [voting_status] - The status of the voting process.
- * @property {number} duration_minutes - The duration of the poll in minutes.
- * @property {PollOption[]} options - An array of poll options.
- */
-interface PollData {
-    id?: string;
-    end_datetime?: string;
-    voting_status?: string;
-    duration_minutes: number;
-    options: PollOption[];
-}
-/**
- * Interface representing a poll option.
- * @typedef {Object} PollOption
- * @property {number} [position] - The position of the option.
- * @property {string} label - The label of the option.
- * @property {number} [votes] - The number of votes for the option.
- */
-interface PollOption {
-    position?: number;
-    label: string;
-    votes?: number;
-}
-/**
- * A parsed Tweet object.
- */
-/**
- * Represents a Tweet on Twitter.
- * @typedef { Object } Tweet
- * @property { number } [bookmarkCount] - The number of times this Tweet has been bookmarked.
- * @property { string } [conversationId] - The ID of the conversation this Tweet is a part of.
- * @property {string[]} hashtags - An array of hashtags mentioned in the Tweet.
- * @property { string } [html] - The HTML content of the Tweet.
- * @property { string } [id] - The unique ID of the Tweet.
- * @property { Tweet } [inReplyToStatus] - The Tweet that this Tweet is in reply to.
- * @property { string } [inReplyToStatusId] - The ID of the Tweet that this Tweet is in reply to.
- * @property { boolean } [isQuoted] - Indicates if this Tweet is a quote of another Tweet.
- * @property { boolean } [isPin] - Indicates if this Tweet is pinned.
- * @property { boolean } [isReply] - Indicates if this Tweet is a reply to another Tweet.
- * @property { boolean } [isRetweet] - Indicates if this Tweet is a retweet.
- * @property { boolean } [isSelfThread] - Indicates if this Tweet is part of a self thread.
- * @property { string } [language] - The language of the Tweet.
- * @property { number } [likes] - The number of likes on the Tweet.
- * @property { string } [name] - The name associated with the Tweet.
- * @property {Mention[]} mentions - An array of mentions in the Tweet.
- * @property { string } [permanentUrl] - The permanent URL of the Tweet.
- * @property {Photo[]} photos - An array of photos attached to the Tweet.
- * @property { PlaceRaw } [place] - The place associated with the Tweet.
- * @property { Tweet } [quotedStatus] - The quoted Tweet.
- * @property { string } [quotedStatusId] - The ID of the quoted Tweet.
- * @property { number } [quotes] - The number of times this Tweet has been quoted.
- * @property { number } [replies] - The number of replies to the Tweet.
- * @property { number } [retweets] - The number of retweets on the Tweet.
- * @property { Tweet } [retweetedStatus] - The status that was retweeted.
- * @property { string } [retweetedStatusId] - The ID of the retweeted status.
- * @property { string } [text] - The text content of the Tweet.
- * @property {Tweet[]} thread - An array representing a Twitter thread.
- * @property { Date } [timeParsed] - The parsed timestamp of the Tweet.
- * @property { number } [timestamp] - The timestamp of the Tweet.
- * @property {string[]} urls - An array of URLs mentioned in the Tweet.
- * @property { string } [userId] - The ID of the user who posted the Tweet.
- * @property { string } [username] - The username of the user who posted the Tweet.
- * @property {Video[]} videos - An array of videos attached to the Tweet.
- * @property { number } [views] - The number of views on the Tweet.
- * @property { boolean } [sensitiveContent] - Indicates if the Tweet contains sensitive content.
- * @property {PollV2 | null} [poll] - The poll attached to the Tweet, if any.
- */
-interface Tweet$1 {
-    bookmarkCount?: number;
-    conversationId?: string;
-    hashtags: string[];
-    html?: string;
-    id?: string;
-    inReplyToStatus?: Tweet$1;
-    inReplyToStatusId?: string;
-    isQuoted?: boolean;
-    isPin?: boolean;
-    isReply?: boolean;
-    isRetweet?: boolean;
-    isSelfThread?: boolean;
-    language?: string;
-    likes?: number;
-    name?: string;
-    mentions: Mention[];
-    permanentUrl?: string;
-    photos: Photo[];
-    place?: PlaceRaw;
-    quotedStatus?: Tweet$1;
-    quotedStatusId?: string;
-    quotes?: number;
-    replies?: number;
-    retweets?: number;
-    retweetedStatus?: Tweet$1;
-    retweetedStatusId?: string;
-    text?: string;
-    thread: Tweet$1[];
-    timeParsed?: Date;
-    timestamp?: number;
-    urls: string[];
-    userId?: string;
-    username?: string;
-    videos: Video[];
-    views?: number;
-    sensitiveContent?: boolean;
-    poll?: PollV2 | null;
-}
-interface Retweeter {
-    rest_id: string;
-    screen_name: string;
-    name: string;
-    description?: string;
-}
-type TweetQuery = Partial<Tweet$1> | ((tweet: Tweet$1) => boolean | Promise<boolean>);
-
-/**
- * Common types for Twitter plugin API responses
- */
-
-/**
- * Response for paginated tweets queries
- */
-interface QueryTweetsResponse {
-    tweets: Tweet$1[];
-    next?: string;
-    previous?: string;
-}
-/**
- * Response for paginated profiles queries
- */
-interface QueryProfilesResponse {
-    profiles: Profile[];
-    next?: string;
-    previous?: string;
-}
-/**
- * Options for request transformation
- */
-interface FetchTransformOptions {
-    /**
-     * Transforms the request options before a request is made.
-     */
-    request: (...args: [input: RequestInfo | URL, init?: RequestInit]) => [input: RequestInfo | URL, init?: RequestInit] | Promise<[input: RequestInfo | URL, init?: RequestInit]>;
-    /**
-     * Transforms the response after a request completes.
-     */
-    response: (response: Response) => Response | Promise<Response>;
-}
-
-/**
- * A parsed profile object.
- */
-/**
- * Interface representing a user profile.
- * @typedef {Object} Profile
- * @property {string} [avatar] - The URL to the user's avatar.
- * @property {string} [banner] - The URL to the user's banner image.
- * @property {string} [biography] - The user's biography.
- * @property {string} [birthday] - The user's birthday.
- * @property {number} [followersCount] - The number of followers the user has.
- * @property {number} [followingCount] - The number of users the user is following.
- * @property {number} [friendsCount] - The number of friends the user has.
- * @property {number} [mediaCount] - The number of media items the user has posted.
- * @property {number} [statusesCount] - The number of statuses the user has posted.
- * @property {boolean} [isPrivate] - Indicates if the user's profile is private.
- * @property {boolean} [isVerified] - Indicates if the user account is verified.
- * @property {boolean} [isBlueVerified] - Indicates if the user account has blue verification badge.
- * @property {Date} [joined] - The date the user joined the platform.
- * @property {number} [likesCount] - The number of likes the user has received.
- * @property {number} [listedCount] - The number of times the user has been listed.
- * @property {string} location - The user's location.
- * @property {string} [name] - The user's name.
- * @property {string[]} [pinnedTweetIds] - The IDs of the user's pinned tweets.
- * @property {number} [tweetsCount] - The number of tweets the user has posted.
- * @property {string} [url] - The user's website URL.
- * @property {string} [userId] - The unique user ID.
- * @property {string} [username] - The user's username.
- * @property {string} [website] - The user's website.
- * @property {boolean} [canDm] - Indicates if the user can receive direct messages.
- */
-interface Profile {
-    avatar?: string;
-    banner?: string;
-    biography?: string;
-    birthday?: string;
-    followersCount?: number;
-    followingCount?: number;
-    friendsCount?: number;
-    mediaCount?: number;
-    statusesCount?: number;
-    isPrivate?: boolean;
-    isVerified?: boolean;
-    isBlueVerified?: boolean;
-    joined?: Date;
-    likesCount?: number;
-    listedCount?: number;
-    location: string;
-    name?: string;
-    pinnedTweetIds?: string[];
-    tweetsCount?: number;
-    url?: string;
-    userId?: string;
-    username?: string;
-    website?: string;
-    canDm?: boolean;
-}
-
-/**
- * The categories that can be used in Twitter searches.
- */
-/**
- * Enum representing different search modes.
- * @enum {number}
- */
-declare enum SearchMode {
-    Top = 0,
-    Latest = 1,
-    Photos = 2,
-    Videos = 3,
-    Users = 4
-}
-
-/**
- * An alternative fetch function to use instead of the default fetch function. This may be useful
- * in nonstandard runtime environments, such as edge workers.
- *
- * @param {typeof fetch} fetch - The fetch function to use.
- *
- * @param {Partial<FetchTransformOptions>} transform - Additional options that control how requests
- * and responses are processed. This can be used to proxy requests through other hosts, for example.
- */
-interface ClientOptions {
-    /**
-     * An alternative fetch function to use instead of the default fetch function. This may be useful
-     * in nonstandard runtime environments, such as edge workers.
-     */
-    fetch: typeof fetch;
-    /**
-     * Additional options that control how requests and responses are processed. This can be used to
-     * proxy requests through other hosts, for example.
-     */
-    transform: Partial<FetchTransformOptions>;
-}
-/**
- * An interface to Twitter's API v2.
- * - Reusing Client objects is recommended to minimize the time spent authenticating unnecessarily.
- */
-declare class Client {
-    private readonly options?;
-    private auth?;
-    /**
-     * Creates a new Client object.
-     * - Reusing Client objects is recommended to minimize the time spent authenticating unnecessarily.
-     */
-    constructor(options?: Partial<ClientOptions>);
-    /**
-     * Fetches a Twitter profile.
-     * @param username The Twitter username of the profile to fetch, without an `@` at the beginning.
-     * @returns The requested {@link Profile}.
-     */
-    getProfile(username: string): Promise<Profile>;
-    /**
-     * Fetches the user ID corresponding to the provided screen name.
-     * @param screenName The Twitter screen name of the profile to fetch.
-     * @returns The ID of the corresponding account.
-     */
-    getEntityIdByScreenName(screenName: string): Promise<string>;
-    /**
-     *
-     * @param userId The user ID of the profile to fetch.
-     * @returns The screen name of the corresponding account.
-     */
-    getScreenNameByUserId(userId: string): Promise<string>;
-    /**
-     * Fetches tweets from Twitter.
-     * @param query The search query. Any Twitter-compatible query format can be used.
-     * @param maxTweets The maximum number of tweets to return.
-     * @param includeReplies Whether or not replies should be included in the response.
-     * @param searchMode The category filter to apply to the search. Defaults to `Top`.
-     * @returns An {@link AsyncGenerator} of tweets matching the provided filters.
-     */
-    searchTweets(query: string, maxTweets: number, searchMode?: SearchMode): AsyncGenerator<Tweet$1, void>;
-    /**
-     * Fetches profiles from Twitter.
-     * @param query The search query. Any Twitter-compatible query format can be used.
-     * @param maxProfiles The maximum number of profiles to return.
-     * @returns An {@link AsyncGenerator} of tweets matching the provided filter(s).
-     */
-    searchProfiles(query: string, maxProfiles: number): AsyncGenerator<Profile, void>;
-    /**
-     * Fetches tweets from Twitter.
-     * @param query The search query. Any Twitter-compatible query format can be used.
-     * @param maxTweets The maximum number of tweets to return.
-     * @param includeReplies Whether or not replies should be included in the response.
-     * @param searchMode The category filter to apply to the search. Defaults to `Top`.
-     * @param cursor The search cursor, which can be passed into further requests for more results.
-     * @returns A page of results, containing a cursor that can be used in further requests.
-     */
-    fetchSearchTweets(query: string, maxTweets: number, searchMode: SearchMode, cursor?: string): Promise<QueryTweetsResponse>;
-    /**
-     * Fetches profiles from Twitter.
-     * @param query The search query. Any Twitter-compatible query format can be used.
-     * @param maxProfiles The maximum number of profiles to return.
-     * @param cursor The search cursor, which can be passed into further requests for more results.
-     * @returns A page of results, containing a cursor that can be used in further requests.
-     */
-    fetchSearchProfiles(query: string, maxProfiles: number, cursor?: string): Promise<QueryProfilesResponse>;
-    /**
-     * Fetches list tweets from Twitter.
-     * @param listId The list id
-     * @param maxTweets The maximum number of tweets to return.
-     * @param cursor The search cursor, which can be passed into further requests for more results.
-     * @returns A page of results, containing a cursor that can be used in further requests.
-     */
-    fetchListTweets(listId: string, maxTweets: number, cursor?: string): Promise<QueryTweetsResponse>;
-    /**
-     * Fetch the profiles a user is following
-     * @param userId The user whose following should be returned
-     * @param maxProfiles The maximum number of profiles to return.
-     * @returns An {@link AsyncGenerator} of following profiles for the provided user.
-     */
-    getFollowing(userId: string, maxProfiles: number): AsyncGenerator<Profile, void>;
-    /**
-     * Fetch the profiles that follow a user
-     * @param userId The user whose followers should be returned
-     * @param maxProfiles The maximum number of profiles to return.
-     * @returns An {@link AsyncGenerator} of profiles following the provided user.
-     */
-    getFollowers(userId: string, maxProfiles: number): AsyncGenerator<Profile, void>;
-    /**
-     * Fetches following profiles from Twitter.
-     * @param userId The user whose following should be returned
-     * @param maxProfiles The maximum number of profiles to return.
-     * @param cursor The search cursor, which can be passed into further requests for more results.
-     * @returns A page of results, containing a cursor that can be used in further requests.
-     */
-    fetchProfileFollowing(userId: string, maxProfiles: number, cursor?: string): Promise<QueryProfilesResponse>;
-    /**
-     * Fetches profile followers from Twitter.
-     * @param userId The user whose following should be returned
-     * @param maxProfiles The maximum number of profiles to return.
-     * @param cursor The search cursor, which can be passed into further requests for more results.
-     * @returns A page of results, containing a cursor that can be used in further requests.
-     */
-    fetchProfileFollowers(userId: string, maxProfiles: number, cursor?: string): Promise<QueryProfilesResponse>;
-    /**
-     * Fetches the home timeline for the current user using Twitter API v2.
-     * Note: Twitter API v2 doesn't distinguish between "For You" and "Following" feeds.
-     * @param count The number of tweets to fetch.
-     * @param seenTweetIds An array of tweet IDs that have already been seen (not used in v2).
-     * @returns A promise that resolves to an array of tweets.
-     */
-    fetchHomeTimeline(count: number, seenTweetIds: string[]): Promise<Tweet$1[]>;
-    /**
-     * Fetches the home timeline for the current user (same as fetchHomeTimeline in v2).
-     * Twitter API v2 doesn't provide separate "Following" timeline endpoint.
-     * @param count The number of tweets to fetch.
-     * @param seenTweetIds An array of tweet IDs that have already been seen (not used in v2).
-     * @returns A promise that resolves to an array of tweets.
-     */
-    fetchFollowingTimeline(count: number, seenTweetIds: string[]): Promise<Tweet$1[]>;
-    getUserTweets(userId: string, maxTweets?: number, cursor?: string): Promise<{
-        tweets: Tweet$1[];
-        next?: string;
-    }>;
-    getUserTweetsIterator(userId: string, maxTweets?: number): AsyncGenerator<Tweet$1, void>;
-    /**
-     * Fetches the current trends from Twitter.
-     * @returns The current list of trends.
-     */
-    getTrends(): Promise<string[]>;
-    /**
-     * Fetches tweets from a Twitter user.
-     * @param user The user whose tweets should be returned.
-     * @param maxTweets The maximum number of tweets to return. Defaults to `200`.
-     * @returns An {@link AsyncGenerator} of tweets from the provided user.
-     */
-    getTweets(user: string, maxTweets?: number): AsyncGenerator<Tweet$1>;
-    /**
-     * Fetches tweets from a Twitter user using their ID.
-     * @param userId The user whose tweets should be returned.
-     * @param maxTweets The maximum number of tweets to return. Defaults to `200`.
-     * @returns An {@link AsyncGenerator} of tweets from the provided user.
-     */
-    getTweetsByUserId(userId: string, maxTweets?: number): AsyncGenerator<Tweet$1, void>;
-    /**
-     * Send a tweet
-     * @param text The text of the tweet
-     * @param tweetId The id of the tweet to reply to
-     * @param mediaData Optional media data
-     * @returns
-     */
-    sendTweet(text: string, replyToTweetId?: string, mediaData?: {
-        data: Buffer;
-        mediaType: string;
-    }[], hideLinkPreview?: boolean): Promise<{
-        ok: boolean;
-        json: () => Promise<twitter_api_v2.TweetV2PostTweetResult>;
-        data: twitter_api_v2.TweetV2PostTweetResult;
-    }>;
-    sendNoteTweet(text: string, replyToTweetId?: string, mediaData?: {
-        data: Buffer;
-        mediaType: string;
-    }[]): Promise<{
-        ok: boolean;
-        json: () => Promise<twitter_api_v2.TweetV2PostTweetResult>;
-        data: twitter_api_v2.TweetV2PostTweetResult;
-    }>;
-    /**
-     * Send a long tweet (Note Tweet)
-     * @param text The text of the tweet
-     * @param tweetId The id of the tweet to reply to
-     * @param mediaData Optional media data
-     * @returns
-     */
-    sendLongTweet(text: string, replyToTweetId?: string, mediaData?: {
-        data: Buffer;
-        mediaType: string;
-    }[]): Promise<{
-        ok: boolean;
-        json: () => Promise<twitter_api_v2.TweetV2PostTweetResult>;
-        data: twitter_api_v2.TweetV2PostTweetResult;
-    }>;
-    /**
-     * Send a tweet
-     * @param text The text of the tweet
-     * @param tweetId The id of the tweet to reply to
-     * @param options The options for the tweet
-     * @returns
-     */
-    sendTweetV2(text: string, replyToTweetId?: string, options?: {
-        poll?: PollData;
-    }): Promise<Tweet$1>;
-    /**
-     * Fetches tweets and replies from a Twitter user.
-     * @param user The user whose tweets should be returned.
-     * @param maxTweets The maximum number of tweets to return. Defaults to `200`.
-     * @returns An {@link AsyncGenerator} of tweets from the provided user.
-     */
-    getTweetsAndReplies(user: string, maxTweets?: number): AsyncGenerator<Tweet$1>;
-    /**
-     * Fetches tweets and replies from a Twitter user using their ID.
-     * @param userId The user whose tweets should be returned.
-     * @param maxTweets The maximum number of tweets to return. Defaults to `200`.
-     * @returns An {@link AsyncGenerator} of tweets from the provided user.
-     */
-    getTweetsAndRepliesByUserId(userId: string, maxTweets?: number): AsyncGenerator<Tweet$1, void>;
-    /**
-     * Fetches the first tweet matching the given query.
-     *
-     * Example:
-     * ```js
-     * const timeline = client.getTweets('user', 200);
-     * const retweet = await client.getTweetWhere(timeline, { isRetweet: true });
-     * ```
-     * @param tweets The {@link AsyncIterable} of tweets to search through.
-     * @param query A query to test **all** tweets against. This may be either an
-     * object of key/value pairs or a predicate. If this query is an object, all
-     * key/value pairs must match a {@link Tweet} for it to be returned. If this query
-     * is a predicate, it must resolve to `true` for a {@link Tweet} to be returned.
-     * - All keys are optional.
-     * - If specified, the key must be implemented by that of {@link Tweet}.
-     */
-    getTweetWhere(tweets: AsyncIterable<Tweet$1>, query: TweetQuery): Promise<Tweet$1 | null>;
-    /**
-     * Fetches all tweets matching the given query.
-     *
-     * Example:
-     * ```js
-     * const timeline = client.getTweets('user', 200);
-     * const retweets = await client.getTweetsWhere(timeline, { isRetweet: true });
-     * ```
-     * @param tweets The {@link AsyncIterable} of tweets to search through.
-     * @param query A query to test **all** tweets against. This may be either an
-     * object of key/value pairs or a predicate. If this query is an object, all
-     * key/value pairs must match a {@link Tweet} for it to be returned. If this query
-     * is a predicate, it must resolve to `true` for a {@link Tweet} to be returned.
-     * - All keys are optional.
-     * - If specified, the key must be implemented by that of {@link Tweet}.
-     */
-    getTweetsWhere(tweets: AsyncIterable<Tweet$1>, query: TweetQuery): Promise<Tweet$1[]>;
-    /**
-     * Fetches the most recent tweet from a Twitter user.
-     * @param user The user whose latest tweet should be returned.
-     * @param includeRetweets Whether or not to include retweets. Defaults to `false`.
-     * @returns The {@link Tweet} object or `null`/`undefined` if it couldn't be fetched.
-     */
-    getLatestTweet(user: string, includeRetweets?: boolean, max?: number): Promise<Tweet$1 | null | undefined>;
-    /**
-     * Fetches a single tweet.
-     * @param id The ID of the tweet to fetch.
-     * @returns The {@link Tweet} object, or `null` if it couldn't be fetched.
-     */
-    getTweet(id: string): Promise<Tweet$1 | null>;
-    /**
-     * Fetches a single tweet by ID using the Twitter API v2.
-     * Allows specifying optional expansions and fields for more detailed data.
-     *
-     * @param {string} id - The ID of the tweet to fetch.
-     * @param {Object} [options] - Optional parameters to customize the tweet data.
-     * @param {string[]} [options.expansions] - Array of expansions to include, e.g., 'attachments.poll_ids'.
-     * @param {string[]} [options.tweetFields] - Array of tweet fields to include, e.g., 'created_at', 'public_metrics'.
-     * @param {string[]} [options.pollFields] - Array of poll fields to include, if the tweet has a poll, e.g., 'options', 'end_datetime'.
-     * @param {string[]} [options.mediaFields] - Array of media fields to include, if the tweet includes media, e.g., 'url', 'preview_image_url'.
-     * @param {string[]} [options.userFields] - Array of user fields to include, if user information is requested, e.g., 'username', 'verified'.
-     * @param {string[]} [options.placeFields] - Array of place fields to include, if the tweet includes location data, e.g., 'full_name', 'country'.
-     * @returns {Promise<TweetV2 | null>} - The tweet data, including requested expansions and fields.
-     */
-    getTweetV2(id: string, options?: {
-        expansions?: TTweetv2Expansion[];
-        tweetFields?: TTweetv2TweetField[];
-        pollFields?: TTweetv2PollField[];
-        mediaFields?: TTweetv2MediaField[];
-        userFields?: TTweetv2UserField[];
-        placeFields?: TTweetv2PlaceField[];
-    }): Promise<Tweet$1 | null>;
-    /**
-     * Fetches multiple tweets by IDs using the Twitter API v2.
-     * Allows specifying optional expansions and fields for more detailed data.
-     *
-     * @param {string[]} ids - Array of tweet IDs to fetch.
-     * @param {Object} [options] - Optional parameters to customize the tweet data.
-     * @param {string[]} [options.expansions] - Array of expansions to include, e.g., 'attachments.poll_ids'.
-     * @param {string[]} [options.tweetFields] - Array of tweet fields to include, e.g., 'created_at', 'public_metrics'.
-     * @param {string[]} [options.pollFields] - Array of poll fields to include, if tweets contain polls, e.g., 'options', 'end_datetime'.
-     * @param {string[]} [options.mediaFields] - Array of media fields to include, if tweets contain media, e.g., 'url', 'preview_image_url'.
-     * @param {string[]} [options.userFields] - Array of user fields to include, if user information is requested, e.g., 'username', 'verified'.
-     * @param {string[]} [options.placeFields] - Array of place fields to include, if tweets contain location data, e.g., 'full_name', 'country'.
-     * @returns {Promise<TweetV2[]> } - Array of tweet data, including requested expansions and fields.
-     */
-    getTweetsV2(ids: string[], options?: {
-        expansions?: TTweetv2Expansion[];
-        tweetFields?: TTweetv2TweetField[];
-        pollFields?: TTweetv2PollField[];
-        mediaFields?: TTweetv2MediaField[];
-        userFields?: TTweetv2UserField[];
-        placeFields?: TTweetv2PlaceField[];
-    }): Promise<Tweet$1[]>;
-    /**
-     * Updates the authentication state for the client.
-     * @param auth The new authentication.
-     */
-    updateAuth(auth: TwitterAuth): void;
-    /**
-     * Get current authentication credentials
-     * @returns {TwitterAuth | null} Current authentication or null if not authenticated
-     */
-    getAuth(): TwitterAuth | null;
-    /**
-     * Check if client is properly authenticated with Twitter API v2 credentials
-     * @returns {boolean} True if authenticated
-     */
-    isAuthenticated(): boolean;
-    /**
-     * Returns if the client is logged in as a real user.
-     * @returns `true` if the client is logged in with a real user account; otherwise `false`.
-     */
-    isLoggedIn(): Promise<boolean>;
-    /**
-     * Returns the currently logged in user
-     * @returns The currently logged in user
-     */
-    me(): Promise<Profile | undefined>;
-    /**
-     * Login to Twitter using API v2 credentials only.
-     * @param appKey The API key
-     * @param appSecret The API secret key
-     * @param accessToken The access token
-     * @param accessSecret The access token secret
-     */
-    login(username: string, password: string, email?: string, twoFactorSecret?: string, appKey?: string, appSecret?: string, accessToken?: string, accessSecret?: string): Promise<void>;
-    /**
-     * Log out of Twitter.
-     * Note: With API v2, logout is not applicable as we use API credentials.
-     */
-    logout(): Promise<void>;
-    /**
-     * Sends a quote tweet.
-     * @param text The text of the tweet.
-     * @param quotedTweetId The ID of the tweet to quote.
-     * @param options Optional parameters, such as media data.
-     * @returns The response from the Twitter API.
-     */
-    sendQuoteTweet(text: string, quotedTweetId: string, options?: {
-        mediaData: {
-            data: Buffer;
-            mediaType: string;
-        }[];
-    }): Promise<{
-        ok: boolean;
-        json: () => Promise<twitter_api_v2.TweetV2PostTweetResult>;
-        data: twitter_api_v2.TweetV2PostTweetResult;
-    }>;
-    /**
-     * Delete a tweet with the given ID.
-     * @param tweetId The ID of the tweet to delete.
-     * @returns A promise that resolves when the tweet is deleted.
-     */
-    deleteTweet(tweetId: string): Promise<any>;
-    /**
-     * Likes a tweet with the given tweet ID.
-     * @param tweetId The ID of the tweet to like.
-     * @returns A promise that resolves when the tweet is liked.
-     */
-    likeTweet(tweetId: string): Promise<void>;
-    /**
-     * Retweets a tweet with the given tweet ID.
-     * @param tweetId The ID of the tweet to retweet.
-     * @returns A promise that resolves when the tweet is retweeted.
-     */
-    retweet(tweetId: string): Promise<void>;
-    /**
-     * Follows a user with the given user ID.
-     * @param userId The user ID of the user to follow.
-     * @returns A promise that resolves when the user is followed.
-     */
-    followUser(userName: string): Promise<void>;
-    /**
-     * Fetches direct message conversations
-     * Note: This functionality requires additional permissions and is not implemented in the current Twitter API v2 wrapper
-     * @param userId User ID
-     * @param cursor Pagination cursor
-     * @returns Array of DM conversations
-     */
-    getDirectMessageConversations(userId: string, cursor?: string): Promise<any>;
-    /**
-     * Sends a direct message to a user.
-     * Note: This functionality requires additional permissions and is not implemented in the current Twitter API v2 wrapper
-     * @param conversationId The ID of the conversation
-     * @param text The text of the message
-     * @returns The response from the Twitter API
-     */
-    sendDirectMessage(conversationId: string, text: string): Promise<any>;
-    private getAuthOptions;
-    private handleResponse;
-    /**
-     * Retrieves all users who retweeted the given tweet.
-     * @param tweetId The ID of the tweet.
-     * @returns An array of users (retweeters).
-     */
-    getRetweetersOfTweet(tweetId: string): Promise<Retweeter[]>;
-    /**
-     * Fetches all quoted tweets for a given tweet ID, handling pagination automatically.
-     * @param tweetId The ID of the tweet to fetch quotes for.
-     * @param maxQuotes Maximum number of quotes to return (default: 100).
-     * @returns An array of all quoted tweets.
-     */
-    fetchAllQuotedTweets(tweetId: string, maxQuotes?: number): Promise<Tweet$1[]>;
-    /**
-     * Fetches quoted tweets for a given tweet ID.
-     * This method now uses a generator function internally but maintains backward compatibility.
-     * @param tweetId The ID of the tweet to fetch quotes for.
-     * @param maxQuotes Maximum number of quotes to return.
-     * @param cursor Optional cursor for pagination.
-     * @returns A promise that resolves to a QueryTweetsResponse containing tweets and the next cursor.
-     */
-    fetchQuotedTweetsPage(tweetId: string, maxQuotes?: number, cursor?: string): Promise<QueryTweetsResponse>;
-}
-
-/**
- * Class representing a Twitter post client for generating and posting tweets.
- */
-declare class TwitterPostClient {
-    client: ClientBase;
-    runtime: IAgentRuntime;
-    twitterUsername: string;
-    private isDryRun;
-    private state;
-    private isRunning;
-    /**
-     * Constructor for initializing a new Twitter client with the provided client, runtime, and state
-     * @param {ClientBase} client - The client used for interacting with Twitter API
-     * @param {IAgentRuntime} runtime - The runtime environment for the agent
-     * @param {any} state - The state object containing configuration settings
-     */
-    constructor(client: ClientBase, runtime: IAgentRuntime, state: any);
-    /**
-     * Stops the Twitter post client
-     */
-    stop(): Promise<void>;
-    /**
-     * Starts the Twitter post client, setting up a loop to periodically generate new tweets.
-     */
-    start(): Promise<void>;
-    /**
-     * Handles the creation and posting of a tweet by emitting standardized events.
-     * This approach aligns with our platform-independent architecture.
-     */
-    generateNewTweet(): Promise<void>;
-    /**
-     * Posts content to Twitter
-     * @param {string} text The tweet text to post
-     * @param {MediaData[]} mediaData Optional media to attach to the tweet
-     * @returns {Promise<any>} The result from the Twitter API
-     */
-    private postToTwitter;
-}
-
-/**
- * @interface ITwitterClient
- * Represents the main Twitter client interface for interacting with Twitter's API.
- * @property {ClientBase} client - The base client for Twitter operations.
- * @property {TwitterPostClient} post - The client for managing Twitter posts.
- * @property {TwitterInteractionClient} interaction - The client for managing Twitter interactions.
- */
-interface ITwitterClient {
-    client: ClientBase;
-    post: TwitterPostClient;
-    interaction: TwitterInteractionClient;
-}
-/**
- * Twitter-specific tweet type
- */
-type Tweet = {
-    id: string;
-    text: string;
-    userId: string;
-    username: string;
-    name: string;
-    conversationId: string;
-    inReplyToStatusId?: string;
-    timestamp: number;
-    photos: {
-        url: string;
-    }[];
-    mentions: string[];
-    hashtags: string[];
-    urls: string[];
-    videos: any[];
-    thread: any[];
-    permanentUrl: string;
-};
-/**
- * Twitter-specific memory interface
- */
-interface TwitterMemory extends Memory {
-    content: {
-        source: "twitter";
-        text?: string;
-        type?: string;
-        targetId?: string;
-        [key: string]: any;
-    };
-    roomId: UUID;
-}
-/**
- * Twitter-specific interaction memory
- */
-interface TwitterInteractionMemory extends TwitterMemory {
-    content: {
-        type: string;
-        source: "twitter";
-        targetId?: string;
-    };
-}
-/**
- * Twitter-specific interaction payload
- */
-interface TwitterInteractionPayload {
-    id: string;
-    type: "like" | "retweet" | "quote";
-    userId: string;
-    username: string;
-    name: string;
-    targetTweetId: string;
-    targetTweet: Tweet;
-    quoteTweet?: Tweet;
-    retweetId?: string;
-}
-
-/**
- * Represents a Twitter Profile.
- * @typedef {Object} TwitterProfile
- * @property {string} id - The unique identifier of the profile.
- * @property {string} username - The username of the profile.
- * @property {string} screenName - The screen name of the profile.
- * @property {string} bio - The biography of the profile.
- * @property {string[]} nicknames - An array of nicknames associated with the profile.
- */
-type TwitterProfile = {
-    id: string;
-    username: string;
-    screenName: string;
-    bio: string;
-    nicknames: string[];
-};
-/**
- * Class representing a request queue for handling asynchronous requests in a controlled manner.
- */
-declare class RequestQueue {
-    private queue;
-    private processing;
-    private maxRetries;
-    private retryAttempts;
-    /**
-     * Asynchronously adds a request to the queue, then processes the queue.
-     *
-     * @template T
-     * @param {() => Promise<T>} request - The request to be added to the queue
-     * @returns {Promise<T>} - A promise that resolves with the result of the request or rejects with an error
-     */
-    add<T>(request: () => Promise<T>): Promise<T>;
-    /**
-     * Asynchronously processes the queue of requests.
-     *
-     * @returns A promise that resolves when the queue has been fully processed.
-     */
-    private processQueue;
-    /**
-     * Implements an exponential backoff strategy for retrying a task.
-     * @param {number} retryCount - The number of retries attempted so far.
-     * @returns {Promise<void>} - A promise that resolves after a delay based on the retry count.
-     */
-    private exponentialBackoff;
-    /**
-     * Asynchronous method that creates a random delay between 1500ms and 3500ms.
-     *
-     * @returns A Promise that resolves after the random delay has passed.
-     */
-    private randomDelay;
-}
-/**
- * Class representing a base client for interacting with Twitter.
- * @extends EventEmitter
- */
-declare class ClientBase {
-    static _twitterClients: {
-        [accountIdentifier: string]: Client;
-    };
-    twitterClient: Client;
-    runtime: IAgentRuntime;
-    lastCheckedTweetId: bigint | null;
-    temperature: number;
-    requestQueue: RequestQueue;
-    profile: TwitterProfile | null;
-    /**
-     * Caches a tweet in the database.
-     *
-     * @param {Tweet} tweet - The tweet to cache.
-     * @returns {Promise<void>} A promise that resolves once the tweet is cached.
-     */
-    cacheTweet(tweet: Tweet$1): Promise<void>;
-    /**
-     * Retrieves a cached tweet by its ID.
-     * @param {string} tweetId - The ID of the tweet to retrieve from the cache.
-     * @returns {Promise<Tweet | undefined>} A Promise that resolves to the cached tweet, or undefined if the tweet is not found in the cache.
-     */
-    getCachedTweet(tweetId: string): Promise<Tweet$1 | undefined>;
-    /**
-     * Asynchronously retrieves a tweet with the specified ID.
-     * If the tweet is found in the cache, it is returned from the cache.
-     * If not, a request is made to the Twitter API to get the tweet, which is then cached and returned.
-     * @param {string} tweetId - The ID of the tweet to retrieve.
-     * @returns {Promise<Tweet>} A Promise that resolves to the retrieved tweet.
-     */
-    getTweet(tweetId: string): Promise<Tweet$1>;
-    callback: (self: ClientBase) => any;
-    /**
-     * This method is called when the application is ready.
-     * It throws an error indicating that it is not implemented in the base class
-     * and should be implemented in the subclass.
-     */
-    onReady(): void;
-    /**
-     * Parse the raw tweet data into a standardized Tweet object.
-     */
-    /**
-     * Parses a raw tweet object into a structured Tweet object.
-     *
-     * @param {any} raw - The raw tweet object to parse.
-     * @param {number} [depth=0] - The current depth of parsing nested quotes/retweets.
-     * @param {number} [maxDepth=3] - The maximum depth allowed for parsing nested quotes/retweets.
-     * @returns {Tweet} The parsed Tweet object.
-     */
-    state: any;
-    constructor(runtime: IAgentRuntime, state: any);
-    init(): Promise<void>;
-    fetchOwnPosts(count: number): Promise<Tweet$1[]>;
-    /**
-     * Fetch timeline for twitter account, optionally only from followed accounts
-     */
-    fetchHomeTimeline(count: number, following?: boolean): Promise<Tweet$1[]>;
-    fetchSearchTweets(query: string, maxTweets: number, searchMode: SearchMode, cursor?: string): Promise<QueryTweetsResponse>;
-    private populateTimeline;
-    saveRequestMessage(message: Memory, state: State): Promise<void>;
-    loadLatestCheckedTweetId(): Promise<void>;
-    cacheLatestCheckedTweetId(): Promise<void>;
-    getCachedTimeline(): Promise<Tweet$1[] | undefined>;
-    cacheTimeline(timeline: Tweet$1[]): Promise<void>;
-    cacheMentions(mentions: Tweet$1[]): Promise<void>;
-    fetchProfile(username: string): Promise<TwitterProfile>;
-    /**
-     * Fetches recent interactions (likes, retweets, quotes) for the authenticated user's tweets
-     */
-    fetchInteractions(): Promise<TwitterInteractionPayload[]>;
-    formatTweetToInteraction(tweet: any): TwitterInteractionPayload | null;
-}
-
-/**
- * The TwitterInteractionClient class manages Twitter interactions,
- * including handling mentions, managing timelines, and engaging with other users.
- * It extends the base Twitter client functionality to provide mention handling,
- * user interaction, and follow change detection capabilities.
- *
- * @extends ClientBase
- */
-declare class TwitterInteractionClient {
-    client: ClientBase;
-    runtime: IAgentRuntime;
-    twitterUsername: string;
-    private twitterUserId;
-    private isDryRun;
-    private state;
-    private isRunning;
-    private lastProcessedTimestamp;
-    /**
-     * Constructor to initialize the Twitter interaction client with runtime and state management.
-     *
-     * @param {ClientBase} client - The client instance.
-     * @param {IAgentRuntime} runtime - The runtime instance for agent operations.
-     * @param {any} state - The state object containing configuration settings.
-     */
-    constructor(client: ClientBase, runtime: IAgentRuntime, state: any);
-    /**
-     * Asynchronously starts the process of handling Twitter interactions on a loop.
-     * Uses the unified TWITTER_ENGAGEMENT_INTERVAL setting.
-     */
-    start(): Promise<void>;
-    /**
-     * Stops the Twitter interaction client
-     */
-    stop(): Promise<void>;
-    /**
-     * Asynchronously handles Twitter interactions by checking for mentions and target user posts.
-     */
-    handleTwitterInteractions(): Promise<void>;
-    /**
-     * Handle mentions and replies
-     */
-    private handleMentions;
-    /**
-     * Handle autonomous engagement with target users' posts
-     */
-    private handleTargetUserPosts;
-    /**
-     * Process tweets from target users for potential engagement
-     */
-    private processTargetUserTweets;
-    /**
-     * Process timeline for engagement when wildcard is configured
-     */
-    private processTimelineForEngagement;
-    /**
-     * Determine if the bot should engage with a specific tweet
-     */
-    private shouldEngageWithTweet;
-    /**
-     * Ensure tweet context exists (world, room, entity)
-     */
-    private ensureTweetContext;
-    /**
-     * Engage with a tweet by generating and sending a reply
-     */
-    private engageWithTweet;
-    /**
-     * Processes all incoming tweets that mention the bot.
-     * For each new tweet:
-     *  - Ensures world, room, and connection exist
-     *  - Saves the tweet as memory
-     *  - Emits thread-related events (THREAD_CREATED / THREAD_UPDATED)
-     *  - Delegates tweet content to `handleTweet` for reply generation
-     *
-     * Note: MENTION_RECEIVED is currently disabled (see TODO below)
-     */
-    processMentionTweets(mentionCandidates: Tweet$1[]): Promise<void>;
-    /**
-     * Handles Twitter interactions such as likes, retweets, and quotes.
-     * For each interaction:
-     *  - Creates a memory object
-     *  - Emits platform-specific events (LIKE_RECEIVED, RETWEET_RECEIVED, QUOTE_RECEIVED)
-     *  - Emits a generic REACTION_RECEIVED event with metadata
-     */
-    handleInteraction(interaction: TwitterInteractionPayload): Promise<void>;
-    /**
-     * Creates a memory object for a given Twitter interaction.
-     *
-     * @param {string} type - The type of interaction (e.g., 'like', 'retweet', 'quote').
-     * @param {string} id - The unique identifier for the interaction.
-     * @param {string} userId - The ID of the user who initiated the interaction.
-     * @param {string} conversationId - The ID of the conversation context.
-     * @returns {TwitterInteractionMemory} The constructed memory object.
-     */
-    createMemoryObject(type: string, id: string, userId: string, conversationId: string): TwitterInteractionMemory;
-    /**
-     * Asynchronously handles a tweet by generating a response and sending it.
-     * This method processes the tweet content, determines if a response is needed,
-     * generates appropriate response text, and sends the tweet reply.
-     *
-     * @param {object} params - The parameters object containing the tweet, message, and thread.
-     * @param {Tweet} params.tweet - The tweet object to handle.
-     * @param {Memory} params.message - The memory object associated with the tweet.
-     * @param {Tweet[]} params.thread - The array of tweets in the thread.
-     * @returns {object} - An object containing the text of the response and any relevant actions.
-     */
-    handleTweet({ tweet, message, thread, }: {
-        tweet: Tweet$1;
-        message: Memory;
-        thread: Tweet$1[];
-    }): Promise<{
-        text: string;
-        actions: string[];
-    }>;
-}
-
-declare enum TIMELINE_TYPE {
-    ForYou = "foryou",
-    Following = "following"
-}
-declare class TwitterTimelineClient {
-    client: ClientBase;
-    twitterClient: Client;
-    runtime: IAgentRuntime;
-    isDryRun: boolean;
-    timelineType: TIMELINE_TYPE;
-    private state;
-    private isRunning;
-    constructor(client: ClientBase, runtime: IAgentRuntime, state: any);
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    getTimeline(count: number): Promise<Tweet$1[]>;
-    createTweetId(runtime: IAgentRuntime, tweet: Tweet$1): `${string}-${string}-${string}-${string}-${string}`;
-    formMessage(runtime: IAgentRuntime, tweet: Tweet$1): {
-        id: `${string}-${string}-${string}-${string}-${string}`;
-        agentId: `${string}-${string}-${string}-${string}-${string}`;
-        content: {
-            text: string;
-            url: string;
-            imageUrls: string[];
-            inReplyTo: `${string}-${string}-${string}-${string}-${string}`;
-            source: string;
-            channelType: ChannelType;
-            tweet: Tweet$1;
-        };
-        entityId: `${string}-${string}-${string}-${string}-${string}`;
-        roomId: `${string}-${string}-${string}-${string}-${string}`;
-        createdAt: number;
-    };
-    handleTimeline(): Promise<void>;
-    private processTimelineActions;
-    private ensureTweetWorldContext;
-    handleLikeAction(tweet: Tweet$1): Promise<void>;
-    handleRetweetAction(tweet: Tweet$1): Promise<void>;
-    handleQuoteAction(tweet: Tweet$1): Promise<void>;
-    handleReplyAction(tweet: Tweet$1): Promise<void>;
-}
-
-declare class TwitterDiscoveryClient {
-    private client;
-    private twitterClient;
-    private runtime;
-    private config;
-    private isRunning;
-    private isDryRun;
-    constructor(client: ClientBase, runtime: IAgentRuntime, state: any);
-    private buildDiscoveryConfig;
-    private extractTopicsFromBio;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    private runDiscoveryCycle;
-    private discoverContent;
-    private discoverFromTopics;
-    private discoverFromThreads;
-    private discoverFromPopularAccounts;
-    private scoreTweet;
-    private scoreAccount;
-    private processAccounts;
-    private processTweets;
-    private checkIfFollowing;
-    private generateReply;
-    private generateQuote;
-    private saveEngagementMemory;
-    private saveFollowMemory;
-    private delay;
-}
-
-declare class TwitterService extends Service {
-    static serviceType: string;
-    capabilityDescription: string;
-    constructor();
-    static start(runtime: IAgentRuntime): Promise<TwitterService>;
-    stop(): Promise<void>;
-}
-
-/**
- * A manager that orchestrates all specialized Twitter logic:
- * - client: base operations (login, timeline caching, etc.)
- * - post: autonomous posting logic
- * - interaction: handling mentions, replies, and autonomous targeting
- * - timeline: processing timeline for actions (likes, retweets, replies)
- * - discovery: autonomous content discovery and engagement
- */
-declare class TwitterClientInstance implements ITwitterClient {
-    client: ClientBase;
-    post: TwitterPostClient;
-    interaction: TwitterInteractionClient;
-    timeline?: TwitterTimelineClient;
-    discovery?: TwitterDiscoveryClient;
-    constructor(runtime: IAgentRuntime, state: any);
-}
-declare function startTwitterClient(runtime: IAgentRuntime): Promise<void>;
-declare const TwitterPlugin: {
-    name: string;
-    description: string;
-    actions: _elizaos_core.Action[];
-    services: (typeof TwitterService)[];
-    init: typeof startTwitterClient;
-};
-
-export { TwitterClientInstance, TwitterPlugin, TwitterPlugin as default };
+export { TwitterPlugin, TwitterPlugin as default };