@crosspost/types 0.1.10 → 0.1.12

package/dist/index.cjs

@@ -216,198 +216,212 @@ var MultiStatusDataSchema = import_zod3.z.object({
 });
 
 // src/auth.ts
+var import_zod5 = require("zod");
+
+// src/user-profile.ts
 var import_zod4 = require("zod");
-var PlatformParamSchema = import_zod4.z.object({
-  platform: import_zod4.z.string().describe("Social media platform")
+var UserProfileSchema = import_zod4.z.object({
+  userId: import_zod4.z.string().describe("User ID on the platform"),
+  username: import_zod4.z.string().describe("Username on the platform"),
+  url: import_zod4.z.string().url().optional().describe("URL to the user profile"),
+  profileImageUrl: import_zod4.z.string().describe("URL to the user profile image"),
+  isPremium: import_zod4.z.boolean().optional().describe("Whether the user has a premium account"),
+  platform: PlatformSchema.describe("The platform the user profile is from"),
+  lastUpdated: import_zod4.z.number().describe("Timestamp when the profile was last updated")
+}).describe("User profile");
+var ProfileRefreshResponseSchema = import_zod4.z.object({
+  profile: UserProfileSchema.optional().describe("The refreshed user profile (if successful)")
+}).describe("Profile refresh response");
+
+// src/auth.ts
+var PlatformParamSchema = import_zod5.z.object({
+  platform: import_zod5.z.string().describe("Social media platform")
 }).describe("Platform parameter");
-var AuthInitRequestSchema = import_zod4.z.object({
-  successUrl: import_zod4.z.string().url().optional().describe(
+var AuthInitRequestSchema = import_zod5.z.object({
+  successUrl: import_zod5.z.string().url().optional().describe(
     "URL to redirect to on successful authentication"
   ),
-  errorUrl: import_zod4.z.string().url().optional().describe("URL to redirect to on authentication error"),
-  redirect: import_zod4.z.boolean().optional().default(false).describe(
+  errorUrl: import_zod5.z.string().url().optional().describe("URL to redirect to on authentication error"),
+  redirect: import_zod5.z.boolean().optional().default(false).describe(
     "Whether to redirect to successUrl/errorUrl (true) or return data directly (false)"
   )
 }).describe("Auth initialization request");
-var AuthUrlResponseSchema = import_zod4.z.object({
-  url: import_zod4.z.string().describe("Authentication URL to redirect the user to"),
-  state: import_zod4.z.string().describe("State parameter for CSRF protection"),
-  platform: PlatformSchema
+var AuthUrlResponseSchema = import_zod5.z.object({
+  url: import_zod5.z.string().describe("Authentication URL to redirect the user to")
 }).describe("Auth URL response");
-var AuthCallbackQuerySchema = import_zod4.z.object({
-  code: import_zod4.z.string().describe("Authorization code from OAuth provider"),
-  state: import_zod4.z.string().describe("State parameter for CSRF protection")
+var AuthCallbackQuerySchema = import_zod5.z.object({
+  code: import_zod5.z.string().describe("Authorization code from OAuth provider"),
+  state: import_zod5.z.string().describe("State parameter for CSRF protection")
 }).describe("Auth callback query");
-var AuthCallbackResponseSchema = import_zod4.z.object({
+var AuthCallbackResponseSchema = import_zod5.z.object({
   platform: PlatformSchema,
-  userId: import_zod4.z.string().describe("User ID"),
-  redirectUrl: import_zod4.z.string().optional().describe("URL to redirect the user to after authentication")
+  userId: import_zod5.z.string().describe("User ID"),
+  redirectUrl: import_zod5.z.string().optional().describe("URL to redirect the user to after authentication")
 }).describe("Auth callback response");
-var AuthStatusParamsSchema = import_zod4.z.object({
-  platform: import_zod4.z.string().describe("Social media platform"),
-  userId: import_zod4.z.string().describe("User ID on the platform")
+var AuthStatusParamsSchema = import_zod5.z.object({
+  platform: import_zod5.z.string().describe("Social media platform"),
+  userId: import_zod5.z.string().describe("User ID on the platform")
 }).describe("Token status parameters");
-var NearUnauthorizationResponseSchema = import_zod4.z.object({
-  success: import_zod4.z.boolean().describe("Whether the unauthorized operation was successful"),
-  nearAccount: import_zod4.z.string().describe("NEAR account ID that was unauthorized")
+var NearUnauthorizationResponseSchema = import_zod5.z.object({
+  success: import_zod5.z.boolean().describe("Whether the unauthorized operation was successful"),
+  nearAccount: import_zod5.z.string().describe("NEAR account ID that was unauthorized")
 }).describe("NEAR unauthorized response");
-var AuthStatusResponseSchema = import_zod4.z.object({
+var AuthStatusResponseSchema = import_zod5.z.object({
   platform: PlatformSchema,
-  userId: import_zod4.z.string().describe("User ID"),
-  authenticated: import_zod4.z.boolean().describe("Whether the user is authenticated"),
-  tokenStatus: import_zod4.z.object({
-    valid: import_zod4.z.boolean().describe("Whether the token is valid"),
-    expired: import_zod4.z.boolean().describe("Whether the token is expired"),
-    expiresAt: import_zod4.z.string().optional().describe("When the token expires")
+  userId: import_zod5.z.string().describe("User ID"),
+  authenticated: import_zod5.z.boolean().describe("Whether the user is authenticated"),
+  tokenStatus: import_zod5.z.object({
+    valid: import_zod5.z.boolean().describe("Whether the token is valid"),
+    expired: import_zod5.z.boolean().describe("Whether the token is expired"),
+    expiresAt: import_zod5.z.string().optional().describe("When the token expires")
   })
 }).describe("Auth status response");
-var AuthTokenRequestSchema = import_zod4.z.object({
-  userId: import_zod4.z.string().describe("User ID on the platform")
+var AuthTokenRequestSchema = import_zod5.z.object({
+  userId: import_zod5.z.string().describe("User ID on the platform")
 }).describe("Auth token request");
-var AuthRevokeResponseSchema = import_zod4.z.object({
+var AuthRevokeResponseSchema = import_zod5.z.object({
   platform: PlatformSchema,
-  userId: import_zod4.z.string().describe("User ID")
+  userId: import_zod5.z.string().describe("User ID")
 }).describe("Auth revoke response");
-var ConnectedAccountSchema = import_zod4.z.object({
+var ConnectedAccountSchema = import_zod5.z.object({
   platform: PlatformSchema,
-  userId: import_zod4.z.string().describe("User ID on the platform"),
-  username: import_zod4.z.string().optional().describe("Username on the platform (if available)"),
-  profileUrl: import_zod4.z.string().optional().describe("URL to the user profile"),
-  connectedAt: import_zod4.z.string().optional().describe("When the account was connected")
+  userId: import_zod5.z.string().describe("User ID on the platform"),
+  connectedAt: import_zod5.z.string().describe("When the account was connected"),
+  profile: UserProfileSchema.nullable().describe("Full user profile data")
 }).describe("Connected account");
-var ConnectedAccountsResponseSchema = import_zod4.z.object({
-  accounts: import_zod4.z.array(ConnectedAccountSchema)
+var ConnectedAccountsResponseSchema = import_zod5.z.object({
+  accounts: import_zod5.z.array(ConnectedAccountSchema)
 }).describe("Response containing an array of connected accounts");
-var NearAuthorizationRequestSchema = import_zod4.z.object({
+var NearAuthorizationRequestSchema = import_zod5.z.object({
   // No additional parameters needed, as the NEAR account ID is extracted from the signature
 }).describe("NEAR authorization request");
-var NearAuthorizationResponseSchema = import_zod4.z.object({
-  nearAccount: import_zod4.z.string().describe("NEAR account ID"),
-  authorized: import_zod4.z.boolean().describe("Whether the account is authorized")
+var NearAuthorizationResponseSchema = import_zod5.z.object({
+  nearAccount: import_zod5.z.string().describe("NEAR account ID"),
+  authorized: import_zod5.z.boolean().describe("Whether the account is authorized")
 }).describe("NEAR authorization response");
-var NearAuthorizationStatusResponseSchema = import_zod4.z.object({
-  nearAccount: import_zod4.z.string().describe("NEAR account ID"),
-  authorized: import_zod4.z.boolean().describe("Whether the account is authorized"),
-  authorizedAt: import_zod4.z.string().optional().describe("When the account was authorized")
+var NearAuthorizationStatusResponseSchema = import_zod5.z.object({
+  nearAccount: import_zod5.z.string().describe("NEAR account ID"),
+  authorized: import_zod5.z.boolean().describe("Whether the account is authorized"),
+  authorizedAt: import_zod5.z.string().optional().describe("When the account was authorized")
 }).describe("NEAR authorization status response");
 
 // src/post.ts
-var import_zod5 = require("zod");
-var MediaContentSchema = import_zod5.z.object({
-  data: import_zod5.z.union([import_zod5.z.string(), import_zod5.z.instanceof(Blob)]).describe("Media data as string or Blob"),
-  mimeType: import_zod5.z.string().optional().describe("Media MIME type"),
-  altText: import_zod5.z.string().optional().describe("Alt text for the media")
+var import_zod6 = require("zod");
+var MediaContentSchema = import_zod6.z.object({
+  data: import_zod6.z.union([import_zod6.z.string(), import_zod6.z.instanceof(Blob)]).describe("Media data as string or Blob"),
+  mimeType: import_zod6.z.string().optional().describe("Media MIME type"),
+  altText: import_zod6.z.string().optional().describe("Alt text for the media")
 }).describe("Media content object");
-var MediaSchema = import_zod5.z.object({
-  id: import_zod5.z.string().describe("Media ID"),
-  type: import_zod5.z.enum(["image", "video", "gif"]).describe("Media type"),
-  url: import_zod5.z.string().optional().describe("Media URL"),
-  altText: import_zod5.z.string().optional().describe("Alt text for the media")
+var MediaSchema = import_zod6.z.object({
+  id: import_zod6.z.string().describe("Media ID"),
+  type: import_zod6.z.enum(["image", "video", "gif"]).describe("Media type"),
+  url: import_zod6.z.string().optional().describe("Media URL"),
+  altText: import_zod6.z.string().optional().describe("Alt text for the media")
 }).describe("Media object");
-var PostMetricsSchema = import_zod5.z.object({
-  retweets: import_zod5.z.number().describe("Number of retweets"),
-  quotes: import_zod5.z.number().describe("Number of quotes"),
-  likes: import_zod5.z.number().describe("Number of likes"),
-  replies: import_zod5.z.number().describe("Number of replies")
+var PostMetricsSchema = import_zod6.z.object({
+  retweets: import_zod6.z.number().describe("Number of retweets"),
+  quotes: import_zod6.z.number().describe("Number of quotes"),
+  likes: import_zod6.z.number().describe("Number of likes"),
+  replies: import_zod6.z.number().describe("Number of replies")
 }).describe("Post metrics");
-var PostSchema = import_zod5.z.object({
-  id: import_zod5.z.string().describe("Post ID"),
-  text: import_zod5.z.string().describe("Post text content"),
-  createdAt: import_zod5.z.string().describe("Post creation date"),
-  authorId: import_zod5.z.string().describe("Author ID"),
-  media: import_zod5.z.array(MediaSchema).optional().describe("Media attached to the post"),
+var PostSchema = import_zod6.z.object({
+  id: import_zod6.z.string().describe("Post ID"),
+  text: import_zod6.z.string().describe("Post text content"),
+  createdAt: import_zod6.z.string().describe("Post creation date"),
+  authorId: import_zod6.z.string().describe("Author ID"),
+  media: import_zod6.z.array(MediaSchema).optional().describe("Media attached to the post"),
   metrics: PostMetricsSchema.optional().describe("Post metrics"),
-  inReplyToId: import_zod5.z.string().optional().describe("ID of the post this is a reply to"),
-  quotedPostId: import_zod5.z.string().optional().describe("ID of the post this is quoting")
+  inReplyToId: import_zod6.z.string().optional().describe("ID of the post this is a reply to"),
+  quotedPostId: import_zod6.z.string().optional().describe("ID of the post this is quoting")
 }).describe("Post object");
-var PostContentSchema = import_zod5.z.object({
-  text: import_zod5.z.string().optional().describe("Text content for the post"),
-  media: import_zod5.z.array(MediaContentSchema).optional().describe("Media attachments for the post")
+var PostContentSchema = import_zod6.z.object({
+  text: import_zod6.z.string().optional().describe("Text content for the post"),
+  media: import_zod6.z.array(MediaContentSchema).optional().describe("Media attachments for the post")
 }).describe("Post content");
-var PostResultSchema = import_zod5.z.object({
-  id: import_zod5.z.string().describe("Post ID"),
-  text: import_zod5.z.string().optional().describe("Post text content"),
-  createdAt: import_zod5.z.string().describe("Post creation date"),
-  mediaIds: import_zod5.z.array(import_zod5.z.string()).optional().describe("Media IDs attached to the post"),
-  threadIds: import_zod5.z.array(import_zod5.z.string()).optional().describe("Thread IDs for threaded posts"),
-  quotedPostId: import_zod5.z.string().optional().describe("ID of the post this is quoting"),
-  inReplyToId: import_zod5.z.string().optional().describe("ID of the post this is a reply to"),
-  success: import_zod5.z.boolean().optional().describe("Whether the operation was successful")
-}).catchall(import_zod5.z.any()).describe("Post result");
-var DeleteResultSchema = import_zod5.z.object({
-  success: import_zod5.z.boolean().describe("Whether the deletion was successful"),
-  id: import_zod5.z.string().describe("ID of the deleted post")
+var PostResultSchema = import_zod6.z.object({
+  id: import_zod6.z.string().describe("Post ID"),
+  text: import_zod6.z.string().optional().describe("Post text content"),
+  createdAt: import_zod6.z.string().describe("Post creation date"),
+  mediaIds: import_zod6.z.array(import_zod6.z.string()).optional().describe("Media IDs attached to the post"),
+  threadIds: import_zod6.z.array(import_zod6.z.string()).optional().describe("Thread IDs for threaded posts"),
+  quotedPostId: import_zod6.z.string().optional().describe("ID of the post this is quoting"),
+  inReplyToId: import_zod6.z.string().optional().describe("ID of the post this is a reply to"),
+  success: import_zod6.z.boolean().optional().describe("Whether the operation was successful")
+}).catchall(import_zod6.z.any()).describe("Post result");
+var DeleteResultSchema = import_zod6.z.object({
+  success: import_zod6.z.boolean().describe("Whether the deletion was successful"),
+  id: import_zod6.z.string().describe("ID of the deleted post")
 }).describe("Delete result");
-var LikeResultSchema = import_zod5.z.object({
-  success: import_zod5.z.boolean().describe("Whether the like was successful"),
-  id: import_zod5.z.string().describe("ID of the liked post")
+var LikeResultSchema = import_zod6.z.object({
+  success: import_zod6.z.boolean().describe("Whether the like was successful"),
+  id: import_zod6.z.string().describe("ID of the liked post")
 }).describe("Like result");
-var PostSuccessDetailSchema = import_zod5.z.object({
+var PostSuccessDetailSchema = import_zod6.z.object({
   platform: PlatformSchema,
-  userId: import_zod5.z.string().describe("User ID"),
-  status: import_zod5.z.literal("success"),
-  postId: import_zod5.z.string().optional().describe("Post ID"),
-  postUrl: import_zod5.z.string().optional().describe("URL to the post")
-}).catchall(import_zod5.z.any()).describe("Post success detail");
-var TargetSchema = import_zod5.z.object({
+  userId: import_zod6.z.string().describe("User ID"),
+  status: import_zod6.z.literal("success"),
+  postId: import_zod6.z.string().optional().describe("Post ID"),
+  postUrl: import_zod6.z.string().optional().describe("URL to the post")
+}).catchall(import_zod6.z.any()).describe("Post success detail");
+var TargetSchema = import_zod6.z.object({
   platform: PlatformSchema.describe('The platform to post to (e.g., "twitter")'),
-  userId: import_zod5.z.string().describe("User ID on the platform")
+  userId: import_zod6.z.string().describe("User ID on the platform")
 }).describe("Target for posting operations");
-var CreatePostRequestSchema = import_zod5.z.object({
-  targets: import_zod5.z.array(TargetSchema).describe("Array of targets to post to (can be a single target)"),
-  content: import_zod5.z.array(PostContentSchema).describe(
+var CreatePostRequestSchema = import_zod6.z.object({
+  targets: import_zod6.z.array(TargetSchema).describe("Array of targets to post to (can be a single target)"),
+  content: import_zod6.z.array(PostContentSchema).describe(
     "The content of the post, always an array of PostContent objects, even for a single post"
   )
 }).describe("Create post request");
-var RepostRequestSchema = import_zod5.z.object({
-  targets: import_zod5.z.array(TargetSchema).describe("Array of targets to post to"),
+var RepostRequestSchema = import_zod6.z.object({
+  targets: import_zod6.z.array(TargetSchema).describe("Array of targets to post to"),
   platform: PlatformSchema.describe("Platform of the post being reposted"),
-  postId: import_zod5.z.string().describe("ID of the post to repost")
+  postId: import_zod6.z.string().describe("ID of the post to repost")
 }).describe("Repost request");
-var QuotePostRequestSchema = import_zod5.z.object({
-  targets: import_zod5.z.array(TargetSchema).describe(
+var QuotePostRequestSchema = import_zod6.z.object({
+  targets: import_zod6.z.array(TargetSchema).describe(
     "Array of targets to post to (must be on the same platform as the post being quoted)"
   ),
   platform: PlatformSchema.describe("Platform of the post being quoted"),
-  postId: import_zod5.z.string().describe("ID of the post to quote"),
-  content: import_zod5.z.array(PostContentSchema).describe(
+  postId: import_zod6.z.string().describe("ID of the post to quote"),
+  content: import_zod6.z.array(PostContentSchema).describe(
     "Content for the quote post(s), always an array, even for a single post"
   )
 }).describe("Quote post request");
-var ReplyToPostRequestSchema = import_zod5.z.object({
-  targets: import_zod5.z.array(TargetSchema).describe(
+var ReplyToPostRequestSchema = import_zod6.z.object({
+  targets: import_zod6.z.array(TargetSchema).describe(
     "Array of targets to post to (must be on the same platform as the post being replied to)"
   ),
   platform: PlatformSchema.describe("Platform of the post being replied to"),
-  postId: import_zod5.z.string().describe("ID of the post to reply to"),
-  content: import_zod5.z.array(PostContentSchema).describe(
+  postId: import_zod6.z.string().describe("ID of the post to reply to"),
+  content: import_zod6.z.array(PostContentSchema).describe(
     "Content for the reply post(s), always an array, even for a single post"
   )
 }).describe("Reply to post request");
-var PostToDeleteSchema = import_zod5.z.object({
+var PostToDeleteSchema = import_zod6.z.object({
   platform: PlatformSchema.describe("Platform of the post to delete"),
-  userId: import_zod5.z.string().describe("User ID on the platform"),
-  postId: import_zod5.z.string().describe("ID of the post to delete")
+  userId: import_zod6.z.string().describe("User ID on the platform"),
+  postId: import_zod6.z.string().describe("ID of the post to delete")
 }).describe("Post to delete");
-var DeletePostRequestSchema = import_zod5.z.object({
-  targets: import_zod5.z.array(TargetSchema).describe("Array of targets to delete posts"),
-  posts: import_zod5.z.array(PostToDeleteSchema).describe("Array of posts to delete")
+var DeletePostRequestSchema = import_zod6.z.object({
+  targets: import_zod6.z.array(TargetSchema).describe("Array of targets to delete posts"),
+  posts: import_zod6.z.array(PostToDeleteSchema).describe("Array of posts to delete")
 }).describe("Delete post request");
-var LikePostRequestSchema = import_zod5.z.object({
-  targets: import_zod5.z.array(TargetSchema).describe(
+var LikePostRequestSchema = import_zod6.z.object({
+  targets: import_zod6.z.array(TargetSchema).describe(
     "Array of targets to like the post (must be on the same platform as the post being liked)"
   ),
   platform: PlatformSchema.describe("Platform of the post being liked"),
-  postId: import_zod5.z.string().describe("ID of the post to like")
+  postId: import_zod6.z.string().describe("ID of the post to like")
 }).describe("Like post request");
-var UnlikePostRequestSchema = import_zod5.z.object({
-  targets: import_zod5.z.array(TargetSchema).describe(
+var UnlikePostRequestSchema = import_zod6.z.object({
+  targets: import_zod6.z.array(TargetSchema).describe(
     "Array of targets to unlike the post (must be on the same platform as the post being unliked)"
   ),
   platform: PlatformSchema.describe("Platform of the post being unliked"),
-  postId: import_zod5.z.string().describe("ID of the post to unlike")
+  postId: import_zod6.z.string().describe("ID of the post to unlike")
 }).describe("Unlike post request");
-var PostResponseSchema = import_zod5.z.union([PostSchema, import_zod5.z.array(PostSchema)]).describe(
+var PostResponseSchema = import_zod6.z.union([PostSchema, import_zod6.z.array(PostSchema)]).describe(
   "Post response"
 );
 var CreatePostResponseSchema = PostResponseSchema.describe(
@@ -416,115 +430,115 @@ var CreatePostResponseSchema = PostResponseSchema.describe(
 var RepostResponseSchema = PostResponseSchema.describe("Repost response");
 var QuotePostResponseSchema = PostResponseSchema.describe("Quote post response");
 var ReplyToPostResponseSchema = PostResponseSchema.describe("Reply to post response");
-var DeletePostResponseSchema = import_zod5.z.object({
-  id: import_zod5.z.string().describe("ID of the deleted post")
+var DeletePostResponseSchema = import_zod6.z.object({
+  id: import_zod6.z.string().describe("ID of the deleted post")
 }).describe("Delete post response");
-var LikePostResponseSchema = import_zod5.z.object({
-  id: import_zod5.z.string().describe("ID of the liked post")
+var LikePostResponseSchema = import_zod6.z.object({
+  id: import_zod6.z.string().describe("ID of the liked post")
 }).describe("Like post response");
-var UnlikePostResponseSchema = import_zod5.z.object({
-  id: import_zod5.z.string().describe("ID of the unliked post")
+var UnlikePostResponseSchema = import_zod6.z.object({
+  id: import_zod6.z.string().describe("ID of the unliked post")
 }).describe("Unlike post response");
-var PostMultiStatusResponseSchema = import_zod5.z.object({
-  summary: import_zod5.z.object({
-    total: import_zod5.z.number().describe("Total number of operations"),
-    succeeded: import_zod5.z.number().describe("Number of successful operations"),
-    failed: import_zod5.z.number().describe("Number of failed operations")
+var PostMultiStatusResponseSchema = import_zod6.z.object({
+  summary: import_zod6.z.object({
+    total: import_zod6.z.number().describe("Total number of operations"),
+    succeeded: import_zod6.z.number().describe("Number of successful operations"),
+    failed: import_zod6.z.number().describe("Number of failed operations")
   }),
-  results: import_zod5.z.array(PostSuccessDetailSchema).describe("Successful operations"),
-  errors: import_zod5.z.array(ErrorDetailSchema).describe("Failed operations")
+  results: import_zod6.z.array(PostSuccessDetailSchema).describe("Successful operations"),
+  errors: import_zod6.z.array(ErrorDetailSchema).describe("Failed operations")
 }).describe("Multi-status response for post operations");
 
 // src/rate-limit.ts
-var import_zod6 = require("zod");
-var RateLimitEndpointParamSchema = import_zod6.z.object({
-  endpoint: import_zod6.z.string().optional().describe(
+var import_zod7 = require("zod");
+var RateLimitEndpointParamSchema = import_zod7.z.object({
+  endpoint: import_zod7.z.string().optional().describe(
     "Specific endpoint to get rate limit information for (optional)"
   )
 }).describe("Rate limit endpoint parameter");
-var RateLimitEndpointSchema = import_zod6.z.object({
-  endpoint: import_zod6.z.string().describe("API endpoint"),
-  method: import_zod6.z.enum(["GET", "POST", "PUT", "DELETE"]).describe("HTTP method"),
-  limit: import_zod6.z.number().describe("Rate limit"),
-  remaining: import_zod6.z.number().describe("Remaining requests"),
-  reset: import_zod6.z.number().describe("Reset timestamp (Unix timestamp in seconds)"),
-  resetDate: import_zod6.z.string().describe("Reset date (ISO string)")
+var RateLimitEndpointSchema = import_zod7.z.object({
+  endpoint: import_zod7.z.string().describe("API endpoint"),
+  method: import_zod7.z.enum(["GET", "POST", "PUT", "DELETE"]).describe("HTTP method"),
+  limit: import_zod7.z.number().describe("Rate limit"),
+  remaining: import_zod7.z.number().describe("Remaining requests"),
+  reset: import_zod7.z.number().describe("Reset timestamp (Unix timestamp in seconds)"),
+  resetDate: import_zod7.z.string().describe("Reset date (ISO string)")
 }).describe("Rate limit endpoint");
-var RateLimitStatusSchema = import_zod6.z.object({
-  endpoint: import_zod6.z.string().describe("API endpoint or action"),
-  limit: import_zod6.z.number().describe("Maximum number of requests allowed in the time window"),
-  remaining: import_zod6.z.number().describe("Number of requests remaining in the current time window"),
-  reset: import_zod6.z.string().datetime().describe("Timestamp when the rate limit will reset"),
-  resetSeconds: import_zod6.z.number().describe("Seconds until the rate limit will reset")
+var RateLimitStatusSchema = import_zod7.z.object({
+  endpoint: import_zod7.z.string().describe("API endpoint or action"),
+  limit: import_zod7.z.number().describe("Maximum number of requests allowed in the time window"),
+  remaining: import_zod7.z.number().describe("Number of requests remaining in the current time window"),
+  reset: import_zod7.z.string().datetime().describe("Timestamp when the rate limit will reset"),
+  resetSeconds: import_zod7.z.number().describe("Seconds until the rate limit will reset")
 }).describe("Rate limit status");
-var PlatformRateLimitSchema = import_zod6.z.object({
+var PlatformRateLimitSchema = import_zod7.z.object({
   platform: PlatformSchema,
-  endpoints: import_zod6.z.record(import_zod6.z.string(), RateLimitStatusSchema).describe(
+  endpoints: import_zod7.z.record(import_zod7.z.string(), RateLimitStatusSchema).describe(
     "Rate limit status for each endpoint"
   )
 }).describe("Platform-specific rate limit");
-var UsageRateLimitSchema = import_zod6.z.object({
-  endpoint: import_zod6.z.string().describe("API endpoint or action"),
-  limit: import_zod6.z.number().describe("Maximum number of requests allowed in the time window"),
-  remaining: import_zod6.z.number().describe("Number of requests remaining in the current time window"),
-  reset: import_zod6.z.string().datetime().describe("Timestamp when the rate limit will reset"),
-  resetSeconds: import_zod6.z.number().describe("Seconds until the rate limit will reset"),
-  timeWindow: import_zod6.z.string().describe("Time window for the rate limit")
+var UsageRateLimitSchema = import_zod7.z.object({
+  endpoint: import_zod7.z.string().describe("API endpoint or action"),
+  limit: import_zod7.z.number().describe("Maximum number of requests allowed in the time window"),
+  remaining: import_zod7.z.number().describe("Number of requests remaining in the current time window"),
+  reset: import_zod7.z.string().datetime().describe("Timestamp when the rate limit will reset"),
+  resetSeconds: import_zod7.z.number().describe("Seconds until the rate limit will reset"),
+  timeWindow: import_zod7.z.string().describe("Time window for the rate limit")
 }).describe("Usage rate limit");
-var RateLimitStatusResponseSchema = import_zod6.z.object({
+var RateLimitStatusResponseSchema = import_zod7.z.object({
   platform: PlatformSchema,
-  userId: import_zod6.z.string().optional().describe("User ID"),
-  endpoints: import_zod6.z.array(RateLimitEndpointSchema).describe("Rate limits for specific endpoints"),
-  app: import_zod6.z.object({
-    limit: import_zod6.z.number().describe("App-wide rate limit"),
-    remaining: import_zod6.z.number().describe("Remaining requests"),
-    reset: import_zod6.z.number().describe("Reset timestamp (Unix timestamp in seconds)"),
-    resetDate: import_zod6.z.string().describe("Reset date (ISO string)")
+  userId: import_zod7.z.string().optional().describe("User ID"),
+  endpoints: import_zod7.z.array(RateLimitEndpointSchema).describe("Rate limits for specific endpoints"),
+  app: import_zod7.z.object({
+    limit: import_zod7.z.number().describe("App-wide rate limit"),
+    remaining: import_zod7.z.number().describe("Remaining requests"),
+    reset: import_zod7.z.number().describe("Reset timestamp (Unix timestamp in seconds)"),
+    resetDate: import_zod7.z.string().describe("Reset date (ISO string)")
   }).optional().describe("App-wide rate limits")
 }).describe("Rate limit status response");
-var AllRateLimitsResponseSchema = import_zod6.z.object({
-  platforms: import_zod6.z.record(
+var AllRateLimitsResponseSchema = import_zod7.z.object({
+  platforms: import_zod7.z.record(
     PlatformSchema,
-    import_zod6.z.object({
-      users: import_zod6.z.record(
-        import_zod6.z.string(),
-        import_zod6.z.object({
-          endpoints: import_zod6.z.array(RateLimitEndpointSchema).describe(
+    import_zod7.z.object({
+      users: import_zod7.z.record(
+        import_zod7.z.string(),
+        import_zod7.z.object({
+          endpoints: import_zod7.z.array(RateLimitEndpointSchema).describe(
             "Rate limits for specific endpoints"
           ),
-          lastUpdated: import_zod6.z.string().describe("Last updated date (ISO string)")
+          lastUpdated: import_zod7.z.string().describe("Last updated date (ISO string)")
         })
       ).describe("User-specific rate limits"),
-      app: import_zod6.z.object({
-        limit: import_zod6.z.number().describe("App-wide rate limit"),
-        remaining: import_zod6.z.number().describe("Remaining requests"),
-        reset: import_zod6.z.number().describe("Reset timestamp (Unix timestamp in seconds)"),
-        resetDate: import_zod6.z.string().describe("Reset date (ISO string)")
+      app: import_zod7.z.object({
+        limit: import_zod7.z.number().describe("App-wide rate limit"),
+        remaining: import_zod7.z.number().describe("Remaining requests"),
+        reset: import_zod7.z.number().describe("Reset timestamp (Unix timestamp in seconds)"),
+        resetDate: import_zod7.z.string().describe("Reset date (ISO string)")
       }).optional().describe("App-wide rate limits")
     })
   ).describe("Rate limits by platform")
 }).describe("All rate limits response");
-var RateLimitResponseSchema = import_zod6.z.object({
-  platformLimits: import_zod6.z.array(PlatformRateLimitSchema).describe("Platform-specific rate limits"),
-  usageLimits: import_zod6.z.record(import_zod6.z.string(), UsageRateLimitSchema).describe(
+var RateLimitResponseSchema = import_zod7.z.object({
+  platformLimits: import_zod7.z.array(PlatformRateLimitSchema).describe("Platform-specific rate limits"),
+  usageLimits: import_zod7.z.record(import_zod7.z.string(), UsageRateLimitSchema).describe(
     "Usage-based rate limits for the NEAR account"
   ),
-  signerId: import_zod6.z.string().describe("NEAR account ID")
+  signerId: import_zod7.z.string().describe("NEAR account ID")
 }).describe("Rate limit response");
-var EndpointRateLimitResponseSchema = import_zod6.z.object({
-  platformLimits: import_zod6.z.array(
-    import_zod6.z.object({
+var EndpointRateLimitResponseSchema = import_zod7.z.object({
+  platformLimits: import_zod7.z.array(
+    import_zod7.z.object({
       platform: PlatformSchema,
       status: RateLimitStatusSchema.describe("Rate limit status for the endpoint")
     })
   ).describe("Platform-specific rate limits for the endpoint"),
   usageLimit: UsageRateLimitSchema.describe("Usage-based rate limit for the NEAR account"),
-  endpoint: import_zod6.z.string().describe("API endpoint or action"),
-  signerId: import_zod6.z.string().describe("NEAR account ID")
+  endpoint: import_zod7.z.string().describe("API endpoint or action"),
+  signerId: import_zod7.z.string().describe("NEAR account ID")
 }).describe("Endpoint rate limit response");
 
 // src/activity.ts
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
 var TimePeriod = /* @__PURE__ */ ((TimePeriod2) => {
   TimePeriod2["ALL"] = "all";
   TimePeriod2["YEARLY"] = "year";
@@ -533,111 +547,96 @@ var TimePeriod = /* @__PURE__ */ ((TimePeriod2) => {
   TimePeriod2["DAILY"] = "day";
   return TimePeriod2;
 })(TimePeriod || {});
-var ActivityLeaderboardQuerySchema = import_zod7.z.object({
-  timeframe: import_zod7.z.nativeEnum(TimePeriod).optional().describe(
+var ActivityLeaderboardQuerySchema = import_zod8.z.object({
+  timeframe: import_zod8.z.nativeEnum(TimePeriod).optional().describe(
     "Timeframe for the leaderboard"
   ),
-  limit: import_zod7.z.string().optional().transform((val) => val ? parseInt(val, 10) : void 0).pipe(import_zod7.z.number().min(1).max(100).optional()).describe("Maximum number of results to return (1-100)"),
-  offset: import_zod7.z.string().optional().transform((val) => val ? parseInt(val, 10) : void 0).pipe(import_zod7.z.number().min(0).optional()).describe("Offset for pagination")
+  limit: import_zod8.z.string().optional().transform((val) => val ? parseInt(val, 10) : void 0).pipe(import_zod8.z.number().min(1).max(100).optional()).describe("Maximum number of results to return (1-100)"),
+  offset: import_zod8.z.string().optional().transform((val) => val ? parseInt(val, 10) : void 0).pipe(import_zod8.z.number().min(0).optional()).describe("Offset for pagination")
 }).describe("Activity leaderboard query");
-var AccountActivityEntrySchema = import_zod7.z.object({
-  signerId: import_zod7.z.string().describe("NEAR account ID"),
-  totalPosts: import_zod7.z.number().describe("Total number of posts"),
-  totalLikes: import_zod7.z.number().describe("Total number of likes"),
-  totalReposts: import_zod7.z.number().describe("Total number of reposts"),
-  totalReplies: import_zod7.z.number().describe("Total number of replies"),
-  totalQuotes: import_zod7.z.number().describe("Total number of quote posts"),
-  totalScore: import_zod7.z.number().describe("Total activity score"),
-  rank: import_zod7.z.number().describe("Rank on the leaderboard"),
-  lastActive: import_zod7.z.string().datetime().describe("Timestamp of last activity")
+var AccountActivityEntrySchema = import_zod8.z.object({
+  signerId: import_zod8.z.string().describe("NEAR account ID"),
+  totalPosts: import_zod8.z.number().describe("Total number of posts"),
+  totalLikes: import_zod8.z.number().describe("Total number of likes"),
+  totalReposts: import_zod8.z.number().describe("Total number of reposts"),
+  totalReplies: import_zod8.z.number().describe("Total number of replies"),
+  totalQuotes: import_zod8.z.number().describe("Total number of quote posts"),
+  totalScore: import_zod8.z.number().describe("Total activity score"),
+  rank: import_zod8.z.number().describe("Rank on the leaderboard"),
+  lastActive: import_zod8.z.string().datetime().describe("Timestamp of last activity")
 }).describe("Account activity entry");
-var ActivityLeaderboardResponseSchema = import_zod7.z.object({
-  timeframe: import_zod7.z.nativeEnum(TimePeriod).describe("Timeframe for the leaderboard"),
-  entries: import_zod7.z.array(AccountActivityEntrySchema).describe("Leaderboard entries"),
-  generatedAt: import_zod7.z.string().datetime().describe("Timestamp when the leaderboard was generated"),
+var ActivityLeaderboardResponseSchema = import_zod8.z.object({
+  timeframe: import_zod8.z.nativeEnum(TimePeriod).describe("Timeframe for the leaderboard"),
+  entries: import_zod8.z.array(AccountActivityEntrySchema).describe("Leaderboard entries"),
+  generatedAt: import_zod8.z.string().datetime().describe("Timestamp when the leaderboard was generated"),
   platform: PlatformSchema.optional().describe("Platform filter (if applied)")
 });
-var AccountActivityParamsSchema = import_zod7.z.object({
-  signerId: import_zod7.z.string().describe("NEAR account ID")
+var AccountActivityParamsSchema = import_zod8.z.object({
+  signerId: import_zod8.z.string().describe("NEAR account ID")
 }).describe("Account activity params");
-var AccountActivityQuerySchema = import_zod7.z.object({
-  timeframe: import_zod7.z.nativeEnum(TimePeriod).optional().describe(
+var AccountActivityQuerySchema = import_zod8.z.object({
+  timeframe: import_zod8.z.nativeEnum(TimePeriod).optional().describe(
     "Timeframe for the activity"
   )
 }).describe("Account activity query");
-var PlatformActivitySchema = import_zod7.z.object({
+var PlatformActivitySchema = import_zod8.z.object({
   platform: PlatformSchema,
-  posts: import_zod7.z.number().describe("Number of posts on this platform"),
-  likes: import_zod7.z.number().describe("Number of likes on this platform"),
-  reposts: import_zod7.z.number().describe("Number of reposts on this platform"),
-  replies: import_zod7.z.number().describe("Number of replies on this platform"),
-  quotes: import_zod7.z.number().describe("Number of quote posts on this platform"),
-  score: import_zod7.z.number().describe("Activity score on this platform"),
-  lastActive: import_zod7.z.string().datetime().describe("Timestamp of last activity on this platform")
+  posts: import_zod8.z.number().describe("Number of posts on this platform"),
+  likes: import_zod8.z.number().describe("Number of likes on this platform"),
+  reposts: import_zod8.z.number().describe("Number of reposts on this platform"),
+  replies: import_zod8.z.number().describe("Number of replies on this platform"),
+  quotes: import_zod8.z.number().describe("Number of quote posts on this platform"),
+  score: import_zod8.z.number().describe("Activity score on this platform"),
+  lastActive: import_zod8.z.string().datetime().describe("Timestamp of last activity on this platform")
 }).describe("Platform activity");
-var AccountActivityResponseSchema = import_zod7.z.object({
-  signerId: import_zod7.z.string().describe("NEAR account ID"),
-  timeframe: import_zod7.z.nativeEnum(TimePeriod).describe("Timeframe for the activity"),
-  totalPosts: import_zod7.z.number().describe("Total number of posts across all platforms"),
-  totalLikes: import_zod7.z.number().describe("Total number of likes across all platforms"),
-  totalReposts: import_zod7.z.number().describe("Total number of reposts across all platforms"),
-  totalReplies: import_zod7.z.number().describe("Total number of replies across all platforms"),
-  totalQuotes: import_zod7.z.number().describe("Total number of quote posts across all platforms"),
-  totalScore: import_zod7.z.number().describe("Total activity score across all platforms"),
-  rank: import_zod7.z.number().describe("Rank on the leaderboard"),
-  lastActive: import_zod7.z.string().datetime().describe("Timestamp of last activity across all platforms"),
-  platforms: import_zod7.z.array(PlatformActivitySchema).describe("Activity breakdown by platform")
+var AccountActivityResponseSchema = import_zod8.z.object({
+  signerId: import_zod8.z.string().describe("NEAR account ID"),
+  timeframe: import_zod8.z.nativeEnum(TimePeriod).describe("Timeframe for the activity"),
+  totalPosts: import_zod8.z.number().describe("Total number of posts across all platforms"),
+  totalLikes: import_zod8.z.number().describe("Total number of likes across all platforms"),
+  totalReposts: import_zod8.z.number().describe("Total number of reposts across all platforms"),
+  totalReplies: import_zod8.z.number().describe("Total number of replies across all platforms"),
+  totalQuotes: import_zod8.z.number().describe("Total number of quote posts across all platforms"),
+  totalScore: import_zod8.z.number().describe("Total activity score across all platforms"),
+  rank: import_zod8.z.number().describe("Rank on the leaderboard"),
+  lastActive: import_zod8.z.string().datetime().describe("Timestamp of last activity across all platforms"),
+  platforms: import_zod8.z.array(PlatformActivitySchema).describe("Activity breakdown by platform")
 });
-var AccountPostsParamsSchema = import_zod7.z.object({
-  signerId: import_zod7.z.string().describe("NEAR account ID")
+var AccountPostsParamsSchema = import_zod8.z.object({
+  signerId: import_zod8.z.string().describe("NEAR account ID")
 }).describe("Account posts params");
-var AccountPostsQuerySchema = import_zod7.z.object({
-  platform: import_zod7.z.string().optional().describe("Filter by platform (optional)"),
-  limit: import_zod7.z.string().optional().transform((val) => val ? parseInt(val, 10) : void 0).pipe(import_zod7.z.number().min(1).max(100).optional()).describe("Maximum number of results to return (1-100)"),
-  offset: import_zod7.z.string().optional().transform((val) => val ? parseInt(val, 10) : void 0).pipe(import_zod7.z.number().min(0).optional()).describe("Offset for pagination"),
-  type: import_zod7.z.enum(["post", "repost", "reply", "quote", "like", "all"]).optional().describe(
+var AccountPostsQuerySchema = import_zod8.z.object({
+  platform: import_zod8.z.string().optional().describe("Filter by platform (optional)"),
+  limit: import_zod8.z.string().optional().transform((val) => val ? parseInt(val, 10) : void 0).pipe(import_zod8.z.number().min(1).max(100).optional()).describe("Maximum number of results to return (1-100)"),
+  offset: import_zod8.z.string().optional().transform((val) => val ? parseInt(val, 10) : void 0).pipe(import_zod8.z.number().min(0).optional()).describe("Offset for pagination"),
+  type: import_zod8.z.enum(["post", "repost", "reply", "quote", "like", "all"]).optional().describe(
     "Filter by post type (optional)"
   )
 }).describe("Account posts query");
-var AccountPostSchema = import_zod7.z.object({
-  id: import_zod7.z.string().describe("Post ID"),
+var AccountPostSchema = import_zod8.z.object({
+  id: import_zod8.z.string().describe("Post ID"),
   platform: PlatformSchema,
-  type: import_zod7.z.enum(["post", "repost", "reply", "quote", "like"]).describe("Type of post"),
-  content: import_zod7.z.string().optional().describe("Post content (if available)"),
-  url: import_zod7.z.string().url().optional().describe("URL to the post on the platform (if available)"),
-  createdAt: import_zod7.z.string().datetime().describe("Timestamp when the post was created"),
-  metrics: import_zod7.z.object({
-    likes: import_zod7.z.number().optional().describe("Number of likes (if available)"),
-    reposts: import_zod7.z.number().optional().describe("Number of reposts (if available)"),
-    replies: import_zod7.z.number().optional().describe("Number of replies (if available)"),
-    quotes: import_zod7.z.number().optional().describe("Number of quotes (if available)")
+  type: import_zod8.z.enum(["post", "repost", "reply", "quote", "like"]).describe("Type of post"),
+  content: import_zod8.z.string().optional().describe("Post content (if available)"),
+  url: import_zod8.z.string().url().optional().describe("URL to the post on the platform (if available)"),
+  createdAt: import_zod8.z.string().datetime().describe("Timestamp when the post was created"),
+  metrics: import_zod8.z.object({
+    likes: import_zod8.z.number().optional().describe("Number of likes (if available)"),
+    reposts: import_zod8.z.number().optional().describe("Number of reposts (if available)"),
+    replies: import_zod8.z.number().optional().describe("Number of replies (if available)"),
+    quotes: import_zod8.z.number().optional().describe("Number of quotes (if available)")
   }).optional().describe("Post metrics (if available)"),
-  inReplyToId: import_zod7.z.string().optional().describe("ID of the post this is a reply to (if applicable)"),
-  quotedPostId: import_zod7.z.string().optional().describe("ID of the post this is quoting (if applicable)")
+  inReplyToId: import_zod8.z.string().optional().describe("ID of the post this is a reply to (if applicable)"),
+  quotedPostId: import_zod8.z.string().optional().describe("ID of the post this is quoting (if applicable)")
 }).describe("Account post");
-var AccountPostsResponseSchema = import_zod7.z.object({
-  signerId: import_zod7.z.string().describe("NEAR account ID"),
-  posts: import_zod7.z.array(AccountPostSchema).describe("List of posts"),
-  platform: import_zod7.z.string().optional().describe("Platform filter (if applied)"),
-  type: import_zod7.z.enum(["post", "repost", "reply", "quote", "like", "all"]).optional().describe(
+var AccountPostsResponseSchema = import_zod8.z.object({
+  signerId: import_zod8.z.string().describe("NEAR account ID"),
+  posts: import_zod8.z.array(AccountPostSchema).describe("List of posts"),
+  platform: import_zod8.z.string().optional().describe("Platform filter (if applied)"),
+  type: import_zod8.z.enum(["post", "repost", "reply", "quote", "like", "all"]).optional().describe(
     "Post type filter (if applied)"
   )
 });
-
-// src/user-profile.ts
-var import_zod8 = require("zod");
-var UserProfileSchema = import_zod8.z.object({
-  userId: import_zod8.z.string().describe("User ID on the platform"),
-  username: import_zod8.z.string().describe("Username on the platform"),
-  url: import_zod8.z.string().url().optional().describe("URL to the user profile"),
-  profileImageUrl: import_zod8.z.string().describe("URL to the user profile image"),
-  isPremium: import_zod8.z.boolean().optional().describe("Whether the user has a premium account"),
-  platform: PlatformSchema.describe("The platform the user profile is from"),
-  lastUpdated: import_zod8.z.number().describe("Timestamp when the profile was last updated")
-}).describe("User profile");
-var ProfileRefreshResponseSchema = import_zod8.z.object({
-  profile: UserProfileSchema.optional().describe("The refreshed user profile (if successful)")
-}).describe("Profile refresh response");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AccountActivityEntrySchema,