@crosspost/types 0.1.2

package/dist/index.js

@@ -0,0 +1,852 @@
+// src/common.ts
+import { z } from "zod";
+var PlatformSchema = z.enum([
+  "unknown",
+  "twitter"
+  // Add more platforms as they're implemented
+  // 'linkedin',
+  // 'facebook',
+  // 'instagram',
+]).describe("Social media platform");
+var Platform = /* @__PURE__ */ ((Platform2) => {
+  Platform2["UNKNOWN"] = "unknown";
+  Platform2["TWITTER"] = "twitter";
+  return Platform2;
+})(Platform || {});
+
+// src/response.ts
+import { z as z2 } from "zod";
+var ApiResponseSchema = z2.object({
+  data: z2.any().describe("Response data"),
+  meta: z2.object({
+    rateLimit: z2.object({
+      remaining: z2.number().describe("Number of requests remaining in the current window"),
+      limit: z2.number().describe("Total number of requests allowed in the window"),
+      reset: z2.number().describe("Timestamp when the rate limit resets (in seconds since epoch)")
+    }).optional().describe("Rate limit information"),
+    pagination: z2.object({
+      page: z2.number().describe("Current page number"),
+      perPage: z2.number().describe("Number of items per page"),
+      total: z2.number().describe("Total number of items"),
+      totalPages: z2.number().describe("Total number of pages"),
+      nextCursor: z2.string().optional().describe("Next page cursor (if applicable)"),
+      prevCursor: z2.string().optional().describe("Previous page cursor (if applicable)")
+    }).optional().describe("Pagination information")
+  }).optional().describe("Response metadata")
+}).describe("Standard API response");
+var ErrorResponseSchema = z2.object({
+  error: z2.object({
+    type: z2.string().describe("Error type"),
+    message: z2.string().describe("Error message"),
+    code: z2.string().optional().describe("Error code (if applicable)"),
+    details: z2.any().optional().describe("Additional error details")
+  }).describe("Error information")
+}).describe("Error response");
+var EnhancedResponseMetaSchema = z2.object({
+  requestId: z2.string().optional().describe("Unique request identifier"),
+  timestamp: z2.string().optional().describe("Request timestamp"),
+  rateLimit: z2.object({
+    remaining: z2.number().describe("Number of requests remaining in the current window"),
+    limit: z2.number().describe("Total number of requests allowed in the window"),
+    reset: z2.number().describe("Timestamp when the rate limit resets (in seconds since epoch)")
+  }).optional().describe("Rate limit information"),
+  pagination: z2.object({
+    page: z2.number().describe("Current page number"),
+    perPage: z2.number().describe("Number of items per page"),
+    total: z2.number().describe("Total number of items"),
+    totalPages: z2.number().describe("Total number of pages"),
+    nextCursor: z2.string().optional().describe("Next page cursor (if applicable)"),
+    prevCursor: z2.string().optional().describe("Previous page cursor (if applicable)")
+  }).optional().describe("Pagination information")
+}).optional().describe("Response metadata");
+var ErrorDetailSchema = z2.object({
+  platform: z2.string().optional().describe("Platform associated with the error (if applicable)"),
+  userId: z2.string().optional().describe("User ID associated with the error (if applicable)"),
+  status: z2.literal("error").describe("Error status"),
+  error: z2.string().describe("Human-readable error message"),
+  errorCode: z2.string().describe("Machine-readable error code"),
+  recoverable: z2.boolean().describe("Whether the error is recoverable (can be retried)"),
+  details: z2.record(z2.any()).optional().describe("Additional error details (platform-specific)")
+}).describe("Error detail");
+var EnhancedErrorResponseSchema = z2.object({
+  success: z2.literal(false).describe("Success indicator (always false for error responses)"),
+  errors: z2.array(ErrorDetailSchema).describe("Error information")
+}).describe("Enhanced error response");
+var SuccessDetailSchema = z2.object({
+  platform: z2.string().describe("Platform associated with the success"),
+  userId: z2.string().describe("User ID associated with the success"),
+  status: z2.literal("success").describe("Success status"),
+  postId: z2.string().optional().describe("Post ID (if applicable)"),
+  postUrl: z2.string().optional().describe("Post URL (if applicable)")
+}).catchall(z2.any()).describe("Success detail");
+var MultiStatusResponseSchema = z2.object({
+  success: z2.boolean().describe("Success indicator (true if at least one operation succeeded)"),
+  data: z2.object({
+    summary: z2.object({
+      total: z2.number().describe("Total number of operations"),
+      succeeded: z2.number().describe("Number of successful operations"),
+      failed: z2.number().describe("Number of failed operations")
+    }).describe("Summary of operations"),
+    results: z2.array(SuccessDetailSchema).describe("Successful results"),
+    errors: z2.array(ErrorDetailSchema).describe("Failed results")
+  }).describe("Response data")
+}).describe("Multi-status response");
+function EnhancedResponseSchema(schema) {
+  return z2.object({
+    success: z2.boolean().describe("Whether the request was successful"),
+    data: schema,
+    meta: EnhancedResponseMetaSchema
+  });
+}
+function createEnhancedApiResponse(data, meta) {
+  return {
+    success: true,
+    data,
+    meta
+  };
+}
+function createApiResponse(data, meta) {
+  return {
+    data,
+    meta
+  };
+}
+function createErrorResponse(type, message, code, details) {
+  return {
+    error: {
+      type,
+      message,
+      ...code ? { code } : {},
+      ...details ? { details } : {}
+    }
+  };
+}
+function createEnhancedErrorResponse(errors) {
+  return {
+    success: false,
+    errors
+  };
+}
+function createErrorDetail(error, errorCode, recoverable, platform, userId, details) {
+  return {
+    platform,
+    userId,
+    status: "error",
+    error,
+    errorCode,
+    recoverable,
+    details
+  };
+}
+function createSuccessDetail(platform, userId, additionalData) {
+  return {
+    platform,
+    userId,
+    status: "success",
+    ...additionalData
+  };
+}
+function createMultiStatusResponse(results, errors) {
+  const total = results.length + errors.length;
+  const succeeded = results.length;
+  const failed = errors.length;
+  return {
+    success: succeeded > 0,
+    data: {
+      summary: {
+        total,
+        succeeded,
+        failed
+      },
+      results,
+      errors
+    }
+  };
+}
+
+// src/errors/base-error.ts
+var BaseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+
+// src/errors/api-error.ts
+var ApiErrorCode = /* @__PURE__ */ ((ApiErrorCode2) => {
+  ApiErrorCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+  ApiErrorCode2["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+  ApiErrorCode2["UNAUTHORIZED"] = "UNAUTHORIZED";
+  ApiErrorCode2["FORBIDDEN"] = "FORBIDDEN";
+  ApiErrorCode2["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+  ApiErrorCode2["INVALID_REQUEST"] = "INVALID_REQUEST";
+  ApiErrorCode2["RATE_LIMITED"] = "RATE_LIMITED";
+  ApiErrorCode2["NOT_FOUND"] = "NOT_FOUND";
+  ApiErrorCode2["PLATFORM_ERROR"] = "PLATFORM_ERROR";
+  ApiErrorCode2["PLATFORM_UNAVAILABLE"] = "PLATFORM_UNAVAILABLE";
+  ApiErrorCode2["CONTENT_POLICY_VIOLATION"] = "CONTENT_POLICY_VIOLATION";
+  ApiErrorCode2["DUPLICATE_CONTENT"] = "DUPLICATE_CONTENT";
+  ApiErrorCode2["MEDIA_UPLOAD_FAILED"] = "MEDIA_UPLOAD_FAILED";
+  ApiErrorCode2["POST_CREATION_FAILED"] = "POST_CREATION_FAILED";
+  ApiErrorCode2["THREAD_CREATION_FAILED"] = "THREAD_CREATION_FAILED";
+  ApiErrorCode2["POST_DELETION_FAILED"] = "POST_DELETION_FAILED";
+  ApiErrorCode2["POST_INTERACTION_FAILED"] = "POST_INTERACTION_FAILED";
+  ApiErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  return ApiErrorCode2;
+})(ApiErrorCode || {});
+var ApiError = class _ApiError extends BaseError {
+  constructor(message, code = "INTERNAL_ERROR" /* INTERNAL_ERROR */, status = 500, details, recoverable = false) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.details = details;
+    this.recoverable = recoverable;
+  }
+  /**
+   * Create a validation error
+   */
+  static validation(message, details) {
+    return new _ApiError(
+      message,
+      "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+      400,
+      details,
+      true
+    );
+  }
+  /**
+   * Create an unauthorized error
+   */
+  static unauthorized(message = "Unauthorized") {
+    return new _ApiError(
+      message,
+      "UNAUTHORIZED" /* UNAUTHORIZED */,
+      401,
+      void 0,
+      true
+    );
+  }
+  /**
+   * Create a forbidden error
+   */
+  static forbidden(message = "Forbidden") {
+    return new _ApiError(
+      message,
+      "FORBIDDEN" /* FORBIDDEN */,
+      403,
+      void 0,
+      false
+    );
+  }
+  /**
+   * Create a not found error
+   */
+  static notFound(message = "Resource not found") {
+    return new _ApiError(
+      message,
+      "NOT_FOUND" /* NOT_FOUND */,
+      404,
+      void 0,
+      false
+    );
+  }
+  /**
+   * Create a rate limit error
+   */
+  static rateLimited(message = "Rate limit exceeded", details) {
+    return new _ApiError(
+      message,
+      "RATE_LIMITED" /* RATE_LIMITED */,
+      429,
+      details,
+      true
+    );
+  }
+  /**
+   * Create an internal server error
+   */
+  static internal(message = "Internal server error", details) {
+    return new _ApiError(
+      message,
+      "INTERNAL_ERROR" /* INTERNAL_ERROR */,
+      500,
+      details,
+      false
+    );
+  }
+};
+
+// src/errors/platform-error.ts
+var PlatformError = class extends Error {
+  constructor(message, platform, code = "PLATFORM_ERROR" /* PLATFORM_ERROR */, recoverable = false, originalError, status, userId, details) {
+    super(message);
+    this.originalError = originalError;
+    this.status = status;
+    this.name = "PlatformError";
+    this.code = code;
+    this.recoverable = recoverable;
+    this.platform = platform;
+    this.userId = userId;
+    this.details = details;
+  }
+};
+
+// src/auth.ts
+import { z as z3 } from "zod";
+var PlatformParamSchema = z3.object({
+  platform: z3.string().describe("Social media platform")
+}).describe("Platform parameter");
+var AuthInitRequestSchema = z3.object({
+  successUrl: z3.string().url().optional().describe(
+    "URL to redirect to on successful authentication"
+  ),
+  errorUrl: z3.string().url().optional().describe("URL to redirect to on authentication error")
+}).describe("Auth initialization request");
+var AuthUrlResponseSchema = EnhancedResponseSchema(
+  z3.object({
+    url: z3.string().describe("Authentication URL to redirect the user to"),
+    state: z3.string().describe("State parameter for CSRF protection"),
+    platform: PlatformSchema
+  })
+).describe("Auth URL response");
+var AuthCallbackQuerySchema = z3.object({
+  code: z3.string().describe("Authorization code from OAuth provider"),
+  state: z3.string().describe("State parameter for CSRF protection")
+}).describe("Auth callback query");
+var AuthCallbackResponseSchema = EnhancedResponseSchema(
+  z3.object({
+    success: z3.boolean().describe("Whether the authentication was successful"),
+    platform: PlatformSchema,
+    userId: z3.string().describe("User ID"),
+    redirectUrl: z3.string().optional().describe("URL to redirect the user to after authentication")
+  })
+).describe("Auth callback response");
+var AuthStatusResponseSchema = EnhancedResponseSchema(
+  z3.object({
+    platform: PlatformSchema,
+    userId: z3.string().describe("User ID"),
+    authenticated: z3.boolean().describe("Whether the user is authenticated"),
+    tokenStatus: z3.object({
+      valid: z3.boolean().describe("Whether the token is valid"),
+      expired: z3.boolean().describe("Whether the token is expired"),
+      expiresAt: z3.string().optional().describe("When the token expires")
+    })
+  })
+).describe("Auth status response");
+var AuthRevokeResponseSchema = EnhancedResponseSchema(
+  z3.object({
+    success: z3.boolean().describe("Whether the revocation was successful"),
+    platform: PlatformSchema,
+    userId: z3.string().describe("User ID")
+  })
+).describe("Auth revoke response");
+var ConnectedAccountSchema = z3.object({
+  platform: PlatformSchema,
+  userId: z3.string().describe("User ID on the platform"),
+  username: z3.string().optional().describe("Username on the platform (if available)"),
+  profileUrl: z3.string().optional().describe("URL to the user profile"),
+  connectedAt: z3.string().optional().describe("When the account was connected")
+}).describe("Connected account");
+var ConnectedAccountsResponseSchema = EnhancedResponseSchema(
+  z3.array(ConnectedAccountSchema)
+).describe("Connected accounts response");
+var NearAuthorizationRequestSchema = z3.object({
+  // No additional parameters needed, as the NEAR account ID is extracted from the signature
+}).describe("NEAR authorization request");
+var NearAuthorizationResponseSchema = EnhancedResponseSchema(
+  z3.object({
+    success: z3.boolean().describe("Whether the authorization was successful"),
+    nearAccount: z3.string().describe("NEAR account ID"),
+    authorized: z3.boolean().describe("Whether the account is authorized")
+  })
+).describe("NEAR authorization response");
+var NearAuthorizationStatusResponseSchema = EnhancedResponseSchema(
+  z3.object({
+    nearAccount: z3.string().describe("NEAR account ID"),
+    authorized: z3.boolean().describe("Whether the account is authorized"),
+    authorizedAt: z3.string().optional().describe("When the account was authorized")
+  })
+).describe("NEAR authorization status response");
+
+// src/post.ts
+import { z as z4 } from "zod";
+var MediaContentSchema = z4.object({
+  data: z4.union([z4.string(), z4.instanceof(Blob)]).describe("Media data as string or Blob"),
+  mimeType: z4.string().optional().describe("Media MIME type"),
+  altText: z4.string().optional().describe("Alt text for the media")
+}).describe("Media content object");
+var MediaSchema = z4.object({
+  id: z4.string().describe("Media ID"),
+  type: z4.enum(["image", "video", "gif"]).describe("Media type"),
+  url: z4.string().optional().describe("Media URL"),
+  altText: z4.string().optional().describe("Alt text for the media")
+}).describe("Media object");
+var PostMetricsSchema = z4.object({
+  retweets: z4.number().describe("Number of retweets"),
+  quotes: z4.number().describe("Number of quotes"),
+  likes: z4.number().describe("Number of likes"),
+  replies: z4.number().describe("Number of replies")
+}).describe("Post metrics");
+var PostSchema = z4.object({
+  id: z4.string().describe("Post ID"),
+  text: z4.string().describe("Post text content"),
+  createdAt: z4.string().describe("Post creation date"),
+  authorId: z4.string().describe("Author ID"),
+  media: z4.array(MediaSchema).optional().describe("Media attached to the post"),
+  metrics: PostMetricsSchema.optional().describe("Post metrics"),
+  inReplyToId: z4.string().optional().describe("ID of the post this is a reply to"),
+  quotedPostId: z4.string().optional().describe("ID of the post this is quoting")
+}).describe("Post object");
+var PostContentSchema = z4.object({
+  text: z4.string().optional().describe("Text content for the post"),
+  media: z4.array(MediaContentSchema).optional().describe("Media attachments for the post")
+}).describe("Post content");
+var PostResultSchema = z4.object({
+  id: z4.string().describe("Post ID"),
+  text: z4.string().optional().describe("Post text content"),
+  createdAt: z4.string().describe("Post creation date"),
+  mediaIds: z4.array(z4.string()).optional().describe("Media IDs attached to the post"),
+  threadIds: z4.array(z4.string()).optional().describe("Thread IDs for threaded posts"),
+  quotedPostId: z4.string().optional().describe("ID of the post this is quoting"),
+  inReplyToId: z4.string().optional().describe("ID of the post this is a reply to"),
+  success: z4.boolean().optional().describe("Whether the operation was successful")
+}).catchall(z4.any()).describe("Post result");
+var DeleteResultSchema = z4.object({
+  success: z4.boolean().describe("Whether the deletion was successful"),
+  id: z4.string().describe("ID of the deleted post")
+}).describe("Delete result");
+var LikeResultSchema = z4.object({
+  success: z4.boolean().describe("Whether the like was successful"),
+  id: z4.string().describe("ID of the liked post")
+}).describe("Like result");
+var PostSuccessDetailSchema = z4.object({
+  platform: PlatformSchema,
+  userId: z4.string().describe("User ID"),
+  status: z4.literal("success"),
+  postId: z4.string().optional().describe("Post ID"),
+  postUrl: z4.string().optional().describe("URL to the post")
+}).catchall(z4.any()).describe("Post success detail");
+var TargetSchema = z4.object({
+  platform: PlatformSchema.describe('The platform to post to (e.g., "twitter")'),
+  userId: z4.string().describe("User ID on the platform")
+}).describe("Target for posting operations");
+var CreatePostRequestSchema = z4.object({
+  targets: z4.array(TargetSchema).describe("Array of targets to post to (can be a single target)"),
+  content: z4.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 = z4.object({
+  targets: z4.array(TargetSchema).describe("Array of targets to post to"),
+  platform: PlatformSchema.describe("Platform of the post being reposted"),
+  postId: z4.string().describe("ID of the post to repost")
+}).describe("Repost request");
+var QuotePostRequestSchema = z4.object({
+  targets: z4.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: z4.string().describe("ID of the post to quote"),
+  content: z4.array(PostContentSchema).describe(
+    "Content for the quote post(s), always an array, even for a single post"
+  )
+}).describe("Quote post request");
+var ReplyToPostRequestSchema = z4.object({
+  targets: z4.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: z4.string().describe("ID of the post to reply to"),
+  content: z4.array(PostContentSchema).describe(
+    "Content for the reply post(s), always an array, even for a single post"
+  )
+}).describe("Reply to post request");
+var PostToDeleteSchema = z4.object({
+  platform: PlatformSchema.describe("Platform of the post to delete"),
+  userId: z4.string().describe("User ID on the platform"),
+  postId: z4.string().describe("ID of the post to delete")
+}).describe("Post to delete");
+var DeletePostRequestSchema = z4.object({
+  targets: z4.array(TargetSchema).describe("Array of targets to delete posts"),
+  posts: z4.array(PostToDeleteSchema).describe("Array of posts to delete")
+}).describe("Delete post request");
+var LikePostRequestSchema = z4.object({
+  targets: z4.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: z4.string().describe("ID of the post to like")
+}).describe("Like post request");
+var UnlikePostRequestSchema = z4.object({
+  targets: z4.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: z4.string().describe("ID of the post to unlike")
+}).describe("Unlike post request");
+var PostResponseSchema = EnhancedResponseSchema(
+  z4.union([PostSchema, z4.array(PostSchema)])
+).describe("Post response");
+var CreatePostResponseLegacySchema = PostResponseSchema.describe(
+  "Create post response (legacy)"
+);
+var RepostResponseSchema = PostResponseSchema.describe("Repost response");
+var QuotePostResponseSchema = PostResponseSchema.describe("Quote post response");
+var ReplyToPostResponseSchema = PostResponseSchema.describe("Reply to post response");
+var DeletePostResponseSchema = EnhancedResponseSchema(
+  z4.object({
+    success: z4.boolean().describe("Whether the deletion was successful"),
+    id: z4.string().describe("ID of the deleted post")
+  })
+).describe("Delete post response");
+var LikePostResponseSchema = EnhancedResponseSchema(
+  z4.object({
+    success: z4.boolean().describe("Whether the like was successful"),
+    id: z4.string().describe("ID of the liked post")
+  })
+).describe("Like post response");
+var UnlikePostResponseSchema = EnhancedResponseSchema(
+  z4.object({
+    success: z4.boolean().describe("Whether the unlike was successful"),
+    id: z4.string().describe("ID of the unliked post")
+  })
+).describe("Unlike post response");
+var PostMultiStatusResponseSchema = z4.object({
+  success: z4.boolean().describe("Whether the operation was partially or fully successful"),
+  data: z4.object({
+    summary: z4.object({
+      total: z4.number().describe("Total number of operations"),
+      succeeded: z4.number().describe("Number of successful operations"),
+      failed: z4.number().describe("Number of failed operations")
+    }),
+    results: z4.array(PostSuccessDetailSchema).describe("Successful operations"),
+    errors: z4.array(ErrorDetailSchema).describe("Failed operations")
+  })
+}).describe("Multi-status response for post operations");
+var CreatePostTargetResultSchema = z4.object({
+  platform: PlatformSchema.describe("The platform the post was created on"),
+  userId: z4.string().describe("The user ID on the platform"),
+  result: z4.array(z4.any()).describe("The result of the post creation")
+}).describe("Create post target result");
+var CreatePostTargetErrorSchema = z4.object({
+  platform: PlatformSchema.optional().describe(
+    "The platform where the error occurred (if applicable)"
+  ),
+  userId: z4.string().optional().describe("The user ID where the error occurred (if applicable)"),
+  error: z4.string().describe("The error message")
+}).describe("Create post target error");
+var CreatePostResponseSchema = EnhancedResponseSchema(
+  z4.object({
+    results: z4.array(CreatePostTargetResultSchema).describe("Array of successful post results"),
+    errors: z4.array(CreatePostTargetErrorSchema).optional().describe(
+      "Array of errors that occurred (if any)"
+    )
+  })
+).describe("Create post response");
+
+// src/rate-limit.ts
+import { z as z5 } from "zod";
+var RateLimitEndpointParamSchema = z5.object({
+  endpoint: z5.string().optional().describe(
+    "Specific endpoint to get rate limit information for (optional)"
+  )
+}).describe("Rate limit endpoint parameter");
+var RateLimitEndpointSchema = z5.object({
+  endpoint: z5.string().describe("API endpoint"),
+  method: z5.enum(["GET", "POST", "PUT", "DELETE"]).describe("HTTP method"),
+  limit: z5.number().describe("Rate limit"),
+  remaining: z5.number().describe("Remaining requests"),
+  reset: z5.number().describe("Reset timestamp (Unix timestamp in seconds)"),
+  resetDate: z5.string().describe("Reset date (ISO string)")
+}).describe("Rate limit endpoint");
+var RateLimitStatusSchema = z5.object({
+  endpoint: z5.string().describe("API endpoint or action"),
+  limit: z5.number().describe("Maximum number of requests allowed in the time window"),
+  remaining: z5.number().describe("Number of requests remaining in the current time window"),
+  reset: z5.string().datetime().describe("Timestamp when the rate limit will reset"),
+  resetSeconds: z5.number().describe("Seconds until the rate limit will reset")
+}).describe("Rate limit status");
+var PlatformRateLimitSchema = z5.object({
+  platform: PlatformSchema,
+  endpoints: z5.record(z5.string(), RateLimitStatusSchema).describe(
+    "Rate limit status for each endpoint"
+  )
+}).describe("Platform-specific rate limit");
+var UsageRateLimitSchema = z5.object({
+  endpoint: z5.string().describe("API endpoint or action"),
+  limit: z5.number().describe("Maximum number of requests allowed in the time window"),
+  remaining: z5.number().describe("Number of requests remaining in the current time window"),
+  reset: z5.string().datetime().describe("Timestamp when the rate limit will reset"),
+  resetSeconds: z5.number().describe("Seconds until the rate limit will reset"),
+  timeWindow: z5.string().describe("Time window for the rate limit")
+}).describe("Usage rate limit");
+var RateLimitStatusResponseSchema = EnhancedResponseSchema(
+  z5.object({
+    platform: PlatformSchema,
+    userId: z5.string().optional().describe("User ID"),
+    endpoints: z5.array(RateLimitEndpointSchema).describe("Rate limits for specific endpoints"),
+    app: z5.object({
+      limit: z5.number().describe("App-wide rate limit"),
+      remaining: z5.number().describe("Remaining requests"),
+      reset: z5.number().describe("Reset timestamp (Unix timestamp in seconds)"),
+      resetDate: z5.string().describe("Reset date (ISO string)")
+    }).optional().describe("App-wide rate limits")
+  })
+).describe("Rate limit status response");
+var AllRateLimitsResponseSchema = EnhancedResponseSchema(
+  z5.object({
+    platforms: z5.record(
+      PlatformSchema,
+      z5.object({
+        users: z5.record(
+          z5.string(),
+          z5.object({
+            endpoints: z5.array(RateLimitEndpointSchema).describe(
+              "Rate limits for specific endpoints"
+            ),
+            lastUpdated: z5.string().describe("Last updated date (ISO string)")
+          })
+        ).describe("User-specific rate limits"),
+        app: z5.object({
+          limit: z5.number().describe("App-wide rate limit"),
+          remaining: z5.number().describe("Remaining requests"),
+          reset: z5.number().describe("Reset timestamp (Unix timestamp in seconds)"),
+          resetDate: z5.string().describe("Reset date (ISO string)")
+        }).optional().describe("App-wide rate limits")
+      })
+    ).describe("Rate limits by platform")
+  })
+).describe("All rate limits response");
+var RateLimitResponseSchema = z5.object({
+  platformLimits: z5.array(PlatformRateLimitSchema).describe("Platform-specific rate limits"),
+  usageLimits: z5.record(z5.string(), UsageRateLimitSchema).describe(
+    "Usage-based rate limits for the NEAR account"
+  ),
+  signerId: z5.string().describe("NEAR account ID")
+}).describe("Rate limit response");
+var EndpointRateLimitResponseSchema = z5.object({
+  platformLimits: z5.array(
+    z5.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: z5.string().describe("API endpoint or action"),
+  signerId: z5.string().describe("NEAR account ID")
+}).describe("Endpoint rate limit response");
+
+// src/leaderboard.ts
+import { z as z6 } from "zod";
+var LeaderboardQuerySchema = z6.object({
+  timeframe: z6.enum(["day", "week", "month", "all"]).optional().describe(
+    "Timeframe for the leaderboard"
+  ),
+  limit: z6.string().optional().transform((val) => val ? parseInt(val, 10) : void 0).pipe(z6.number().min(1).max(100).optional()).describe("Maximum number of results to return (1-100)"),
+  offset: z6.string().optional().transform((val) => val ? parseInt(val, 10) : void 0).pipe(z6.number().min(0).optional()).describe("Offset for pagination")
+}).describe("Leaderboard query");
+var AccountActivityEntrySchema = z6.object({
+  signerId: z6.string().describe("NEAR account ID"),
+  totalPosts: z6.number().describe("Total number of posts"),
+  totalLikes: z6.number().describe("Total number of likes"),
+  totalReposts: z6.number().describe("Total number of reposts"),
+  totalReplies: z6.number().describe("Total number of replies"),
+  totalQuotes: z6.number().describe("Total number of quote posts"),
+  totalScore: z6.number().describe("Total activity score"),
+  rank: z6.number().describe("Rank on the leaderboard"),
+  lastActive: z6.string().datetime().describe("Timestamp of last activity")
+}).describe("Account activity entry");
+var LeaderboardResponseSchema = EnhancedResponseSchema(
+  z6.object({
+    timeframe: z6.enum(["day", "week", "month", "all"]).describe("Timeframe for the leaderboard"),
+    entries: z6.array(AccountActivityEntrySchema).describe("Leaderboard entries"),
+    total: z6.number().describe("Total number of entries in the leaderboard"),
+    limit: z6.number().describe("Maximum number of results returned"),
+    offset: z6.number().describe("Offset for pagination"),
+    generatedAt: z6.string().datetime().describe("Timestamp when the leaderboard was generated")
+  })
+).describe("Leaderboard response");
+var AccountActivityParamsSchema = z6.object({
+  signerId: z6.string().describe("NEAR account ID")
+}).describe("Account activity params");
+var AccountActivityQuerySchema = z6.object({
+  timeframe: z6.enum(["day", "week", "month", "all"]).optional().describe(
+    "Timeframe for the activity"
+  )
+}).describe("Account activity query");
+var PlatformActivitySchema = z6.object({
+  platform: PlatformSchema,
+  posts: z6.number().describe("Number of posts on this platform"),
+  likes: z6.number().describe("Number of likes on this platform"),
+  reposts: z6.number().describe("Number of reposts on this platform"),
+  replies: z6.number().describe("Number of replies on this platform"),
+  quotes: z6.number().describe("Number of quote posts on this platform"),
+  score: z6.number().describe("Activity score on this platform"),
+  lastActive: z6.string().datetime().describe("Timestamp of last activity on this platform")
+}).describe("Platform activity");
+var AccountActivityResponseSchema = EnhancedResponseSchema(
+  z6.object({
+    signerId: z6.string().describe("NEAR account ID"),
+    timeframe: z6.enum(["day", "week", "month", "all"]).describe("Timeframe for the activity"),
+    totalPosts: z6.number().describe("Total number of posts across all platforms"),
+    totalLikes: z6.number().describe("Total number of likes across all platforms"),
+    totalReposts: z6.number().describe("Total number of reposts across all platforms"),
+    totalReplies: z6.number().describe("Total number of replies across all platforms"),
+    totalQuotes: z6.number().describe("Total number of quote posts across all platforms"),
+    totalScore: z6.number().describe("Total activity score across all platforms"),
+    rank: z6.number().describe("Rank on the leaderboard"),
+    lastActive: z6.string().datetime().describe("Timestamp of last activity across all platforms"),
+    platforms: z6.array(PlatformActivitySchema).describe("Activity breakdown by platform")
+  })
+).describe("Account activity response");
+var AccountPostsParamsSchema = z6.object({
+  signerId: z6.string().describe("NEAR account ID")
+}).describe("Account posts params");
+var AccountPostsQuerySchema = z6.object({
+  platform: z6.string().optional().describe("Filter by platform (optional)"),
+  limit: z6.string().optional().transform((val) => val ? parseInt(val, 10) : void 0).pipe(z6.number().min(1).max(100).optional()).describe("Maximum number of results to return (1-100)"),
+  offset: z6.string().optional().transform((val) => val ? parseInt(val, 10) : void 0).pipe(z6.number().min(0).optional()).describe("Offset for pagination"),
+  type: z6.enum(["post", "repost", "reply", "quote", "like", "all"]).optional().describe(
+    "Filter by post type (optional)"
+  )
+}).describe("Account posts query");
+var AccountPostSchema = z6.object({
+  id: z6.string().describe("Post ID"),
+  platform: PlatformSchema,
+  type: z6.enum(["post", "repost", "reply", "quote", "like"]).describe("Type of post"),
+  content: z6.string().optional().describe("Post content (if available)"),
+  url: z6.string().url().optional().describe("URL to the post on the platform (if available)"),
+  createdAt: z6.string().datetime().describe("Timestamp when the post was created"),
+  metrics: z6.object({
+    likes: z6.number().optional().describe("Number of likes (if available)"),
+    reposts: z6.number().optional().describe("Number of reposts (if available)"),
+    replies: z6.number().optional().describe("Number of replies (if available)"),
+    quotes: z6.number().optional().describe("Number of quotes (if available)")
+  }).optional().describe("Post metrics (if available)"),
+  inReplyToId: z6.string().optional().describe("ID of the post this is a reply to (if applicable)"),
+  quotedPostId: z6.string().optional().describe("ID of the post this is quoting (if applicable)")
+}).describe("Account post");
+var AccountPostsResponseSchema = EnhancedResponseSchema(
+  z6.object({
+    signerId: z6.string().describe("NEAR account ID"),
+    posts: z6.array(AccountPostSchema).describe("List of posts"),
+    total: z6.number().describe("Total number of posts matching the query"),
+    limit: z6.number().describe("Maximum number of results returned"),
+    offset: z6.number().describe("Offset for pagination"),
+    platform: z6.string().optional().describe("Platform filter (if applied)"),
+    type: z6.enum(["post", "repost", "reply", "quote", "like", "all"]).optional().describe(
+      "Post type filter (if applied)"
+    )
+  })
+).describe("Account posts response");
+
+// src/user-profile.ts
+import { z as z7 } from "zod";
+var UserProfileSchema = z7.object({
+  userId: z7.string().describe("User ID on the platform"),
+  username: z7.string().describe("Username on the platform"),
+  url: z7.string().url().optional().describe("URL to the user profile"),
+  profileImageUrl: z7.string().describe("URL to the user profile image"),
+  isPremium: z7.boolean().optional().describe("Whether the user has a premium account"),
+  platform: PlatformSchema.describe("The platform the user profile is from"),
+  lastUpdated: z7.number().describe("Timestamp when the profile was last updated")
+}).describe("User profile");
+var ProfileRefreshResultSchema = z7.object({
+  success: z7.boolean().describe("Whether the profile refresh was successful"),
+  profile: UserProfileSchema.optional().describe("The refreshed user profile (if successful)"),
+  error: z7.string().optional().describe("Error message (if unsuccessful)")
+}).describe("Profile refresh result");
+var ProfileRefreshResponseSchema = EnhancedResponseSchema(
+  ProfileRefreshResultSchema
+).describe("Profile refresh response");
+export {
+  AccountActivityEntrySchema,
+  AccountActivityParamsSchema,
+  AccountActivityQuerySchema,
+  AccountActivityResponseSchema,
+  AccountPostSchema,
+  AccountPostsParamsSchema,
+  AccountPostsQuerySchema,
+  AccountPostsResponseSchema,
+  AllRateLimitsResponseSchema,
+  ApiError,
+  ApiErrorCode,
+  ApiResponseSchema,
+  AuthCallbackQuerySchema,
+  AuthCallbackResponseSchema,
+  AuthInitRequestSchema,
+  AuthRevokeResponseSchema,
+  AuthStatusResponseSchema,
+  AuthUrlResponseSchema,
+  BaseError,
+  ConnectedAccountSchema,
+  ConnectedAccountsResponseSchema,
+  CreatePostRequestSchema,
+  CreatePostResponseLegacySchema,
+  CreatePostResponseSchema,
+  CreatePostTargetErrorSchema,
+  CreatePostTargetResultSchema,
+  DeletePostRequestSchema,
+  DeletePostResponseSchema,
+  DeleteResultSchema,
+  EndpointRateLimitResponseSchema,
+  EnhancedErrorResponseSchema,
+  EnhancedResponseMetaSchema,
+  EnhancedResponseSchema,
+  ErrorDetailSchema,
+  ErrorResponseSchema,
+  LeaderboardQuerySchema,
+  LeaderboardResponseSchema,
+  LikePostRequestSchema,
+  LikePostResponseSchema,
+  LikeResultSchema,
+  MediaContentSchema,
+  MediaSchema,
+  MultiStatusResponseSchema,
+  NearAuthorizationRequestSchema,
+  NearAuthorizationResponseSchema,
+  NearAuthorizationStatusResponseSchema,
+  Platform,
+  PlatformActivitySchema,
+  PlatformError,
+  PlatformParamSchema,
+  PlatformRateLimitSchema,
+  PlatformSchema,
+  PostContentSchema,
+  PostMetricsSchema,
+  PostMultiStatusResponseSchema,
+  PostResponseSchema,
+  PostResultSchema,
+  PostSchema,
+  PostSuccessDetailSchema,
+  PostToDeleteSchema,
+  ProfileRefreshResponseSchema,
+  ProfileRefreshResultSchema,
+  QuotePostRequestSchema,
+  QuotePostResponseSchema,
+  RateLimitEndpointParamSchema,
+  RateLimitEndpointSchema,
+  RateLimitResponseSchema,
+  RateLimitStatusResponseSchema,
+  RateLimitStatusSchema,
+  ReplyToPostRequestSchema,
+  ReplyToPostResponseSchema,
+  RepostRequestSchema,
+  RepostResponseSchema,
+  SuccessDetailSchema,
+  TargetSchema,
+  UnlikePostRequestSchema,
+  UnlikePostResponseSchema,
+  UsageRateLimitSchema,
+  UserProfileSchema,
+  createApiResponse,
+  createEnhancedApiResponse,
+  createEnhancedErrorResponse,
+  createErrorDetail,
+  createErrorResponse,
+  createMultiStatusResponse,
+  createSuccessDetail
+};