@crosspost/types 0.1.6 → 0.1.7

package/dist/index.cjs

@@ -23,53 +23,40 @@ __export(index_exports, {
   AccountActivityEntrySchema: () => AccountActivityEntrySchema,
   AccountActivityParamsSchema: () => AccountActivityParamsSchema,
   AccountActivityQuerySchema: () => AccountActivityQuerySchema,
-  AccountActivityResponseSchema: () => AccountActivityResponseSchema,
   AccountPostSchema: () => AccountPostSchema,
   AccountPostsParamsSchema: () => AccountPostsParamsSchema,
   AccountPostsQuerySchema: () => AccountPostsQuerySchema,
-  AccountPostsResponseSchema: () => AccountPostsResponseSchema,
   ActivityLeaderboardQuerySchema: () => ActivityLeaderboardQuerySchema,
-  ActivityLeaderboardResponseSchema: () => ActivityLeaderboardResponseSchema,
   AllRateLimitsResponseSchema: () => AllRateLimitsResponseSchema,
-  ApiError: () => ApiError,
   ApiErrorCode: () => ApiErrorCode,
-  ApiResponseSchema: () => ApiResponseSchema,
+  ApiErrorCodeSchema: () => ApiErrorCodeSchema,
   AuthCallbackQuerySchema: () => AuthCallbackQuerySchema,
   AuthCallbackResponseSchema: () => AuthCallbackResponseSchema,
   AuthInitRequestSchema: () => AuthInitRequestSchema,
   AuthRevokeResponseSchema: () => AuthRevokeResponseSchema,
   AuthStatusResponseSchema: () => AuthStatusResponseSchema,
+  AuthTokenRequestSchema: () => AuthTokenRequestSchema,
   AuthUrlResponseSchema: () => AuthUrlResponseSchema,
-  BaseError: () => BaseError,
-  CompositeApiError: () => CompositeApiError,
   ConnectedAccountSchema: () => ConnectedAccountSchema,
   ConnectedAccountsResponseSchema: () => ConnectedAccountsResponseSchema,
   CreatePostRequestSchema: () => CreatePostRequestSchema,
-  CreatePostResponseLegacySchema: () => CreatePostResponseLegacySchema,
   CreatePostResponseSchema: () => CreatePostResponseSchema,
-  CreatePostTargetErrorSchema: () => CreatePostTargetErrorSchema,
-  CreatePostTargetResultSchema: () => CreatePostTargetResultSchema,
   DeletePostRequestSchema: () => DeletePostRequestSchema,
   DeletePostResponseSchema: () => DeletePostResponseSchema,
   DeleteResultSchema: () => DeleteResultSchema,
   EndpointRateLimitResponseSchema: () => EndpointRateLimitResponseSchema,
-  EnhancedErrorResponseSchema: () => EnhancedErrorResponseSchema,
-  EnhancedResponseMetaSchema: () => EnhancedResponseMetaSchema,
-  EnhancedResponseSchema: () => EnhancedResponseSchema,
   ErrorDetailSchema: () => ErrorDetailSchema,
-  ErrorResponseSchema: () => ErrorResponseSchema,
   LikePostRequestSchema: () => LikePostRequestSchema,
   LikePostResponseSchema: () => LikePostResponseSchema,
   LikeResultSchema: () => LikeResultSchema,
   MediaContentSchema: () => MediaContentSchema,
   MediaSchema: () => MediaSchema,
-  MultiStatusResponseSchema: () => MultiStatusResponseSchema,
+  MultiStatusDataSchema: () => MultiStatusDataSchema,
   NearAuthorizationRequestSchema: () => NearAuthorizationRequestSchema,
   NearAuthorizationResponseSchema: () => NearAuthorizationResponseSchema,
   NearAuthorizationStatusResponseSchema: () => NearAuthorizationStatusResponseSchema,
   Platform: () => Platform,
   PlatformActivitySchema: () => PlatformActivitySchema,
-  PlatformError: () => PlatformError,
   PlatformParamSchema: () => PlatformParamSchema,
   PlatformRateLimitSchema: () => PlatformRateLimitSchema,
   PlatformSchema: () => PlatformSchema,
@@ -82,7 +69,6 @@ __export(index_exports, {
   PostSuccessDetailSchema: () => PostSuccessDetailSchema,
   PostToDeleteSchema: () => PostToDeleteSchema,
   ProfileRefreshResponseSchema: () => ProfileRefreshResponseSchema,
-  ProfileRefreshResultSchema: () => ProfileRefreshResultSchema,
   QuotePostRequestSchema: () => QuotePostRequestSchema,
   QuotePostResponseSchema: () => QuotePostResponseSchema,
   RateLimitEndpointParamSchema: () => RateLimitEndpointParamSchema,
@@ -94,6 +80,7 @@ __export(index_exports, {
   ReplyToPostResponseSchema: () => ReplyToPostResponseSchema,
   RepostRequestSchema: () => RepostRequestSchema,
   RepostResponseSchema: () => RepostResponseSchema,
+  ResponseMetaSchema: () => ResponseMetaSchema,
   SUPPORTED_PLATFORMS: () => SUPPORTED_PLATFORMS,
   SuccessDetailSchema: () => SuccessDetailSchema,
   SupportedPlatformSchema: () => SupportedPlatformSchema,
@@ -103,13 +90,7 @@ __export(index_exports, {
   UnlikePostResponseSchema: () => UnlikePostResponseSchema,
   UsageRateLimitSchema: () => UsageRateLimitSchema,
   UserProfileSchema: () => UserProfileSchema,
-  createApiResponse: () => createApiResponse,
-  createEnhancedApiResponse: () => createEnhancedApiResponse,
-  createEnhancedErrorResponse: () => createEnhancedErrorResponse,
-  createErrorDetail: () => createErrorDetail,
-  createErrorResponse: () => createErrorResponse,
-  createMultiStatusResponse: () => createMultiStatusResponse,
-  createSuccessDetail: () => createSuccessDetail,
+  errorCodeToStatusCode: () => errorCodeToStatusCode,
   isPlatformSupported: () => isPlatformSupported
 });
 module.exports = __toCommonJS(index_exports);
@@ -133,167 +114,10 @@ function isPlatformSupported(platform) {
 }
 
 // src/response.ts
-var import_zod2 = require("zod");
-var ApiResponseSchema = import_zod2.z.object({
-  data: import_zod2.z.any().describe("Response data"),
-  meta: import_zod2.z.object({
-    rateLimit: import_zod2.z.object({
-      remaining: import_zod2.z.number().describe("Number of requests remaining in the current window"),
-      limit: import_zod2.z.number().describe("Total number of requests allowed in the window"),
-      reset: import_zod2.z.number().describe("Timestamp when the rate limit resets (in seconds since epoch)")
-    }).optional().describe("Rate limit information"),
-    pagination: import_zod2.z.object({
-      page: import_zod2.z.number().describe("Current page number"),
-      perPage: import_zod2.z.number().describe("Number of items per page"),
-      total: import_zod2.z.number().describe("Total number of items"),
-      totalPages: import_zod2.z.number().describe("Total number of pages"),
-      nextCursor: import_zod2.z.string().optional().describe("Next page cursor (if applicable)"),
-      prevCursor: import_zod2.z.string().optional().describe("Previous page cursor (if applicable)")
-    }).optional().describe("Pagination information")
-  }).optional().describe("Response metadata")
-}).describe("Standard API response");
-var ErrorResponseSchema = import_zod2.z.object({
-  error: import_zod2.z.object({
-    type: import_zod2.z.string().describe("Error type"),
-    message: import_zod2.z.string().describe("Error message"),
-    code: import_zod2.z.string().optional().describe("Error code (if applicable)"),
-    details: import_zod2.z.any().optional().describe("Additional error details")
-  }).describe("Error information")
-}).describe("Error response");
-var EnhancedResponseMetaSchema = import_zod2.z.object({
-  requestId: import_zod2.z.string().optional().describe("Unique request identifier"),
-  timestamp: import_zod2.z.string().optional().describe("Request timestamp"),
-  rateLimit: import_zod2.z.object({
-    remaining: import_zod2.z.number().describe("Number of requests remaining in the current window"),
-    limit: import_zod2.z.number().describe("Total number of requests allowed in the window"),
-    reset: import_zod2.z.number().describe("Timestamp when the rate limit resets (in seconds since epoch)")
-  }).optional().describe("Rate limit information"),
-  pagination: import_zod2.z.object({
-    page: import_zod2.z.number().describe("Current page number"),
-    perPage: import_zod2.z.number().describe("Number of items per page"),
-    total: import_zod2.z.number().describe("Total number of items"),
-    totalPages: import_zod2.z.number().describe("Total number of pages"),
-    nextCursor: import_zod2.z.string().optional().describe("Next page cursor (if applicable)"),
-    prevCursor: import_zod2.z.string().optional().describe("Previous page cursor (if applicable)")
-  }).optional().describe("Pagination information")
-}).optional().describe("Response metadata");
-var ErrorDetailSchema = import_zod2.z.object({
-  platform: import_zod2.z.string().optional().describe("Platform associated with the error (if applicable)"),
-  userId: import_zod2.z.string().optional().describe("User ID associated with the error (if applicable)"),
-  status: import_zod2.z.literal("error").describe("Error status"),
-  error: import_zod2.z.string().describe("Human-readable error message"),
-  errorCode: import_zod2.z.string().describe("Machine-readable error code"),
-  recoverable: import_zod2.z.boolean().describe("Whether the error is recoverable (can be retried)"),
-  details: import_zod2.z.record(import_zod2.z.any()).optional().describe("Additional error details (platform-specific)")
-}).describe("Error detail");
-var EnhancedErrorResponseSchema = import_zod2.z.object({
-  success: import_zod2.z.literal(false).describe("Success indicator (always false for error responses)"),
-  errors: import_zod2.z.array(ErrorDetailSchema).describe("Error information")
-}).describe("Enhanced error response");
-var SuccessDetailSchema = import_zod2.z.object({
-  platform: import_zod2.z.string().describe("Platform associated with the success"),
-  userId: import_zod2.z.string().describe("User ID associated with the success"),
-  status: import_zod2.z.literal("success").describe("Success status"),
-  postId: import_zod2.z.string().optional().describe("Post ID (if applicable)"),
-  postUrl: import_zod2.z.string().optional().describe("Post URL (if applicable)")
-}).catchall(import_zod2.z.any()).describe("Success detail");
-var MultiStatusResponseSchema = import_zod2.z.object({
-  success: import_zod2.z.boolean().describe("Success indicator (true if at least one operation succeeded)"),
-  data: import_zod2.z.object({
-    summary: import_zod2.z.object({
-      total: import_zod2.z.number().describe("Total number of operations"),
-      succeeded: import_zod2.z.number().describe("Number of successful operations"),
-      failed: import_zod2.z.number().describe("Number of failed operations")
-    }).describe("Summary of operations"),
-    results: import_zod2.z.array(SuccessDetailSchema).describe("Successful results"),
-    errors: import_zod2.z.array(ErrorDetailSchema).describe("Failed results")
-  }).describe("Response data")
-}).describe("Multi-status response");
-function EnhancedResponseSchema(schema) {
-  return import_zod2.z.object({
-    success: import_zod2.z.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);
-    }
-  }
-};
+var import_zod3 = require("zod");
 
-// src/errors/api-error.ts
+// src/errors.ts
+var import_zod2 = require("zod");
 var ApiErrorCode = /* @__PURE__ */ ((ApiErrorCode2) => {
   ApiErrorCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
   ApiErrorCode2["INTERNAL_ERROR"] = "INTERNAL_ERROR";
@@ -308,472 +132,378 @@ var ApiErrorCode = /* @__PURE__ */ ((ApiErrorCode2) => {
   ApiErrorCode2["CONTENT_POLICY_VIOLATION"] = "CONTENT_POLICY_VIOLATION";
   ApiErrorCode2["DUPLICATE_CONTENT"] = "DUPLICATE_CONTENT";
   ApiErrorCode2["MEDIA_UPLOAD_FAILED"] = "MEDIA_UPLOAD_FAILED";
+  ApiErrorCode2["MULTI_STATUS"] = "MULTI_STATUS";
   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";
-  ApiErrorCode2["MULTI_STATUS"] = "MULTI_STATUS";
   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;
-  }
+var ApiErrorCodeSchema = import_zod2.z.enum(Object.values(ApiErrorCode));
+var errorCodeToStatusCode = {
+  ["MULTI_STATUS" /* MULTI_STATUS */]: 207,
+  ["UNKNOWN_ERROR" /* UNKNOWN_ERROR */]: 500,
+  ["INTERNAL_ERROR" /* INTERNAL_ERROR */]: 500,
+  ["VALIDATION_ERROR" /* VALIDATION_ERROR */]: 400,
+  ["INVALID_REQUEST" /* INVALID_REQUEST */]: 400,
+  ["NOT_FOUND" /* NOT_FOUND */]: 404,
+  ["UNAUTHORIZED" /* UNAUTHORIZED */]: 401,
+  ["FORBIDDEN" /* FORBIDDEN */]: 403,
+  ["RATE_LIMITED" /* RATE_LIMITED */]: 429,
+  ["PLATFORM_ERROR" /* PLATFORM_ERROR */]: 502,
+  ["PLATFORM_UNAVAILABLE" /* PLATFORM_UNAVAILABLE */]: 503,
+  ["CONTENT_POLICY_VIOLATION" /* CONTENT_POLICY_VIOLATION */]: 400,
+  ["DUPLICATE_CONTENT" /* DUPLICATE_CONTENT */]: 400,
+  ["MEDIA_UPLOAD_FAILED" /* MEDIA_UPLOAD_FAILED */]: 400,
+  ["POST_CREATION_FAILED" /* POST_CREATION_FAILED */]: 500,
+  ["THREAD_CREATION_FAILED" /* THREAD_CREATION_FAILED */]: 500,
+  ["POST_DELETION_FAILED" /* POST_DELETION_FAILED */]: 500,
+  ["POST_INTERACTION_FAILED" /* POST_INTERACTION_FAILED */]: 500,
+  ["NETWORK_ERROR" /* NETWORK_ERROR */]: 503
 };
+var ErrorDetailSchema = import_zod2.z.object({
+  message: import_zod2.z.string().describe("Human-readable error message"),
+  code: ApiErrorCodeSchema.describe("Machine-readable error code"),
+  recoverable: import_zod2.z.boolean().describe("Whether the error can be recovered from"),
+  details: import_zod2.z.record(import_zod2.z.unknown()).optional().describe("Additional error details")
+});
 
-// src/errors/composite-api-error.ts
-var CompositeApiError = class extends ApiError {
-  constructor(message, errors, status = 207, details, recoverable = false) {
-    super(
-      message,
-      "MULTI_STATUS" /* MULTI_STATUS */,
-      status,
-      { ...details, errors },
-      recoverable
-    );
-    this.errors = errors;
-  }
-};
+// src/response.ts
+var ResponseMetaSchema = import_zod3.z.object({
+  requestId: import_zod3.z.string().uuid().describe("Unique identifier for the request"),
+  timestamp: import_zod3.z.string().datetime().describe("ISO timestamp of response generation"),
+  rateLimit: import_zod3.z.object({
+    remaining: import_zod3.z.number().int().nonnegative(),
+    limit: import_zod3.z.number().int().positive(),
+    reset: import_zod3.z.number().int().positive().describe("Unix timestamp (seconds)")
+  }).optional().describe("Rate limit information if applicable"),
+  pagination: import_zod3.z.object({
+    page: import_zod3.z.number().int().positive().optional(),
+    perPage: import_zod3.z.number().int().positive().optional(),
+    total: import_zod3.z.number().int().nonnegative().optional(),
+    limit: import_zod3.z.number().int().nonnegative().optional(),
+    offset: import_zod3.z.number().int().nonnegative().optional(),
+    totalPages: import_zod3.z.number().int().nonnegative().optional(),
+    nextCursor: import_zod3.z.string().optional(),
+    prevCursor: import_zod3.z.string().optional()
+  }).optional().describe("Pagination information if applicable")
+});
+var SuccessDetailSchema = import_zod3.z.object({
+  platform: import_zod3.z.string(),
+  userId: import_zod3.z.string(),
+  additionalData: import_zod3.z.any().optional(),
+  status: import_zod3.z.literal("success")
+}).catchall(import_zod3.z.any());
+var MultiStatusDataSchema = import_zod3.z.object({
+  summary: import_zod3.z.object({
+    total: import_zod3.z.number().int().nonnegative(),
+    succeeded: import_zod3.z.number().int().nonnegative(),
+    failed: import_zod3.z.number().int().nonnegative()
+  }),
+  results: import_zod3.z.array(SuccessDetailSchema),
+  errors: import_zod3.z.array(ErrorDetailSchema)
+});
 
 // src/auth.ts
-var import_zod3 = require("zod");
-var PlatformParamSchema = import_zod3.z.object({
-  platform: import_zod3.z.string().describe("Social media platform")
+var import_zod4 = require("zod");
+var PlatformParamSchema = import_zod4.z.object({
+  platform: import_zod4.z.string().describe("Social media platform")
 }).describe("Platform parameter");
-var AuthInitRequestSchema = import_zod3.z.object({
-  successUrl: import_zod3.z.string().url().optional().describe(
+var AuthInitRequestSchema = import_zod4.z.object({
+  successUrl: import_zod4.z.string().url().optional().describe(
     "URL to redirect to on successful authentication"
   ),
-  errorUrl: import_zod3.z.string().url().optional().describe("URL to redirect to on authentication error")
+  errorUrl: import_zod4.z.string().url().optional().describe("URL to redirect to on authentication error")
 }).describe("Auth initialization request");
-var AuthUrlResponseSchema = EnhancedResponseSchema(
-  import_zod3.z.object({
-    url: import_zod3.z.string().describe("Authentication URL to redirect the user to"),
-    state: import_zod3.z.string().describe("State parameter for CSRF protection"),
-    platform: PlatformSchema
-  })
-).describe("Auth URL response");
-var AuthCallbackQuerySchema = import_zod3.z.object({
-  code: import_zod3.z.string().describe("Authorization code from OAuth provider"),
-  state: import_zod3.z.string().describe("State parameter for CSRF protection")
+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
+}).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")
 }).describe("Auth callback query");
-var AuthCallbackResponseSchema = EnhancedResponseSchema(
-  import_zod3.z.object({
-    success: import_zod3.z.boolean().describe("Whether the authentication was successful"),
-    platform: PlatformSchema,
-    userId: import_zod3.z.string().describe("User ID"),
-    redirectUrl: import_zod3.z.string().optional().describe("URL to redirect the user to after authentication")
-  })
-).describe("Auth callback response");
-var AuthStatusResponseSchema = EnhancedResponseSchema(
-  import_zod3.z.object({
-    platform: PlatformSchema,
-    userId: import_zod3.z.string().describe("User ID"),
-    authenticated: import_zod3.z.boolean().describe("Whether the user is authenticated"),
-    tokenStatus: import_zod3.z.object({
-      valid: import_zod3.z.boolean().describe("Whether the token is valid"),
-      expired: import_zod3.z.boolean().describe("Whether the token is expired"),
-      expiresAt: import_zod3.z.string().optional().describe("When the token expires")
-    })
-  })
-).describe("Auth status response");
-var AuthRevokeResponseSchema = EnhancedResponseSchema(
-  import_zod3.z.object({
-    success: import_zod3.z.boolean().describe("Whether the revocation was successful"),
-    platform: PlatformSchema,
-    userId: import_zod3.z.string().describe("User ID")
+var AuthCallbackResponseSchema = import_zod4.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")
+}).describe("Auth callback response");
+var AuthStatusResponseSchema = import_zod4.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")
   })
-).describe("Auth revoke response");
-var ConnectedAccountSchema = import_zod3.z.object({
+}).describe("Auth status response");
+var AuthTokenRequestSchema = import_zod4.z.object({
+  userId: import_zod4.z.string().describe("User ID on the platform")
+}).describe("Auth token request");
+var AuthRevokeResponseSchema = import_zod4.z.object({
+  platform: PlatformSchema,
+  userId: import_zod4.z.string().describe("User ID")
+}).describe("Auth revoke response");
+var ConnectedAccountSchema = import_zod4.z.object({
   platform: PlatformSchema,
-  userId: import_zod3.z.string().describe("User ID on the platform"),
-  username: import_zod3.z.string().optional().describe("Username on the platform (if available)"),
-  profileUrl: import_zod3.z.string().optional().describe("URL to the user profile"),
-  connectedAt: import_zod3.z.string().optional().describe("When the account was connected")
+  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")
 }).describe("Connected account");
-var ConnectedAccountsResponseSchema = EnhancedResponseSchema(
-  import_zod3.z.array(ConnectedAccountSchema)
-).describe("Connected accounts response");
-var NearAuthorizationRequestSchema = import_zod3.z.object({
+var ConnectedAccountsResponseSchema = import_zod4.z.array(ConnectedAccountSchema).describe(
+  "Connected accounts response"
+);
+var NearAuthorizationRequestSchema = import_zod4.z.object({
   // No additional parameters needed, as the NEAR account ID is extracted from the signature
 }).describe("NEAR authorization request");
-var NearAuthorizationResponseSchema = EnhancedResponseSchema(
-  import_zod3.z.object({
-    success: import_zod3.z.boolean().describe("Whether the authorization was successful"),
-    nearAccount: import_zod3.z.string().describe("NEAR account ID"),
-    authorized: import_zod3.z.boolean().describe("Whether the account is authorized")
-  })
-).describe("NEAR authorization response");
-var NearAuthorizationStatusResponseSchema = EnhancedResponseSchema(
-  import_zod3.z.object({
-    nearAccount: import_zod3.z.string().describe("NEAR account ID"),
-    authorized: import_zod3.z.boolean().describe("Whether the account is authorized"),
-    authorizedAt: import_zod3.z.string().optional().describe("When the account was authorized")
-  })
-).describe("NEAR authorization status response");
+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")
+}).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")
+}).describe("NEAR authorization status response");
 
 // src/post.ts
-var import_zod4 = require("zod");
-var MediaContentSchema = import_zod4.z.object({
-  data: import_zod4.z.union([import_zod4.z.string(), import_zod4.z.instanceof(Blob)]).describe("Media data as string or Blob"),
-  mimeType: import_zod4.z.string().optional().describe("Media MIME type"),
-  altText: import_zod4.z.string().optional().describe("Alt text for the media")
+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")
 }).describe("Media content object");
-var MediaSchema = import_zod4.z.object({
-  id: import_zod4.z.string().describe("Media ID"),
-  type: import_zod4.z.enum(["image", "video", "gif"]).describe("Media type"),
-  url: import_zod4.z.string().optional().describe("Media URL"),
-  altText: import_zod4.z.string().optional().describe("Alt text for the media")
+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")
 }).describe("Media object");
-var PostMetricsSchema = import_zod4.z.object({
-  retweets: import_zod4.z.number().describe("Number of retweets"),
-  quotes: import_zod4.z.number().describe("Number of quotes"),
-  likes: import_zod4.z.number().describe("Number of likes"),
-  replies: import_zod4.z.number().describe("Number of replies")
+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")
 }).describe("Post metrics");
-var PostSchema = import_zod4.z.object({
-  id: import_zod4.z.string().describe("Post ID"),
-  text: import_zod4.z.string().describe("Post text content"),
-  createdAt: import_zod4.z.string().describe("Post creation date"),
-  authorId: import_zod4.z.string().describe("Author ID"),
-  media: import_zod4.z.array(MediaSchema).optional().describe("Media attached to the post"),
+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"),
   metrics: PostMetricsSchema.optional().describe("Post metrics"),
-  inReplyToId: import_zod4.z.string().optional().describe("ID of the post this is a reply to"),
-  quotedPostId: import_zod4.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"),
+  quotedPostId: import_zod5.z.string().optional().describe("ID of the post this is quoting")
 }).describe("Post object");
-var PostContentSchema = import_zod4.z.object({
-  text: import_zod4.z.string().optional().describe("Text content for the post"),
-  media: import_zod4.z.array(MediaContentSchema).optional().describe("Media attachments for the post")
+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")
 }).describe("Post content");
-var PostResultSchema = import_zod4.z.object({
-  id: import_zod4.z.string().describe("Post ID"),
-  text: import_zod4.z.string().optional().describe("Post text content"),
-  createdAt: import_zod4.z.string().describe("Post creation date"),
-  mediaIds: import_zod4.z.array(import_zod4.z.string()).optional().describe("Media IDs attached to the post"),
-  threadIds: import_zod4.z.array(import_zod4.z.string()).optional().describe("Thread IDs for threaded posts"),
-  quotedPostId: import_zod4.z.string().optional().describe("ID of the post this is quoting"),
-  inReplyToId: import_zod4.z.string().optional().describe("ID of the post this is a reply to"),
-  success: import_zod4.z.boolean().optional().describe("Whether the operation was successful")
-}).catchall(import_zod4.z.any()).describe("Post result");
-var DeleteResultSchema = import_zod4.z.object({
-  success: import_zod4.z.boolean().describe("Whether the deletion was successful"),
-  id: import_zod4.z.string().describe("ID of the deleted post")
+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")
 }).describe("Delete result");
-var LikeResultSchema = import_zod4.z.object({
-  success: import_zod4.z.boolean().describe("Whether the like was successful"),
-  id: import_zod4.z.string().describe("ID of the liked post")
+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")
 }).describe("Like result");
-var PostSuccessDetailSchema = import_zod4.z.object({
+var PostSuccessDetailSchema = import_zod5.z.object({
   platform: PlatformSchema,
-  userId: import_zod4.z.string().describe("User ID"),
-  status: import_zod4.z.literal("success"),
-  postId: import_zod4.z.string().optional().describe("Post ID"),
-  postUrl: import_zod4.z.string().optional().describe("URL to the post")
-}).catchall(import_zod4.z.any()).describe("Post success detail");
-var TargetSchema = import_zod4.z.object({
+  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({
   platform: PlatformSchema.describe('The platform to post to (e.g., "twitter")'),
-  userId: import_zod4.z.string().describe("User ID on the platform")
+  userId: import_zod5.z.string().describe("User ID on the platform")
 }).describe("Target for posting operations");
-var CreatePostRequestSchema = import_zod4.z.object({
-  targets: import_zod4.z.array(TargetSchema).describe("Array of targets to post to (can be a single target)"),
-  content: import_zod4.z.array(PostContentSchema).describe(
+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(
     "The content of the post, always an array of PostContent objects, even for a single post"
   )
 }).describe("Create post request");
-var RepostRequestSchema = import_zod4.z.object({
-  targets: import_zod4.z.array(TargetSchema).describe("Array of targets to post to"),
+var RepostRequestSchema = import_zod5.z.object({
+  targets: import_zod5.z.array(TargetSchema).describe("Array of targets to post to"),
   platform: PlatformSchema.describe("Platform of the post being reposted"),
-  postId: import_zod4.z.string().describe("ID of the post to repost")
+  postId: import_zod5.z.string().describe("ID of the post to repost")
 }).describe("Repost request");
-var QuotePostRequestSchema = import_zod4.z.object({
-  targets: import_zod4.z.array(TargetSchema).describe(
+var QuotePostRequestSchema = import_zod5.z.object({
+  targets: import_zod5.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_zod4.z.string().describe("ID of the post to quote"),
-  content: import_zod4.z.array(PostContentSchema).describe(
+  postId: import_zod5.z.string().describe("ID of the post to quote"),
+  content: import_zod5.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_zod4.z.object({
-  targets: import_zod4.z.array(TargetSchema).describe(
+var ReplyToPostRequestSchema = import_zod5.z.object({
+  targets: import_zod5.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_zod4.z.string().describe("ID of the post to reply to"),
-  content: import_zod4.z.array(PostContentSchema).describe(
+  postId: import_zod5.z.string().describe("ID of the post to reply to"),
+  content: import_zod5.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_zod4.z.object({
+var PostToDeleteSchema = import_zod5.z.object({
   platform: PlatformSchema.describe("Platform of the post to delete"),
-  userId: import_zod4.z.string().describe("User ID on the platform"),
-  postId: import_zod4.z.string().describe("ID 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")
 }).describe("Post to delete");
-var DeletePostRequestSchema = import_zod4.z.object({
-  targets: import_zod4.z.array(TargetSchema).describe("Array of targets to delete posts"),
-  posts: import_zod4.z.array(PostToDeleteSchema).describe("Array of posts 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")
 }).describe("Delete post request");
-var LikePostRequestSchema = import_zod4.z.object({
-  targets: import_zod4.z.array(TargetSchema).describe(
+var LikePostRequestSchema = import_zod5.z.object({
+  targets: import_zod5.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_zod4.z.string().describe("ID of the post to like")
+  postId: import_zod5.z.string().describe("ID of the post to like")
 }).describe("Like post request");
-var UnlikePostRequestSchema = import_zod4.z.object({
-  targets: import_zod4.z.array(TargetSchema).describe(
+var UnlikePostRequestSchema = import_zod5.z.object({
+  targets: import_zod5.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_zod4.z.string().describe("ID of the post to unlike")
+  postId: import_zod5.z.string().describe("ID of the post to unlike")
 }).describe("Unlike post request");
-var PostResponseSchema = EnhancedResponseSchema(
-  import_zod4.z.union([PostSchema, import_zod4.z.array(PostSchema)])
-).describe("Post response");
-var CreatePostResponseLegacySchema = PostResponseSchema.describe(
-  "Create post response (legacy)"
+var PostResponseSchema = import_zod5.z.union([PostSchema, import_zod5.z.array(PostSchema)]).describe(
+  "Post response"
+);
+var CreatePostResponseSchema = PostResponseSchema.describe(
+  "Create post response"
 );
 var RepostResponseSchema = PostResponseSchema.describe("Repost response");
 var QuotePostResponseSchema = PostResponseSchema.describe("Quote post response");
 var ReplyToPostResponseSchema = PostResponseSchema.describe("Reply to post response");
-var DeletePostResponseSchema = EnhancedResponseSchema(
-  import_zod4.z.object({
-    success: import_zod4.z.boolean().describe("Whether the deletion was successful"),
-    id: import_zod4.z.string().describe("ID of the deleted post")
-  })
-).describe("Delete post response");
-var LikePostResponseSchema = EnhancedResponseSchema(
-  import_zod4.z.object({
-    success: import_zod4.z.boolean().describe("Whether the like was successful"),
-    id: import_zod4.z.string().describe("ID of the liked post")
-  })
-).describe("Like post response");
-var UnlikePostResponseSchema = EnhancedResponseSchema(
-  import_zod4.z.object({
-    success: import_zod4.z.boolean().describe("Whether the unlike was successful"),
-    id: import_zod4.z.string().describe("ID of the unliked post")
-  })
-).describe("Unlike post response");
-var PostMultiStatusResponseSchema = import_zod4.z.object({
-  success: import_zod4.z.boolean().describe("Whether the operation was partially or fully successful"),
-  data: import_zod4.z.object({
-    summary: import_zod4.z.object({
-      total: import_zod4.z.number().describe("Total number of operations"),
-      succeeded: import_zod4.z.number().describe("Number of successful operations"),
-      failed: import_zod4.z.number().describe("Number of failed operations")
-    }),
-    results: import_zod4.z.array(PostSuccessDetailSchema).describe("Successful operations"),
-    errors: import_zod4.z.array(ErrorDetailSchema).describe("Failed operations")
-  })
+var DeletePostResponseSchema = import_zod5.z.object({
+  id: import_zod5.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")
+}).describe("Like post response");
+var UnlikePostResponseSchema = import_zod5.z.object({
+  id: import_zod5.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")
+  }),
+  results: import_zod5.z.array(PostSuccessDetailSchema).describe("Successful operations"),
+  errors: import_zod5.z.array(ErrorDetailSchema).describe("Failed operations")
 }).describe("Multi-status response for post operations");
-var CreatePostTargetResultSchema = import_zod4.z.object({
-  platform: PlatformSchema.describe("The platform the post was created on"),
-  userId: import_zod4.z.string().describe("The user ID on the platform"),
-  result: import_zod4.z.array(import_zod4.z.any()).describe("The result of the post creation")
-}).describe("Create post target result");
-var CreatePostTargetErrorSchema = import_zod4.z.object({
-  platform: PlatformSchema.optional().describe(
-    "The platform where the error occurred (if applicable)"
-  ),
-  userId: import_zod4.z.string().optional().describe("The user ID where the error occurred (if applicable)"),
-  error: import_zod4.z.string().describe("The error message")
-}).describe("Create post target error");
-var CreatePostResponseSchema = EnhancedResponseSchema(
-  import_zod4.z.object({
-    results: import_zod4.z.array(CreatePostTargetResultSchema).describe("Array of successful post results"),
-    errors: import_zod4.z.array(CreatePostTargetErrorSchema).optional().describe(
-      "Array of errors that occurred (if any)"
-    )
-  })
-).describe("Create post response");
 
 // src/rate-limit.ts
-var import_zod5 = require("zod");
-var RateLimitEndpointParamSchema = import_zod5.z.object({
-  endpoint: import_zod5.z.string().optional().describe(
+var import_zod6 = require("zod");
+var RateLimitEndpointParamSchema = import_zod6.z.object({
+  endpoint: import_zod6.z.string().optional().describe(
     "Specific endpoint to get rate limit information for (optional)"
   )
 }).describe("Rate limit endpoint parameter");
-var RateLimitEndpointSchema = import_zod5.z.object({
-  endpoint: import_zod5.z.string().describe("API endpoint"),
-  method: import_zod5.z.enum(["GET", "POST", "PUT", "DELETE"]).describe("HTTP method"),
-  limit: import_zod5.z.number().describe("Rate limit"),
-  remaining: import_zod5.z.number().describe("Remaining requests"),
-  reset: import_zod5.z.number().describe("Reset timestamp (Unix timestamp in seconds)"),
-  resetDate: import_zod5.z.string().describe("Reset date (ISO string)")
+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)")
 }).describe("Rate limit endpoint");
-var RateLimitStatusSchema = import_zod5.z.object({
-  endpoint: import_zod5.z.string().describe("API endpoint or action"),
-  limit: import_zod5.z.number().describe("Maximum number of requests allowed in the time window"),
-  remaining: import_zod5.z.number().describe("Number of requests remaining in the current time window"),
-  reset: import_zod5.z.string().datetime().describe("Timestamp when the rate limit will reset"),
-  resetSeconds: import_zod5.z.number().describe("Seconds until the rate limit will reset")
+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")
 }).describe("Rate limit status");
-var PlatformRateLimitSchema = import_zod5.z.object({
+var PlatformRateLimitSchema = import_zod6.z.object({
   platform: PlatformSchema,
-  endpoints: import_zod5.z.record(import_zod5.z.string(), RateLimitStatusSchema).describe(
+  endpoints: import_zod6.z.record(import_zod6.z.string(), RateLimitStatusSchema).describe(
     "Rate limit status for each endpoint"
   )
 }).describe("Platform-specific rate limit");
-var UsageRateLimitSchema = import_zod5.z.object({
-  endpoint: import_zod5.z.string().describe("API endpoint or action"),
-  limit: import_zod5.z.number().describe("Maximum number of requests allowed in the time window"),
-  remaining: import_zod5.z.number().describe("Number of requests remaining in the current time window"),
-  reset: import_zod5.z.string().datetime().describe("Timestamp when the rate limit will reset"),
-  resetSeconds: import_zod5.z.number().describe("Seconds until the rate limit will reset"),
-  timeWindow: import_zod5.z.string().describe("Time window for the 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")
 }).describe("Usage rate limit");
-var RateLimitStatusResponseSchema = EnhancedResponseSchema(
-  import_zod5.z.object({
-    platform: PlatformSchema,
-    userId: import_zod5.z.string().optional().describe("User ID"),
-    endpoints: import_zod5.z.array(RateLimitEndpointSchema).describe("Rate limits for specific endpoints"),
-    app: import_zod5.z.object({
-      limit: import_zod5.z.number().describe("App-wide rate limit"),
-      remaining: import_zod5.z.number().describe("Remaining requests"),
-      reset: import_zod5.z.number().describe("Reset timestamp (Unix timestamp in seconds)"),
-      resetDate: import_zod5.z.string().describe("Reset date (ISO string)")
-    }).optional().describe("App-wide rate limits")
-  })
-).describe("Rate limit status response");
-var AllRateLimitsResponseSchema = EnhancedResponseSchema(
-  import_zod5.z.object({
-    platforms: import_zod5.z.record(
-      PlatformSchema,
-      import_zod5.z.object({
-        users: import_zod5.z.record(
-          import_zod5.z.string(),
-          import_zod5.z.object({
-            endpoints: import_zod5.z.array(RateLimitEndpointSchema).describe(
-              "Rate limits for specific endpoints"
-            ),
-            lastUpdated: import_zod5.z.string().describe("Last updated date (ISO string)")
-          })
-        ).describe("User-specific rate limits"),
-        app: import_zod5.z.object({
-          limit: import_zod5.z.number().describe("App-wide rate limit"),
-          remaining: import_zod5.z.number().describe("Remaining requests"),
-          reset: import_zod5.z.number().describe("Reset timestamp (Unix timestamp in seconds)"),
-          resetDate: import_zod5.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_zod5.z.object({
-  platformLimits: import_zod5.z.array(PlatformRateLimitSchema).describe("Platform-specific rate limits"),
-  usageLimits: import_zod5.z.record(import_zod5.z.string(), UsageRateLimitSchema).describe(
+var RateLimitStatusResponseSchema = import_zod6.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)")
+  }).optional().describe("App-wide rate limits")
+}).describe("Rate limit status response");
+var AllRateLimitsResponseSchema = import_zod6.z.object({
+  platforms: import_zod6.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(
+            "Rate limits for specific endpoints"
+          ),
+          lastUpdated: import_zod6.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)")
+      }).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(
     "Usage-based rate limits for the NEAR account"
   ),
-  signerId: import_zod5.z.string().describe("NEAR account ID")
+  signerId: import_zod6.z.string().describe("NEAR account ID")
 }).describe("Rate limit response");
-var EndpointRateLimitResponseSchema = import_zod5.z.object({
-  platformLimits: import_zod5.z.array(
-    import_zod5.z.object({
+var EndpointRateLimitResponseSchema = import_zod6.z.object({
+  platformLimits: import_zod6.z.array(
+    import_zod6.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_zod5.z.string().describe("API endpoint or action"),
-  signerId: import_zod5.z.string().describe("NEAR account ID")
+  endpoint: import_zod6.z.string().describe("API endpoint or action"),
+  signerId: import_zod6.z.string().describe("NEAR account ID")
 }).describe("Endpoint rate limit response");
 
 // src/activity.ts
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 var TimePeriod = /* @__PURE__ */ ((TimePeriod2) => {
   TimePeriod2["ALL"] = "all";
   TimePeriod2["YEARLY"] = "year";
@@ -782,179 +512,150 @@ var TimePeriod = /* @__PURE__ */ ((TimePeriod2) => {
   TimePeriod2["DAILY"] = "day";
   return TimePeriod2;
 })(TimePeriod || {});
-var ActivityLeaderboardQuerySchema = import_zod6.z.object({
-  timeframe: import_zod6.z.nativeEnum(TimePeriod).optional().describe(
+var ActivityLeaderboardQuerySchema = import_zod7.z.object({
+  timeframe: import_zod7.z.nativeEnum(TimePeriod).optional().describe(
     "Timeframe for the leaderboard"
   ),
-  limit: import_zod6.z.string().optional().transform((val) => val ? parseInt(val, 10) : void 0).pipe(import_zod6.z.number().min(1).max(100).optional()).describe("Maximum number of results to return (1-100)"),
-  offset: import_zod6.z.string().optional().transform((val) => val ? parseInt(val, 10) : void 0).pipe(import_zod6.z.number().min(0).optional()).describe("Offset for pagination")
+  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")
 }).describe("Activity leaderboard query");
-var AccountActivityEntrySchema = import_zod6.z.object({
-  signerId: import_zod6.z.string().describe("NEAR account ID"),
-  totalPosts: import_zod6.z.number().describe("Total number of posts"),
-  totalLikes: import_zod6.z.number().describe("Total number of likes"),
-  totalReposts: import_zod6.z.number().describe("Total number of reposts"),
-  totalReplies: import_zod6.z.number().describe("Total number of replies"),
-  totalQuotes: import_zod6.z.number().describe("Total number of quote posts"),
-  totalScore: import_zod6.z.number().describe("Total activity score"),
-  rank: import_zod6.z.number().describe("Rank on the leaderboard"),
-  lastActive: import_zod6.z.string().datetime().describe("Timestamp of last activity")
+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")
 }).describe("Account activity entry");
-var ActivityLeaderboardResponseSchema = EnhancedResponseSchema(
-  import_zod6.z.object({
-    timeframe: import_zod6.z.nativeEnum(TimePeriod).describe("Timeframe for the leaderboard"),
-    entries: import_zod6.z.array(AccountActivityEntrySchema).describe("Leaderboard entries"),
-    total: import_zod6.z.number().describe("Total number of entries in the leaderboard"),
-    limit: import_zod6.z.number().describe("Maximum number of results returned"),
-    offset: import_zod6.z.number().describe("Offset for pagination"),
-    generatedAt: import_zod6.z.string().datetime().describe("Timestamp when the leaderboard was generated")
-  })
-).describe("Activity leaderboard response");
-var AccountActivityParamsSchema = import_zod6.z.object({
-  signerId: import_zod6.z.string().describe("NEAR account ID")
+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"),
+  platform: PlatformSchema.optional().describe("Platform filter (if applied)")
+});
+var AccountActivityParamsSchema = import_zod7.z.object({
+  signerId: import_zod7.z.string().describe("NEAR account ID")
 }).describe("Account activity params");
-var AccountActivityQuerySchema = import_zod6.z.object({
-  timeframe: import_zod6.z.nativeEnum(TimePeriod).optional().describe(
+var AccountActivityQuerySchema = import_zod7.z.object({
+  timeframe: import_zod7.z.nativeEnum(TimePeriod).optional().describe(
     "Timeframe for the activity"
   )
 }).describe("Account activity query");
-var PlatformActivitySchema = import_zod6.z.object({
+var PlatformActivitySchema = import_zod7.z.object({
   platform: PlatformSchema,
-  posts: import_zod6.z.number().describe("Number of posts on this platform"),
-  likes: import_zod6.z.number().describe("Number of likes on this platform"),
-  reposts: import_zod6.z.number().describe("Number of reposts on this platform"),
-  replies: import_zod6.z.number().describe("Number of replies on this platform"),
-  quotes: import_zod6.z.number().describe("Number of quote posts on this platform"),
-  score: import_zod6.z.number().describe("Activity score on this platform"),
-  lastActive: import_zod6.z.string().datetime().describe("Timestamp of last activity on this platform")
+  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")
 }).describe("Platform activity");
-var AccountActivityResponseSchema = EnhancedResponseSchema(
-  import_zod6.z.object({
-    signerId: import_zod6.z.string().describe("NEAR account ID"),
-    timeframe: import_zod6.z.nativeEnum(TimePeriod).describe("Timeframe for the activity"),
-    totalPosts: import_zod6.z.number().describe("Total number of posts across all platforms"),
-    totalLikes: import_zod6.z.number().describe("Total number of likes across all platforms"),
-    totalReposts: import_zod6.z.number().describe("Total number of reposts across all platforms"),
-    totalReplies: import_zod6.z.number().describe("Total number of replies across all platforms"),
-    totalQuotes: import_zod6.z.number().describe("Total number of quote posts across all platforms"),
-    totalScore: import_zod6.z.number().describe("Total activity score across all platforms"),
-    rank: import_zod6.z.number().describe("Rank on the leaderboard"),
-    lastActive: import_zod6.z.string().datetime().describe("Timestamp of last activity across all platforms"),
-    platforms: import_zod6.z.array(PlatformActivitySchema).describe("Activity breakdown by platform")
-  })
-).describe("Account activity response");
-var AccountPostsParamsSchema = import_zod6.z.object({
-  signerId: import_zod6.z.string().describe("NEAR account ID")
+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 AccountPostsParamsSchema = import_zod7.z.object({
+  signerId: import_zod7.z.string().describe("NEAR account ID")
 }).describe("Account posts params");
-var AccountPostsQuerySchema = import_zod6.z.object({
-  platform: import_zod6.z.string().optional().describe("Filter by platform (optional)"),
-  limit: import_zod6.z.string().optional().transform((val) => val ? parseInt(val, 10) : void 0).pipe(import_zod6.z.number().min(1).max(100).optional()).describe("Maximum number of results to return (1-100)"),
-  offset: import_zod6.z.string().optional().transform((val) => val ? parseInt(val, 10) : void 0).pipe(import_zod6.z.number().min(0).optional()).describe("Offset for pagination"),
-  type: import_zod6.z.enum(["post", "repost", "reply", "quote", "like", "all"]).optional().describe(
+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(
     "Filter by post type (optional)"
   )
 }).describe("Account posts query");
-var AccountPostSchema = import_zod6.z.object({
-  id: import_zod6.z.string().describe("Post ID"),
+var AccountPostSchema = import_zod7.z.object({
+  id: import_zod7.z.string().describe("Post ID"),
   platform: PlatformSchema,
-  type: import_zod6.z.enum(["post", "repost", "reply", "quote", "like"]).describe("Type of post"),
-  content: import_zod6.z.string().optional().describe("Post content (if available)"),
-  url: import_zod6.z.string().url().optional().describe("URL to the post on the platform (if available)"),
-  createdAt: import_zod6.z.string().datetime().describe("Timestamp when the post was created"),
-  metrics: import_zod6.z.object({
-    likes: import_zod6.z.number().optional().describe("Number of likes (if available)"),
-    reposts: import_zod6.z.number().optional().describe("Number of reposts (if available)"),
-    replies: import_zod6.z.number().optional().describe("Number of replies (if available)"),
-    quotes: import_zod6.z.number().optional().describe("Number of quotes (if available)")
+  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)")
   }).optional().describe("Post metrics (if available)"),
-  inReplyToId: import_zod6.z.string().optional().describe("ID of the post this is a reply to (if applicable)"),
-  quotedPostId: import_zod6.z.string().optional().describe("ID of the post this is quoting (if applicable)")
+  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)")
 }).describe("Account post");
-var AccountPostsResponseSchema = EnhancedResponseSchema(
-  import_zod6.z.object({
-    signerId: import_zod6.z.string().describe("NEAR account ID"),
-    posts: import_zod6.z.array(AccountPostSchema).describe("List of posts"),
-    total: import_zod6.z.number().describe("Total number of posts matching the query"),
-    limit: import_zod6.z.number().describe("Maximum number of results returned"),
-    offset: import_zod6.z.number().describe("Offset for pagination"),
-    platform: import_zod6.z.string().optional().describe("Platform filter (if applied)"),
-    type: import_zod6.z.enum(["post", "repost", "reply", "quote", "like", "all"]).optional().describe(
-      "Post type filter (if applied)"
-    )
-  })
-).describe("Account posts response");
+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(
+    "Post type filter (if applied)"
+  )
+});
 
 // src/user-profile.ts
-var import_zod7 = require("zod");
-var UserProfileSchema = import_zod7.z.object({
-  userId: import_zod7.z.string().describe("User ID on the platform"),
-  username: import_zod7.z.string().describe("Username on the platform"),
-  url: import_zod7.z.string().url().optional().describe("URL to the user profile"),
-  profileImageUrl: import_zod7.z.string().describe("URL to the user profile image"),
-  isPremium: import_zod7.z.boolean().optional().describe("Whether the user has a premium account"),
+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_zod7.z.number().describe("Timestamp when the profile was last updated")
+  lastUpdated: import_zod8.z.number().describe("Timestamp when the profile was last updated")
 }).describe("User profile");
-var ProfileRefreshResultSchema = import_zod7.z.object({
-  success: import_zod7.z.boolean().describe("Whether the profile refresh was successful"),
-  profile: UserProfileSchema.optional().describe("The refreshed user profile (if successful)"),
-  error: import_zod7.z.string().optional().describe("Error message (if unsuccessful)")
-}).describe("Profile refresh result");
-var ProfileRefreshResponseSchema = EnhancedResponseSchema(
-  ProfileRefreshResultSchema
-).describe("Profile refresh response");
+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,
   AccountActivityParamsSchema,
   AccountActivityQuerySchema,
-  AccountActivityResponseSchema,
   AccountPostSchema,
   AccountPostsParamsSchema,
   AccountPostsQuerySchema,
-  AccountPostsResponseSchema,
   ActivityLeaderboardQuerySchema,
-  ActivityLeaderboardResponseSchema,
   AllRateLimitsResponseSchema,
-  ApiError,
   ApiErrorCode,
-  ApiResponseSchema,
+  ApiErrorCodeSchema,
   AuthCallbackQuerySchema,
   AuthCallbackResponseSchema,
   AuthInitRequestSchema,
   AuthRevokeResponseSchema,
   AuthStatusResponseSchema,
+  AuthTokenRequestSchema,
   AuthUrlResponseSchema,
-  BaseError,
-  CompositeApiError,
   ConnectedAccountSchema,
   ConnectedAccountsResponseSchema,
   CreatePostRequestSchema,
-  CreatePostResponseLegacySchema,
   CreatePostResponseSchema,
-  CreatePostTargetErrorSchema,
-  CreatePostTargetResultSchema,
   DeletePostRequestSchema,
   DeletePostResponseSchema,
   DeleteResultSchema,
   EndpointRateLimitResponseSchema,
-  EnhancedErrorResponseSchema,
-  EnhancedResponseMetaSchema,
-  EnhancedResponseSchema,
   ErrorDetailSchema,
-  ErrorResponseSchema,
   LikePostRequestSchema,
   LikePostResponseSchema,
   LikeResultSchema,
   MediaContentSchema,
   MediaSchema,
-  MultiStatusResponseSchema,
+  MultiStatusDataSchema,
   NearAuthorizationRequestSchema,
   NearAuthorizationResponseSchema,
   NearAuthorizationStatusResponseSchema,
   Platform,
   PlatformActivitySchema,
-  PlatformError,
   PlatformParamSchema,
   PlatformRateLimitSchema,
   PlatformSchema,
@@ -967,7 +668,6 @@ var ProfileRefreshResponseSchema = EnhancedResponseSchema(
   PostSuccessDetailSchema,
   PostToDeleteSchema,
   ProfileRefreshResponseSchema,
-  ProfileRefreshResultSchema,
   QuotePostRequestSchema,
   QuotePostResponseSchema,
   RateLimitEndpointParamSchema,
@@ -979,6 +679,7 @@ var ProfileRefreshResponseSchema = EnhancedResponseSchema(
   ReplyToPostResponseSchema,
   RepostRequestSchema,
   RepostResponseSchema,
+  ResponseMetaSchema,
   SUPPORTED_PLATFORMS,
   SuccessDetailSchema,
   SupportedPlatformSchema,
@@ -988,12 +689,6 @@ var ProfileRefreshResponseSchema = EnhancedResponseSchema(
   UnlikePostResponseSchema,
   UsageRateLimitSchema,
   UserProfileSchema,
-  createApiResponse,
-  createEnhancedApiResponse,
-  createEnhancedErrorResponse,
-  createErrorDetail,
-  createErrorResponse,
-  createMultiStatusResponse,
-  createSuccessDetail,
+  errorCodeToStatusCode,
   isPlatformSupported
 });