corsair 0.1.36 → 0.1.37

package/dist/index.js

@@ -39793,622 +39793,337 @@ var get59 = async (ctx, input) => {
   return response;
 };
 
-// plugins/twitterapiio/endpoints/tweets.ts
-var getByIds = async (ctx, input) => {
-  const response = await makeTwitterApiIORequest("/twitter/tweets", ctx.key, {
-    method: "GET",
-    query: { tweet_ids: input.tweetIds }
-  });
-  if (response.tweets) {
-    try {
-      for (const tweet of response.tweets) {
-        await persistTweetWithAuthor(tweet, ctx.db);
-      }
-    } catch (error) {
-      console.warn("[twitterapiio] Failed to save tweets to database:", error);
-    }
+// plugins/twitterapiio/endpoints/types.ts
+import { z as z71 } from "zod";
+
+// plugins/twitterapiio/schema/database.ts
+import { z as z70 } from "zod";
+var TwitterApiIOUser = z70.object({
+  id: z70.string(),
+  userName: z70.string(),
+  name: z70.string(),
+  followerCount: z70.number().optional(),
+  followingCount: z70.number().optional(),
+  profilePicture: z70.string().nullable().optional(),
+  coverPicture: z70.string().nullable().optional(),
+  description: z70.string().nullable().optional(),
+  location: z70.string().nullable().optional(),
+  isBlueVerified: z70.boolean().optional(),
+  isGovernmentVerified: z70.boolean().optional(),
+  favouritesCount: z70.number().optional(),
+  statusesCount: z70.number().optional(),
+  mediaCount: z70.number().optional(),
+  createdAt: z70.string().optional(),
+  isProtected: z70.boolean().optional(),
+  isSuspended: z70.boolean().optional(),
+  isUnavailable: z70.boolean().optional(),
+  pinnedTweetIds: z70.array(z70.string()).optional(),
+  website: z70.string().nullable().optional()
+});
+var TwitterApiIOTweetMedia = z70.object({
+  type: z70.string().optional(),
+  url: z70.string().optional(),
+  mediaUrlHttps: z70.string().optional(),
+  expandedUrl: z70.string().optional(),
+  width: z70.number().optional(),
+  height: z70.number().optional(),
+  altText: z70.string().nullable().optional(),
+  durationMs: z70.number().nullable().optional()
+});
+var TwitterApiIOTweet = z70.object({
+  id: z70.string(),
+  text: z70.string(),
+  author: z70.string().optional(),
+  createdAt: z70.string().optional(),
+  likeCount: z70.number().optional(),
+  retweetCount: z70.number().optional(),
+  replyCount: z70.number().optional(),
+  quoteCount: z70.number().optional(),
+  viewCount: z70.number().nullable().optional(),
+  bookmarkCount: z70.number().optional(),
+  lang: z70.string().optional(),
+  source: z70.string().optional(),
+  isRetweet: z70.boolean().optional(),
+  isQuote: z70.boolean().optional(),
+  isPinned: z70.boolean().optional(),
+  inReplyToStatusId: z70.string().nullable().optional(),
+  inReplyToUserId: z70.string().nullable().optional(),
+  quotedTweetId: z70.string().nullable().optional(),
+  media: z70.array(TwitterApiIOTweetMedia).optional(),
+  entities: z70.object({
+    urls: z70.array(
+      z70.object({
+        url: z70.string().optional(),
+        expandedUrl: z70.string().optional(),
+        displayUrl: z70.string().optional()
+      })
+    ).optional(),
+    hashtags: z70.array(
+      z70.object({
+        text: z70.string().optional()
+      })
+    ).optional(),
+    userMentions: z70.array(
+      z70.object({
+        id: z70.string().optional(),
+        name: z70.string().optional(),
+        screenName: z70.string().optional()
+      })
+    ).optional()
+  }).optional(),
+  conversationId: z70.string().optional()
+});
+var TwitterApiIOList = z70.object({
+  id: z70.string(),
+  name: z70.string(),
+  description: z70.string().nullable().optional(),
+  memberCount: z70.number().optional(),
+  followerCount: z70.number().optional(),
+  owner: TwitterApiIOUser.optional(),
+  createdAt: z70.string().optional(),
+  isPrivate: z70.boolean().optional()
+});
+var TwitterApiIOCommunity = z70.object({
+  id: z70.string(),
+  name: z70.string(),
+  description: z70.string().nullable().optional(),
+  memberCount: z70.number().optional(),
+  role: z70.string().optional(),
+  createdAt: z70.string().optional(),
+  isNsfw: z70.boolean().optional(),
+  adminResults: z70.array(z70.any()).optional(),
+  moderatorResults: z70.array(z70.any()).optional(),
+  rules: z70.array(z70.any()).optional(),
+  primaryTopic: z70.any().optional()
+});
+var TwitterApiIOTrend = z70.object({
+  name: z70.string(),
+  tweetVolume: z70.number().nullable().optional(),
+  url: z70.string().optional(),
+  woeid: z70.number().optional(),
+  trendingAt: z70.string().optional()
+});
+var RawApiTweet = TwitterApiIOTweet.extend({
+  author: TwitterApiIOUser.optional()
+});
+
+// plugins/twitterapiio/endpoints/types.ts
+var PaginatedTweetsResponseSchema = z71.object({
+  status: z71.boolean().optional(),
+  tweets: z71.array(RawApiTweet).optional(),
+  next_cursor: z71.string().nullable().optional(),
+  has_next_page: z71.boolean().optional()
+});
+var PaginatedUsersResponseSchema = z71.object({
+  status: z71.boolean().optional(),
+  users: z71.array(TwitterApiIOUser).optional(),
+  next_cursor: z71.string().nullable().optional(),
+  has_next_page: z71.boolean().optional()
+});
+var ActionResponseSchema = z71.object({
+  status: z71.boolean().optional(),
+  message: z71.string().optional()
+});
+var TweetsGetByIdsInputSchema = z71.object({
+  tweetIds: z71.string().describe("Comma-separated list of tweet IDs")
+});
+var TweetsSearchInputSchema = z71.object({
+  query: z71.string(),
+  queryType: z71.enum(["Top", "Latest", "Photos", "Videos"]).optional().describe("Search type. Defaults to Top"),
+  cursor: z71.string().optional()
+});
+var TwitterLanguageCode = z71.enum([
+  "am",
+  "ar",
+  "bg",
+  "bn",
+  "bo",
+  "ca",
+  "cs",
+  "cy",
+  "da",
+  "de",
+  "dv",
+  "el",
+  "en",
+  "es",
+  "et",
+  "eu",
+  "fa",
+  "fi",
+  "fr",
+  "ga",
+  "gl",
+  "gu",
+  "he",
+  "hi",
+  "hr",
+  "hy",
+  "id",
+  "is",
+  "it",
+  "ja",
+  "ka",
+  "km",
+  "kn",
+  "ko",
+  "lo",
+  "lt",
+  "lv",
+  "ml",
+  "mr",
+  "my",
+  "ne",
+  "nl",
+  "no",
+  "or",
+  "pa",
+  "pl",
+  "ps",
+  "pt",
+  "ro",
+  "ru",
+  "si",
+  "sk",
+  "sl",
+  "sq",
+  "sr",
+  "sv",
+  "sw",
+  "ta",
+  "te",
+  "th",
+  "tl",
+  "tr",
+  "ug",
+  "uk",
+  "ur",
+  "vi",
+  "zh"
+]);
+var TweetsAdvancedSearchInputSchema = z71.object({
+  // ── Content filters ────────────────────────────────────────────────────
+  /** Words that must ALL appear in the tweet (AND logic) */
+  keywords: z71.array(z71.string().min(1)).optional().describe("Words that must all appear in tweets (AND logic)"),
+  /** Exact phrase that must appear verbatim */
+  exactPhrase: z71.string().optional().describe("Exact phrase that must appear in tweets"),
+  /** At least one of these words must appear (OR logic) */
+  anyOf: z71.array(z71.string().min(1)).min(2).optional().describe("At least one of these words must appear (OR logic, minimum 2 items)"),
+  /** Words that must NOT appear in the tweet */
+  excludeKeywords: z71.array(z71.string().min(1)).optional().describe("Words that must not appear in tweets"),
+  /** Hashtags to match (with or without leading #) */
+  hashtags: z71.array(z71.string().min(1)).optional().describe("Hashtags to search for (with or without leading #)"),
+  // ── User filters ───────────────────────────────────────────────────────
+  /** Only return tweets sent by these usernames */
+  fromUsers: z71.array(z71.string().min(1)).optional().describe("Only tweets from these usernames"),
+  /** Only return tweets that are replies to these usernames */
+  toUsers: z71.array(z71.string().min(1)).optional().describe("Only replies to these usernames"),
+  /** Only return tweets that mention these usernames */
+  mentioningUsers: z71.array(z71.string().min(1)).optional().describe("Only tweets mentioning these usernames"),
+  // ── Language filter ────────────────────────────────────────────────────
+  /** ISO 639-1 language code to restrict results */
+  language: TwitterLanguageCode.optional().describe(
+    'ISO 639-1 language code (e.g. "en", "fr", "ja")'
+  ),
+  // ── Time filters ───────────────────────────────────────────────────────
+  /** Return tweets posted on or after this date (YYYY-MM-DD) */
+  since: z71.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Must be YYYY-MM-DD").optional().describe("Only tweets posted on or after this date (YYYY-MM-DD)"),
+  /** Return tweets posted before this date (YYYY-MM-DD) */
+  until: z71.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Must be YYYY-MM-DD").optional().describe("Only tweets posted before this date (YYYY-MM-DD)"),
+  // ── Tweet-type filters ─────────────────────────────────────────────────
+  /** Whether to include or exclude replies */
+  replies: z71.enum(["only", "exclude"]).optional().describe('"only" to return only replies; "exclude" to omit replies'),
+  /** Whether to include or exclude retweets */
+  retweets: z71.enum(["only", "exclude"]).optional().describe('"only" to return only retweets; "exclude" to omit retweets'),
+  /** Only return tweets that contain at least one link */
+  onlyLinks: z71.boolean().optional().describe("Only tweets containing links"),
+  /** Only return tweets that contain media (images or video) */
+  onlyMedia: z71.boolean().optional().describe("Only tweets with media"),
+  /** Only return tweets that contain images */
+  onlyImages: z71.boolean().optional().describe("Only tweets with images"),
+  /** Only return tweets that contain native video */
+  onlyVideos: z71.boolean().optional().describe("Only tweets with native video"),
+  // ── Engagement thresholds ──────────────────────────────────────────────
+  /** Only return tweets with at least this many replies */
+  minReplies: z71.number().int().nonnegative().optional().describe("Minimum number of replies"),
+  /** Only return tweets with at least this many likes */
+  minLikes: z71.number().int().nonnegative().optional().describe("Minimum number of likes"),
+  /** Only return tweets with at least this many retweets */
+  minRetweets: z71.number().int().nonnegative().optional().describe("Minimum number of retweets"),
+  // ── Result ordering & pagination ───────────────────────────────────────
+  queryType: z71.enum(["Latest", "Top"]).optional().describe('Result ordering \u2014 "Latest" (default) or "Top"'),
+  cursor: z71.string().optional()
+});
+function buildAdvancedSearchQuery(input) {
+  const parts = [];
+  if (input.keywords?.length) {
+    parts.push(input.keywords.join(" "));
   }
-  await logEventFromContext(
-    ctx,
-    "twitterapiio.tweets.getByIds",
-    { ...input },
-    "completed"
-  );
-  return response;
-};
-var search11 = async (ctx, input) => {
-  const { query, queryType, cursor } = input;
-  const response = await makeTwitterApiIORequest("/twitter/tweet/advanced_search", ctx.key, {
-    method: "GET",
-    query: { query, queryType, cursor }
-  });
-  if (response.tweets) {
-    try {
-      for (const tweet of response.tweets) {
-        await persistTweetWithAuthor(tweet, ctx.db);
-      }
-    } catch (error) {
-      console.warn("[twitterapiio] Failed to save tweets to database:", error);
-    }
+  if (input.exactPhrase) {
+    parts.push(`"${input.exactPhrase}"`);
   }
-  await logEventFromContext(
-    ctx,
-    "twitterapiio.tweets.search",
-    { ...input },
-    "completed"
-  );
-  return response;
-};
-var getUserTimeline = async (ctx, input) => {
-  const response = await makeTwitterApiIORequest("/twitter/user/timeline", ctx.key, {
-    method: "GET",
-    query: { userId: input.userId, cursor: input.cursor }
-  });
-  if (response.tweets) {
-    try {
-      for (const tweet of response.tweets) {
-        await persistTweetWithAuthor(tweet, ctx.db);
-      }
-    } catch (error) {
-      console.warn(
-        "[twitterapiio] Failed to save tweets to database:",
-        error
-      );
-    }
+  if (input.anyOf?.length) {
+    parts.push(`(${input.anyOf.join(" OR ")})`);
   }
-  await logEventFromContext(
-    ctx,
-    "twitterapiio.tweets.getUserTimeline",
-    { ...input },
-    "completed"
-  );
-  return response;
-};
-var getUserLastTweets = async (ctx, input) => {
-  const response = await makeTwitterApiIORequest("/twitter/user/last_tweets", ctx.key, {
-    method: "GET",
-    query: { userName: input.userName, cursor: input.cursor }
-  });
-  if (response.tweets) {
-    try {
-      for (const tweet of response.tweets) {
-        await persistTweetWithAuthor(tweet, ctx.db);
-      }
-    } catch (error) {
-      console.warn(
-        "[twitterapiio] Failed to save tweets to database:",
-        error
-      );
-    }
+  if (input.excludeKeywords?.length) {
+    parts.push(...input.excludeKeywords.map((k) => `-${k}`));
   }
-  await logEventFromContext(
-    ctx,
-    "twitterapiio.tweets.getUserLastTweets",
-    { ...input },
-    "completed"
-  );
-  return response;
-};
-var getUserMentions = async (ctx, input) => {
-  const response = await makeTwitterApiIORequest("/twitter/user/mentions", ctx.key, {
-    method: "GET",
-    query: { userName: input.userName, cursor: input.cursor }
-  });
-  if (response.tweets) {
-    try {
-      for (const tweet of response.tweets) {
-        await persistTweetWithAuthor(tweet, ctx.db);
-      }
-    } catch (error) {
-      console.warn(
-        "[twitterapiio] Failed to save tweets to database:",
-        error
-      );
-    }
+  if (input.hashtags?.length) {
+    parts.push(
+      ...input.hashtags.map((h) => h.startsWith("#") ? h : `#${h}`)
+    );
   }
-  await logEventFromContext(
-    ctx,
-    "twitterapiio.tweets.getUserMentions",
-    { ...input },
-    "completed"
-  );
-  return response;
-};
-var getReplies2 = async (ctx, input) => {
-  const { tweetId, sinceTime, untilTime, cursor } = input;
-  const response = await makeTwitterApiIORequest("/twitter/tweet/replies", ctx.key, {
-    method: "GET",
-    query: { tweetId, sinceTime, untilTime, cursor }
-  });
-  if (response.tweets) {
-    try {
-      for (const tweet of response.tweets) {
-        await persistTweetWithAuthor(tweet, ctx.db);
-      }
-    } catch (error) {
-      console.warn("[twitterapiio] Failed to save tweets to database:", error);
-    }
+  if (input.fromUsers?.length) {
+    parts.push(...input.fromUsers.map((u) => `from:${u}`));
   }
-  await logEventFromContext(
-    ctx,
-    "twitterapiio.tweets.getReplies",
-    { ...input },
-    "completed"
-  );
-  return response;
-};
-var getQuotations = async (ctx, input) => {
-  const response = await makeTwitterApiIORequest("/twitter/tweet/quotes", ctx.key, {
-    method: "GET",
-    query: { tweetId: input.tweetId, cursor: input.cursor }
-  });
-  if (response.tweets) {
-    try {
-      for (const tweet of response.tweets) {
-        await persistTweetWithAuthor(tweet, ctx.db);
-      }
-    } catch (error) {
-      console.warn(
-        "[twitterapiio] Failed to save tweets to database:",
-        error
-      );
-    }
+  if (input.toUsers?.length) {
+    parts.push(...input.toUsers.map((u) => `to:${u}`));
   }
-  await logEventFromContext(
-    ctx,
-    "twitterapiio.tweets.getQuotations",
-    { ...input },
-    "completed"
-  );
-  return response;
-};
-var getRetweeters = async (ctx, input) => {
-  const response = await makeTwitterApiIORequest("/twitter/tweet/retweeters", ctx.key, {
-    method: "GET",
-    query: { tweetId: input.tweetId, cursor: input.cursor }
-  });
-  if (response.users && ctx.db.users) {
-    try {
-      for (const user of response.users) {
-        await ctx.db.users.upsertByEntityId(user.id, user);
-      }
-    } catch (error) {
-      console.warn("[twitterapiio] Failed to save users to database:", error);
-    }
+  if (input.mentioningUsers?.length) {
+    parts.push(...input.mentioningUsers.map((u) => `@${u}`));
   }
-  await logEventFromContext(
-    ctx,
-    "twitterapiio.tweets.getRetweeters",
-    { ...input },
-    "completed"
-  );
-  return response;
-};
-var getThreadContext = async (ctx, input) => {
-  const response = await makeTwitterApiIORequest("/twitter/tweet/thread_context", ctx.key, {
-    method: "GET",
-    query: { tweetId: input.tweetId, cursor: input.cursor }
-  });
-  if (response.tweets) {
-    try {
-      for (const tweet of response.tweets) {
-        await persistTweetWithAuthor(tweet, ctx.db);
-      }
-    } catch (error) {
-      console.warn(
-        "[twitterapiio] Failed to save tweets to database:",
-        error
-      );
-    }
+  if (input.language) {
+    parts.push(`lang:${input.language}`);
   }
-  await logEventFromContext(
-    ctx,
-    "twitterapiio.tweets.getThreadContext",
-    { ...input },
-    "completed"
-  );
-  return response;
-};
-var create44 = async (ctx, input) => {
-  const { tweet, loginCookie, replyToTweetId, mediaIds } = input;
-  const response = await makeTwitterApiIORequest("/twitter/create_tweet", ctx.key, {
-    method: "POST",
-    body: {
-      tweet,
-      login_cookie: loginCookie,
-      ...replyToTweetId ? { reply_to_tweet_id: replyToTweetId } : {},
-      ...mediaIds ? { media_ids: mediaIds } : {}
-    }
-  });
-  await logEventFromContext(
-    ctx,
-    "twitterapiio.tweets.create",
-    { tweet, replyToTweetId },
-    "completed"
-  );
-  return response;
-};
-var deleteTweet = async (ctx, input) => {
-  const response = await makeTwitterApiIORequest("/twitter/tweet/delete", ctx.key, {
-    method: "POST",
-    body: { tweetId: input.tweetId, login_cookie: input.loginCookie }
-  });
-  await logEventFromContext(
-    ctx,
-    "twitterapiio.tweets.delete",
-    { tweetId: input.tweetId },
-    "completed"
-  );
-  return response;
-};
-var like = async (ctx, input) => {
-  const response = await makeTwitterApiIORequest("/twitter/tweet/like", ctx.key, {
-    method: "POST",
-    body: { tweetId: input.tweetId, login_cookie: input.loginCookie }
-  });
-  await logEventFromContext(
-    ctx,
-    "twitterapiio.tweets.like",
-    { tweetId: input.tweetId },
-    "completed"
-  );
-  return response;
-};
-var unlike = async (ctx, input) => {
-  const response = await makeTwitterApiIORequest("/twitter/tweet/unlike", ctx.key, {
-    method: "POST",
-    body: { tweetId: input.tweetId, login_cookie: input.loginCookie }
-  });
-  await logEventFromContext(
-    ctx,
-    "twitterapiio.tweets.unlike",
-    { tweetId: input.tweetId },
-    "completed"
-  );
-  return response;
-};
-var retweet = async (ctx, input) => {
-  const response = await makeTwitterApiIORequest("/twitter/tweet/retweet", ctx.key, {
-    method: "POST",
-    body: { tweetId: input.tweetId, login_cookie: input.loginCookie }
-  });
-  await logEventFromContext(
-    ctx,
-    "twitterapiio.tweets.retweet",
-    { tweetId: input.tweetId },
-    "completed"
-  );
-  return response;
-};
-
-// plugins/twitterapiio/endpoints/users.ts
-var getByUsername = async (ctx, input) => {
-  const response = await makeTwitterApiIORequest("/twitter/user/info", ctx.key, {
-    method: "GET",
-    query: { userName: input.userName }
-  });
-  if (response.data && ctx.db.users) {
-    try {
-      await ctx.db.users.upsertByEntityId(response.data.id, response.data);
-    } catch (error) {
-      console.warn("[twitterapiio] Failed to save user to database:", error);
-    }
+  if (input.since) {
+    parts.push(`since:${input.since}`);
   }
-  await logEventFromContext(
-    ctx,
-    "twitterapiio.users.getByUsername",
-    { ...input },
-    "completed"
-  );
-  return response;
-};
-var batchGetByIds = async (ctx, input) => {
-  const response = await makeTwitterApiIORequest("/twitter/user/batch_info_by_ids", ctx.key, {
-    method: "GET",
-    query: { userIds: input.userIds }
-  });
-  if (response.data && ctx.db.users) {
-    try {
-      for (const user of response.data) {
-        await ctx.db.users.upsertByEntityId(user.id, user);
-      }
-    } catch (error) {
-      console.warn("[twitterapiio] Failed to save users to database:", error);
-    }
+  if (input.until) {
+    parts.push(`until:${input.until}`);
   }
-  await logEventFromContext(
-    ctx,
-    "twitterapiio.users.batchGetByIds",
-    { ...input },
-    "completed"
-  );
-  return response;
-};
-var search12 = async (ctx, input) => {
-  const response = await makeTwitterApiIORequest("/twitter/user/search", ctx.key, {
-    method: "GET",
-    query: { keyword: input.keyword, cursor: input.cursor }
-  });
-  if (response.users && ctx.db.users) {
-    try {
-      for (const user of response.users) {
-        await ctx.db.users.upsertByEntityId(user.id, user);
-      }
-    } catch (error) {
-      console.warn("[twitterapiio] Failed to save users to database:", error);
-    }
+  if (input.replies === "only") {
+    parts.push("filter:replies");
+  } else if (input.replies === "exclude") {
+    parts.push("-filter:replies");
   }
-  await logEventFromContext(
-    ctx,
-    "twitterapiio.users.search",
-    { ...input },
-    "completed"
-  );
-  return response;
-};
-var getFollowers2 = async (ctx, input) => {
-  const response = await makeTwitterApiIORequest("/twitter/user/followers", ctx.key, {
-    method: "GET",
-    query: { userName: input.userName, cursor: input.cursor }
-  });
-  if (response.users && ctx.db.users) {
-    try {
-      for (const user of response.users) {
-        await ctx.db.users.upsertByEntityId(user.id, user);
-      }
-    } catch (error) {
-      console.warn("[twitterapiio] Failed to save users to database:", error);
-    }
+  if (input.retweets === "only") {
+    parts.push("filter:retweets");
+  } else if (input.retweets === "exclude") {
+    parts.push("-filter:retweets");
   }
-  await logEventFromContext(
-    ctx,
-    "twitterapiio.users.getFollowers",
-    { ...input },
-    "completed"
-  );
-  return response;
-};
-var getVerifiedFollowers = async (ctx, input) => {
-  const response = await makeTwitterApiIORequest("/twitter/user/verified_followers", ctx.key, {
-    method: "GET",
-    query: { userName: input.userName, cursor: input.cursor }
-  });
-  if (response.users && ctx.db.users) {
-    try {
-      for (const user of response.users) {
-        await ctx.db.users.upsertByEntityId(user.id, user);
-      }
-    } catch (error) {
-      console.warn("[twitterapiio] Failed to save users to database:", error);
-    }
+  if (input.onlyLinks) {
+    parts.push("filter:links");
   }
-  await logEventFromContext(
-    ctx,
-    "twitterapiio.users.getVerifiedFollowers",
-    { ...input },
-    "completed"
-  );
-  return response;
-};
-var getFollowings = async (ctx, input) => {
-  const response = await makeTwitterApiIORequest("/twitter/user/followings", ctx.key, {
-    method: "GET",
-    query: { userName: input.userName, cursor: input.cursor }
-  });
-  if (response.users && ctx.db.users) {
-    try {
-      for (const user of response.users) {
-        await ctx.db.users.upsertByEntityId(user.id, user);
-      }
-    } catch (error) {
-      console.warn("[twitterapiio] Failed to save users to database:", error);
-    }
+  if (input.onlyMedia) {
+    parts.push("filter:media");
   }
-  await logEventFromContext(
-    ctx,
-    "twitterapiio.users.getFollowings",
-    { ...input },
-    "completed"
-  );
-  return response;
-};
-var checkFollowRelationship = async (ctx, input) => {
-  const response = await makeTwitterApiIORequest("/twitter/user/follow_relation", ctx.key, {
-    method: "GET",
-    query: {
-      sourceUserName: input.sourceUserName,
-      targetUserName: input.targetUserName
-    }
-  });
-  await logEventFromContext(
-    ctx,
-    "twitterapiio.users.checkFollowRelationship",
-    { ...input },
-    "completed"
-  );
-  return response;
-};
-var follow = async (ctx, input) => {
-  const response = await makeTwitterApiIORequest("/twitter/user/follow", ctx.key, {
-    method: "POST",
-    body: { followId: input.followId, login_cookie: input.loginCookie }
-  });
-  await logEventFromContext(
-    ctx,
-    "twitterapiio.users.follow",
-    { followId: input.followId },
-    "completed"
-  );
-  return response;
-};
-var unfollow = async (ctx, input) => {
-  const response = await makeTwitterApiIORequest("/twitter/user/unfollow", ctx.key, {
-    method: "POST",
-    body: { followId: input.followId, login_cookie: input.loginCookie }
-  });
-  await logEventFromContext(
-    ctx,
-    "twitterapiio.users.unfollow",
-    { followId: input.followId },
-    "completed"
-  );
-  return response;
-};
-var getMe = async (ctx, input) => {
-  const response = await makeTwitterApiIORequest("/twitter/user/me", ctx.key, {
-    method: "GET",
-    query: { login_cookie: input.loginCookie }
-  });
-  if (response.data && ctx.db.users) {
-    try {
-      await ctx.db.users.upsertByEntityId(response.data.id, response.data);
-    } catch (error) {
-      console.warn("[twitterapiio] Failed to save user to database:", error);
-    }
+  if (input.onlyImages) {
+    parts.push("filter:images");
   }
-  await logEventFromContext(ctx, "twitterapiio.users.getMe", {}, "completed");
-  return response;
-};
-
-// plugins/twitterapiio/endpoints/types.ts
-import { z as z71 } from "zod";
-
-// plugins/twitterapiio/schema/database.ts
-import { z as z70 } from "zod";
-var TwitterApiIOUser = z70.object({
-  id: z70.string(),
-  userName: z70.string(),
-  name: z70.string(),
-  followerCount: z70.number().optional(),
-  followingCount: z70.number().optional(),
-  profilePicture: z70.string().nullable().optional(),
-  coverPicture: z70.string().nullable().optional(),
-  description: z70.string().nullable().optional(),
-  location: z70.string().nullable().optional(),
-  isBlueVerified: z70.boolean().optional(),
-  isGovernmentVerified: z70.boolean().optional(),
-  favouritesCount: z70.number().optional(),
-  statusesCount: z70.number().optional(),
-  mediaCount: z70.number().optional(),
-  createdAt: z70.string().optional(),
-  isProtected: z70.boolean().optional(),
-  isSuspended: z70.boolean().optional(),
-  isUnavailable: z70.boolean().optional(),
-  pinnedTweetIds: z70.array(z70.string()).optional(),
-  website: z70.string().nullable().optional()
-});
-var TwitterApiIOTweetMedia = z70.object({
-  type: z70.string().optional(),
-  url: z70.string().optional(),
-  mediaUrlHttps: z70.string().optional(),
-  expandedUrl: z70.string().optional(),
-  width: z70.number().optional(),
-  height: z70.number().optional(),
-  altText: z70.string().nullable().optional(),
-  durationMs: z70.number().nullable().optional()
-});
-var TwitterApiIOTweet = z70.object({
-  id: z70.string(),
-  text: z70.string(),
-  author: z70.string().optional(),
-  createdAt: z70.string().optional(),
-  likeCount: z70.number().optional(),
-  retweetCount: z70.number().optional(),
-  replyCount: z70.number().optional(),
-  quoteCount: z70.number().optional(),
-  viewCount: z70.number().nullable().optional(),
-  bookmarkCount: z70.number().optional(),
-  lang: z70.string().optional(),
-  source: z70.string().optional(),
-  isRetweet: z70.boolean().optional(),
-  isQuote: z70.boolean().optional(),
-  isPinned: z70.boolean().optional(),
-  inReplyToStatusId: z70.string().nullable().optional(),
-  inReplyToUserId: z70.string().nullable().optional(),
-  quotedTweetId: z70.string().nullable().optional(),
-  media: z70.array(TwitterApiIOTweetMedia).optional(),
-  entities: z70.object({
-    urls: z70.array(
-      z70.object({
-        url: z70.string().optional(),
-        expandedUrl: z70.string().optional(),
-        displayUrl: z70.string().optional()
-      })
-    ).optional(),
-    hashtags: z70.array(
-      z70.object({
-        text: z70.string().optional()
-      })
-    ).optional(),
-    userMentions: z70.array(
-      z70.object({
-        id: z70.string().optional(),
-        name: z70.string().optional(),
-        screenName: z70.string().optional()
-      })
-    ).optional()
-  }).optional(),
-  conversationId: z70.string().optional()
-});
-var TwitterApiIOList = z70.object({
-  id: z70.string(),
-  name: z70.string(),
-  description: z70.string().nullable().optional(),
-  memberCount: z70.number().optional(),
-  followerCount: z70.number().optional(),
-  owner: TwitterApiIOUser.optional(),
-  createdAt: z70.string().optional(),
-  isPrivate: z70.boolean().optional()
-});
-var TwitterApiIOCommunity = z70.object({
-  id: z70.string(),
-  name: z70.string(),
-  description: z70.string().nullable().optional(),
-  memberCount: z70.number().optional(),
-  role: z70.string().optional(),
-  createdAt: z70.string().optional(),
-  isNsfw: z70.boolean().optional(),
-  adminResults: z70.array(z70.any()).optional(),
-  moderatorResults: z70.array(z70.any()).optional(),
-  rules: z70.array(z70.any()).optional(),
-  primaryTopic: z70.any().optional()
-});
-var TwitterApiIOTrend = z70.object({
-  name: z70.string(),
-  tweetVolume: z70.number().nullable().optional(),
-  url: z70.string().optional(),
-  woeid: z70.number().optional(),
-  trendingAt: z70.string().optional()
-});
-var RawApiTweet = TwitterApiIOTweet.extend({
-  author: TwitterApiIOUser.optional()
-});
-
-// plugins/twitterapiio/endpoints/types.ts
-var PaginatedTweetsResponseSchema = z71.object({
-  status: z71.boolean().optional(),
-  tweets: z71.array(RawApiTweet).optional(),
-  next_cursor: z71.string().nullable().optional(),
-  has_next_page: z71.boolean().optional()
-});
-var PaginatedUsersResponseSchema = z71.object({
-  status: z71.boolean().optional(),
-  users: z71.array(TwitterApiIOUser).optional(),
-  next_cursor: z71.string().nullable().optional(),
-  has_next_page: z71.boolean().optional()
-});
-var ActionResponseSchema = z71.object({
-  status: z71.boolean().optional(),
-  message: z71.string().optional()
-});
-var TweetsGetByIdsInputSchema = z71.object({
-  tweetIds: z71.string().describe("Comma-separated list of tweet IDs")
-});
-var TweetsSearchInputSchema = z71.object({
-  query: z71.string(),
-  queryType: z71.enum(["Top", "Latest", "Photos", "Videos"]).optional().describe("Search type. Defaults to Top"),
-  cursor: z71.string().optional()
-});
+  if (input.onlyVideos) {
+    parts.push("filter:native_video");
+  }
+  if (input.minReplies !== void 0) {
+    parts.push(`min_replies:${input.minReplies}`);
+  }
+  if (input.minLikes !== void 0) {
+    parts.push(`min_faves:${input.minLikes}`);
+  }
+  if (input.minRetweets !== void 0) {
+    parts.push(`min_retweets:${input.minRetweets}`);
+  }
+  return parts.join(" ");
+}
 var TweetsGetUserTimelineInputSchema = z71.object({
   userId: z71.string(),
   cursor: z71.string().optional()
@@ -40583,6 +40298,7 @@ var TrendsGetResponseSchema = z71.object({
 var TwitterApiIOEndpointInputSchemas = {
   tweetsGetByIds: TweetsGetByIdsInputSchema,
   tweetsSearch: TweetsSearchInputSchema,
+  tweetsAdvancedSearch: TweetsAdvancedSearchInputSchema,
   tweetsGetUserTimeline: TweetsGetUserTimelineInputSchema,
   tweetsGetUserLastTweets: TweetsGetUserLastTweetsInputSchema,
   tweetsGetUserMentions: TweetsGetUserMentionsInputSchema,
@@ -40619,50 +40335,556 @@ var TwitterApiIOEndpointInputSchemas = {
   communitiesLeave: CommunitiesLeaveInputSchema,
   trendsGet: TrendsGetInputSchema
 };
-var TwitterApiIOEndpointOutputSchemas = {
-  tweetsGetByIds: TweetsGetByIdsResponseSchema,
-  tweetsSearch: PaginatedTweetsResponseSchema,
-  tweetsGetUserTimeline: PaginatedTweetsResponseSchema,
-  tweetsGetUserLastTweets: PaginatedTweetsResponseSchema,
-  tweetsGetUserMentions: PaginatedTweetsResponseSchema,
-  tweetsGetReplies: PaginatedTweetsResponseSchema,
-  tweetsGetQuotations: PaginatedTweetsResponseSchema,
-  tweetsGetRetweeters: PaginatedUsersResponseSchema,
-  tweetsGetThreadContext: PaginatedTweetsResponseSchema,
-  tweetsCreate: ActionResponseSchema,
-  tweetsDelete: ActionResponseSchema,
-  tweetsLike: ActionResponseSchema,
-  tweetsUnlike: ActionResponseSchema,
-  tweetsRetweet: ActionResponseSchema,
-  usersGetByUsername: UserGetResponseSchema2,
-  usersBatchGetByIds: UsersBatchGetByIdsResponseSchema,
-  usersSearch: PaginatedUsersResponseSchema,
-  usersGetFollowers: PaginatedUsersResponseSchema,
-  usersGetVerifiedFollowers: PaginatedUsersResponseSchema,
-  usersGetFollowings: PaginatedUsersResponseSchema,
-  usersCheckFollowRelationship: UsersCheckFollowRelationshipResponseSchema,
-  usersFollow: ActionResponseSchema,
-  usersUnfollow: ActionResponseSchema,
-  usersGetMe: UserGetResponseSchema2,
-  listsGetFollowers: PaginatedUsersResponseSchema,
-  listsGetMembers: PaginatedUsersResponseSchema,
-  listsGetTweets: PaginatedTweetsResponseSchema,
-  communitiesGetById: CommunitiesGetByIdResponseSchema,
-  communitiesGetMembers: CommunitiesMembersResponseSchema,
-  communitiesGetModerators: CommunitiesMembersResponseSchema,
-  communitiesGetTweets: PaginatedTweetsResponseSchema,
-  communitiesSearchTweets: PaginatedTweetsResponseSchema,
-  communitiesCreate: ActionResponseSchema,
-  communitiesDelete: ActionResponseSchema,
-  communitiesJoin: ActionResponseSchema,
-  communitiesLeave: ActionResponseSchema,
-  trendsGet: TrendsGetResponseSchema
+var TwitterApiIOEndpointOutputSchemas = {
+  tweetsGetByIds: TweetsGetByIdsResponseSchema,
+  tweetsSearch: PaginatedTweetsResponseSchema,
+  tweetsAdvancedSearch: PaginatedTweetsResponseSchema,
+  tweetsGetUserTimeline: PaginatedTweetsResponseSchema,
+  tweetsGetUserLastTweets: PaginatedTweetsResponseSchema,
+  tweetsGetUserMentions: PaginatedTweetsResponseSchema,
+  tweetsGetReplies: PaginatedTweetsResponseSchema,
+  tweetsGetQuotations: PaginatedTweetsResponseSchema,
+  tweetsGetRetweeters: PaginatedUsersResponseSchema,
+  tweetsGetThreadContext: PaginatedTweetsResponseSchema,
+  tweetsCreate: ActionResponseSchema,
+  tweetsDelete: ActionResponseSchema,
+  tweetsLike: ActionResponseSchema,
+  tweetsUnlike: ActionResponseSchema,
+  tweetsRetweet: ActionResponseSchema,
+  usersGetByUsername: UserGetResponseSchema2,
+  usersBatchGetByIds: UsersBatchGetByIdsResponseSchema,
+  usersSearch: PaginatedUsersResponseSchema,
+  usersGetFollowers: PaginatedUsersResponseSchema,
+  usersGetVerifiedFollowers: PaginatedUsersResponseSchema,
+  usersGetFollowings: PaginatedUsersResponseSchema,
+  usersCheckFollowRelationship: UsersCheckFollowRelationshipResponseSchema,
+  usersFollow: ActionResponseSchema,
+  usersUnfollow: ActionResponseSchema,
+  usersGetMe: UserGetResponseSchema2,
+  listsGetFollowers: PaginatedUsersResponseSchema,
+  listsGetMembers: PaginatedUsersResponseSchema,
+  listsGetTweets: PaginatedTweetsResponseSchema,
+  communitiesGetById: CommunitiesGetByIdResponseSchema,
+  communitiesGetMembers: CommunitiesMembersResponseSchema,
+  communitiesGetModerators: CommunitiesMembersResponseSchema,
+  communitiesGetTweets: PaginatedTweetsResponseSchema,
+  communitiesSearchTweets: PaginatedTweetsResponseSchema,
+  communitiesCreate: ActionResponseSchema,
+  communitiesDelete: ActionResponseSchema,
+  communitiesJoin: ActionResponseSchema,
+  communitiesLeave: ActionResponseSchema,
+  trendsGet: TrendsGetResponseSchema
+};
+
+// plugins/twitterapiio/endpoints/tweets.ts
+var getByIds = async (ctx, input) => {
+  const response = await makeTwitterApiIORequest("/twitter/tweets", ctx.key, {
+    method: "GET",
+    query: { tweet_ids: input.tweetIds }
+  });
+  if (response.tweets) {
+    try {
+      for (const tweet of response.tweets) {
+        await persistTweetWithAuthor(tweet, ctx.db);
+      }
+    } catch (error) {
+      console.warn("[twitterapiio] Failed to save tweets to database:", error);
+    }
+  }
+  await logEventFromContext(
+    ctx,
+    "twitterapiio.tweets.getByIds",
+    { ...input },
+    "completed"
+  );
+  return response;
+};
+var search11 = async (ctx, input) => {
+  const { query, queryType, cursor } = input;
+  const response = await makeTwitterApiIORequest("/twitter/tweet/advanced_search", ctx.key, {
+    method: "GET",
+    query: { query, queryType, cursor }
+  });
+  if (response.tweets) {
+    try {
+      for (const tweet of response.tweets) {
+        await persistTweetWithAuthor(tweet, ctx.db);
+      }
+    } catch (error) {
+      console.warn("[twitterapiio] Failed to save tweets to database:", error);
+    }
+  }
+  await logEventFromContext(
+    ctx,
+    "twitterapiio.tweets.search",
+    { ...input },
+    "completed"
+  );
+  return response;
+};
+var advancedSearch = async (ctx, input) => {
+  const { cursor, queryType, ...queryBuilderInput } = input;
+  const query = buildAdvancedSearchQuery(queryBuilderInput);
+  const response = await makeTwitterApiIORequest("/twitter/tweet/advanced_search", ctx.key, {
+    method: "GET",
+    query: { query, queryType: queryType ?? "Latest", cursor }
+  });
+  if (response.tweets) {
+    try {
+      for (const tweet of response.tweets) {
+        await persistTweetWithAuthor(tweet, ctx.db);
+      }
+    } catch (error) {
+      console.warn(
+        "[twitterapiio] Failed to save tweets to database:",
+        error
+      );
+    }
+  }
+  await logEventFromContext(
+    ctx,
+    "twitterapiio.tweets.advancedSearch",
+    { query, queryType, cursor },
+    "completed"
+  );
+  return response;
+};
+var getUserTimeline = async (ctx, input) => {
+  const response = await makeTwitterApiIORequest("/twitter/user/timeline", ctx.key, {
+    method: "GET",
+    query: { userId: input.userId, cursor: input.cursor }
+  });
+  if (response.tweets) {
+    try {
+      for (const tweet of response.tweets) {
+        await persistTweetWithAuthor(tweet, ctx.db);
+      }
+    } catch (error) {
+      console.warn(
+        "[twitterapiio] Failed to save tweets to database:",
+        error
+      );
+    }
+  }
+  await logEventFromContext(
+    ctx,
+    "twitterapiio.tweets.getUserTimeline",
+    { ...input },
+    "completed"
+  );
+  return response;
+};
+var getUserLastTweets = async (ctx, input) => {
+  const response = await makeTwitterApiIORequest("/twitter/user/last_tweets", ctx.key, {
+    method: "GET",
+    query: { userName: input.userName, cursor: input.cursor }
+  });
+  if (response.tweets) {
+    try {
+      for (const tweet of response.tweets) {
+        await persistTweetWithAuthor(tweet, ctx.db);
+      }
+    } catch (error) {
+      console.warn(
+        "[twitterapiio] Failed to save tweets to database:",
+        error
+      );
+    }
+  }
+  await logEventFromContext(
+    ctx,
+    "twitterapiio.tweets.getUserLastTweets",
+    { ...input },
+    "completed"
+  );
+  return response;
+};
+var getUserMentions = async (ctx, input) => {
+  const response = await makeTwitterApiIORequest("/twitter/user/mentions", ctx.key, {
+    method: "GET",
+    query: { userName: input.userName, cursor: input.cursor }
+  });
+  if (response.tweets) {
+    try {
+      for (const tweet of response.tweets) {
+        await persistTweetWithAuthor(tweet, ctx.db);
+      }
+    } catch (error) {
+      console.warn(
+        "[twitterapiio] Failed to save tweets to database:",
+        error
+      );
+    }
+  }
+  await logEventFromContext(
+    ctx,
+    "twitterapiio.tweets.getUserMentions",
+    { ...input },
+    "completed"
+  );
+  return response;
+};
+var getReplies2 = async (ctx, input) => {
+  const { tweetId, sinceTime, untilTime, cursor } = input;
+  const response = await makeTwitterApiIORequest("/twitter/tweet/replies", ctx.key, {
+    method: "GET",
+    query: { tweetId, sinceTime, untilTime, cursor }
+  });
+  if (response.tweets) {
+    try {
+      for (const tweet of response.tweets) {
+        await persistTweetWithAuthor(tweet, ctx.db);
+      }
+    } catch (error) {
+      console.warn("[twitterapiio] Failed to save tweets to database:", error);
+    }
+  }
+  await logEventFromContext(
+    ctx,
+    "twitterapiio.tweets.getReplies",
+    { ...input },
+    "completed"
+  );
+  return response;
+};
+var getQuotations = async (ctx, input) => {
+  const response = await makeTwitterApiIORequest("/twitter/tweet/quotes", ctx.key, {
+    method: "GET",
+    query: { tweetId: input.tweetId, cursor: input.cursor }
+  });
+  if (response.tweets) {
+    try {
+      for (const tweet of response.tweets) {
+        await persistTweetWithAuthor(tweet, ctx.db);
+      }
+    } catch (error) {
+      console.warn(
+        "[twitterapiio] Failed to save tweets to database:",
+        error
+      );
+    }
+  }
+  await logEventFromContext(
+    ctx,
+    "twitterapiio.tweets.getQuotations",
+    { ...input },
+    "completed"
+  );
+  return response;
+};
+var getRetweeters = async (ctx, input) => {
+  const response = await makeTwitterApiIORequest("/twitter/tweet/retweeters", ctx.key, {
+    method: "GET",
+    query: { tweetId: input.tweetId, cursor: input.cursor }
+  });
+  if (response.users && ctx.db.users) {
+    try {
+      for (const user of response.users) {
+        await ctx.db.users.upsertByEntityId(user.id, user);
+      }
+    } catch (error) {
+      console.warn("[twitterapiio] Failed to save users to database:", error);
+    }
+  }
+  await logEventFromContext(
+    ctx,
+    "twitterapiio.tweets.getRetweeters",
+    { ...input },
+    "completed"
+  );
+  return response;
+};
+var getThreadContext = async (ctx, input) => {
+  const response = await makeTwitterApiIORequest("/twitter/tweet/thread_context", ctx.key, {
+    method: "GET",
+    query: { tweetId: input.tweetId, cursor: input.cursor }
+  });
+  if (response.tweets) {
+    try {
+      for (const tweet of response.tweets) {
+        await persistTweetWithAuthor(tweet, ctx.db);
+      }
+    } catch (error) {
+      console.warn(
+        "[twitterapiio] Failed to save tweets to database:",
+        error
+      );
+    }
+  }
+  await logEventFromContext(
+    ctx,
+    "twitterapiio.tweets.getThreadContext",
+    { ...input },
+    "completed"
+  );
+  return response;
+};
+var create44 = async (ctx, input) => {
+  const { tweet, loginCookie, replyToTweetId, mediaIds } = input;
+  const response = await makeTwitterApiIORequest("/twitter/create_tweet", ctx.key, {
+    method: "POST",
+    body: {
+      tweet,
+      login_cookie: loginCookie,
+      ...replyToTweetId ? { reply_to_tweet_id: replyToTweetId } : {},
+      ...mediaIds ? { media_ids: mediaIds } : {}
+    }
+  });
+  await logEventFromContext(
+    ctx,
+    "twitterapiio.tweets.create",
+    { tweet, replyToTweetId },
+    "completed"
+  );
+  return response;
+};
+var deleteTweet = async (ctx, input) => {
+  const response = await makeTwitterApiIORequest("/twitter/tweet/delete", ctx.key, {
+    method: "POST",
+    body: { tweetId: input.tweetId, login_cookie: input.loginCookie }
+  });
+  await logEventFromContext(
+    ctx,
+    "twitterapiio.tweets.delete",
+    { tweetId: input.tweetId },
+    "completed"
+  );
+  return response;
+};
+var like = async (ctx, input) => {
+  const response = await makeTwitterApiIORequest("/twitter/tweet/like", ctx.key, {
+    method: "POST",
+    body: { tweetId: input.tweetId, login_cookie: input.loginCookie }
+  });
+  await logEventFromContext(
+    ctx,
+    "twitterapiio.tweets.like",
+    { tweetId: input.tweetId },
+    "completed"
+  );
+  return response;
+};
+var unlike = async (ctx, input) => {
+  const response = await makeTwitterApiIORequest("/twitter/tweet/unlike", ctx.key, {
+    method: "POST",
+    body: { tweetId: input.tweetId, login_cookie: input.loginCookie }
+  });
+  await logEventFromContext(
+    ctx,
+    "twitterapiio.tweets.unlike",
+    { tweetId: input.tweetId },
+    "completed"
+  );
+  return response;
+};
+var retweet = async (ctx, input) => {
+  const response = await makeTwitterApiIORequest("/twitter/tweet/retweet", ctx.key, {
+    method: "POST",
+    body: { tweetId: input.tweetId, login_cookie: input.loginCookie }
+  });
+  await logEventFromContext(
+    ctx,
+    "twitterapiio.tweets.retweet",
+    { tweetId: input.tweetId },
+    "completed"
+  );
+  return response;
+};
+
+// plugins/twitterapiio/endpoints/users.ts
+var getByUsername = async (ctx, input) => {
+  const response = await makeTwitterApiIORequest("/twitter/user/info", ctx.key, {
+    method: "GET",
+    query: { userName: input.userName }
+  });
+  if (response.data && ctx.db.users) {
+    try {
+      await ctx.db.users.upsertByEntityId(response.data.id, response.data);
+    } catch (error) {
+      console.warn("[twitterapiio] Failed to save user to database:", error);
+    }
+  }
+  await logEventFromContext(
+    ctx,
+    "twitterapiio.users.getByUsername",
+    { ...input },
+    "completed"
+  );
+  return response;
+};
+var batchGetByIds = async (ctx, input) => {
+  const response = await makeTwitterApiIORequest("/twitter/user/batch_info_by_ids", ctx.key, {
+    method: "GET",
+    query: { userIds: input.userIds }
+  });
+  if (response.data && ctx.db.users) {
+    try {
+      for (const user of response.data) {
+        await ctx.db.users.upsertByEntityId(user.id, user);
+      }
+    } catch (error) {
+      console.warn("[twitterapiio] Failed to save users to database:", error);
+    }
+  }
+  await logEventFromContext(
+    ctx,
+    "twitterapiio.users.batchGetByIds",
+    { ...input },
+    "completed"
+  );
+  return response;
+};
+var search12 = async (ctx, input) => {
+  const response = await makeTwitterApiIORequest("/twitter/user/search", ctx.key, {
+    method: "GET",
+    query: { keyword: input.keyword, cursor: input.cursor }
+  });
+  if (response.users && ctx.db.users) {
+    try {
+      for (const user of response.users) {
+        await ctx.db.users.upsertByEntityId(user.id, user);
+      }
+    } catch (error) {
+      console.warn("[twitterapiio] Failed to save users to database:", error);
+    }
+  }
+  await logEventFromContext(
+    ctx,
+    "twitterapiio.users.search",
+    { ...input },
+    "completed"
+  );
+  return response;
+};
+var getFollowers2 = async (ctx, input) => {
+  const response = await makeTwitterApiIORequest("/twitter/user/followers", ctx.key, {
+    method: "GET",
+    query: { userName: input.userName, cursor: input.cursor }
+  });
+  if (response.users && ctx.db.users) {
+    try {
+      for (const user of response.users) {
+        await ctx.db.users.upsertByEntityId(user.id, user);
+      }
+    } catch (error) {
+      console.warn("[twitterapiio] Failed to save users to database:", error);
+    }
+  }
+  await logEventFromContext(
+    ctx,
+    "twitterapiio.users.getFollowers",
+    { ...input },
+    "completed"
+  );
+  return response;
+};
+var getVerifiedFollowers = async (ctx, input) => {
+  const response = await makeTwitterApiIORequest("/twitter/user/verified_followers", ctx.key, {
+    method: "GET",
+    query: { userName: input.userName, cursor: input.cursor }
+  });
+  if (response.users && ctx.db.users) {
+    try {
+      for (const user of response.users) {
+        await ctx.db.users.upsertByEntityId(user.id, user);
+      }
+    } catch (error) {
+      console.warn("[twitterapiio] Failed to save users to database:", error);
+    }
+  }
+  await logEventFromContext(
+    ctx,
+    "twitterapiio.users.getVerifiedFollowers",
+    { ...input },
+    "completed"
+  );
+  return response;
+};
+var getFollowings = async (ctx, input) => {
+  const response = await makeTwitterApiIORequest("/twitter/user/followings", ctx.key, {
+    method: "GET",
+    query: { userName: input.userName, cursor: input.cursor }
+  });
+  if (response.users && ctx.db.users) {
+    try {
+      for (const user of response.users) {
+        await ctx.db.users.upsertByEntityId(user.id, user);
+      }
+    } catch (error) {
+      console.warn("[twitterapiio] Failed to save users to database:", error);
+    }
+  }
+  await logEventFromContext(
+    ctx,
+    "twitterapiio.users.getFollowings",
+    { ...input },
+    "completed"
+  );
+  return response;
+};
+var checkFollowRelationship = async (ctx, input) => {
+  const response = await makeTwitterApiIORequest("/twitter/user/follow_relation", ctx.key, {
+    method: "GET",
+    query: {
+      sourceUserName: input.sourceUserName,
+      targetUserName: input.targetUserName
+    }
+  });
+  await logEventFromContext(
+    ctx,
+    "twitterapiio.users.checkFollowRelationship",
+    { ...input },
+    "completed"
+  );
+  return response;
+};
+var follow = async (ctx, input) => {
+  const response = await makeTwitterApiIORequest("/twitter/user/follow", ctx.key, {
+    method: "POST",
+    body: { followId: input.followId, login_cookie: input.loginCookie }
+  });
+  await logEventFromContext(
+    ctx,
+    "twitterapiio.users.follow",
+    { followId: input.followId },
+    "completed"
+  );
+  return response;
+};
+var unfollow = async (ctx, input) => {
+  const response = await makeTwitterApiIORequest("/twitter/user/unfollow", ctx.key, {
+    method: "POST",
+    body: { followId: input.followId, login_cookie: input.loginCookie }
+  });
+  await logEventFromContext(
+    ctx,
+    "twitterapiio.users.unfollow",
+    { followId: input.followId },
+    "completed"
+  );
+  return response;
+};
+var getMe = async (ctx, input) => {
+  const response = await makeTwitterApiIORequest("/twitter/user/me", ctx.key, {
+    method: "GET",
+    query: { login_cookie: input.loginCookie }
+  });
+  if (response.data && ctx.db.users) {
+    try {
+      await ctx.db.users.upsertByEntityId(response.data.id, response.data);
+    } catch (error) {
+      console.warn("[twitterapiio] Failed to save user to database:", error);
+    }
+  }
+  await logEventFromContext(ctx, "twitterapiio.users.getMe", {}, "completed");
+  return response;
 };
 
 // plugins/twitterapiio/endpoints/index.ts
 var TweetsEndpoints = {
   getByIds,
   search: search11,
+  advancedSearch,
   getUserTimeline,
   getUserLastTweets,
   getUserMentions,
@@ -41012,6 +41234,7 @@ var twitterApiIOEndpointsNested = {
   tweets: {
     getByIds: TweetsEndpoints.getByIds,
     search: TweetsEndpoints.search,
+    advancedSearch: TweetsEndpoints.advancedSearch,
     getUserTimeline: TweetsEndpoints.getUserTimeline,
     getUserLastTweets: TweetsEndpoints.getUserLastTweets,
     getUserMentions: TweetsEndpoints.getUserMentions,
@@ -41072,6 +41295,10 @@ var twitterApiIOEndpointSchemas = {
     input: TwitterApiIOEndpointInputSchemas.tweetsSearch,
     output: TwitterApiIOEndpointOutputSchemas.tweetsSearch
   },
+  "tweets.advancedSearch": {
+    input: TwitterApiIOEndpointInputSchemas.tweetsAdvancedSearch,
+    output: TwitterApiIOEndpointOutputSchemas.tweetsAdvancedSearch
+  },
   "tweets.getUserTimeline": {
     input: TwitterApiIOEndpointInputSchemas.tweetsGetUserTimeline,
     output: TwitterApiIOEndpointOutputSchemas.tweetsGetUserTimeline
@@ -41232,7 +41459,11 @@ var twitterApiIOEndpointMeta = {
   },
   "tweets.search": {
     riskLevel: "read",
-    description: "Search tweets with a query"
+    description: "Search tweets with a raw query string"
+  },
+  "tweets.advancedSearch": {
+    riskLevel: "read",
+    description: "Search tweets using structured operators (keywords, users, dates, engagement thresholds, media filters, etc.)"
   },
   "tweets.getUserTimeline": {
     riskLevel: "read",
@@ -41590,7 +41821,7 @@ function describeZodSchema(schema) {
   if (schema instanceof ZodNumber) return "number";
   if (schema instanceof ZodBoolean) return "boolean";
   if (schema instanceof ZodDate) return "date";
-  if (schema instanceof ZodRecord) return "Record<string, unknown>";
+  if (schema instanceof ZodRecord) return "jsonb";
   return "unknown";
 }
 async function checkTables(db, warn) {