@crosspost/sdk 0.1.5 → 0.1.7

package/dist/index.js

@@ -4075,162 +4075,6 @@ SupportedPlatformSchema.describe("Currently supported social media platforms");
 function isPlatformSupported(platform) {
   return SUPPORTED_PLATFORMS.includes(platform);
 }
-var ApiResponseSchema = z.object({
-  data: z.any().describe("Response data"),
-  meta: z.object({
-    rateLimit: z.object({
-      remaining: z.number().describe("Number of requests remaining in the current window"),
-      limit: z.number().describe("Total number of requests allowed in the window"),
-      reset: z.number().describe("Timestamp when the rate limit resets (in seconds since epoch)")
-    }).optional().describe("Rate limit information"),
-    pagination: z.object({
-      page: z.number().describe("Current page number"),
-      perPage: z.number().describe("Number of items per page"),
-      total: z.number().describe("Total number of items"),
-      totalPages: z.number().describe("Total number of pages"),
-      nextCursor: z.string().optional().describe("Next page cursor (if applicable)"),
-      prevCursor: z.string().optional().describe("Previous page cursor (if applicable)")
-    }).optional().describe("Pagination information")
-  }).optional().describe("Response metadata")
-}).describe("Standard API response");
-var ErrorResponseSchema = z.object({
-  error: z.object({
-    type: z.string().describe("Error type"),
-    message: z.string().describe("Error message"),
-    code: z.string().optional().describe("Error code (if applicable)"),
-    details: z.any().optional().describe("Additional error details")
-  }).describe("Error information")
-}).describe("Error response");
-var EnhancedResponseMetaSchema = z.object({
-  requestId: z.string().optional().describe("Unique request identifier"),
-  timestamp: z.string().optional().describe("Request timestamp"),
-  rateLimit: z.object({
-    remaining: z.number().describe("Number of requests remaining in the current window"),
-    limit: z.number().describe("Total number of requests allowed in the window"),
-    reset: z.number().describe("Timestamp when the rate limit resets (in seconds since epoch)")
-  }).optional().describe("Rate limit information"),
-  pagination: z.object({
-    page: z.number().describe("Current page number"),
-    perPage: z.number().describe("Number of items per page"),
-    total: z.number().describe("Total number of items"),
-    totalPages: z.number().describe("Total number of pages"),
-    nextCursor: z.string().optional().describe("Next page cursor (if applicable)"),
-    prevCursor: z.string().optional().describe("Previous page cursor (if applicable)")
-  }).optional().describe("Pagination information")
-}).optional().describe("Response metadata");
-var ErrorDetailSchema = z.object({
-  platform: z.string().optional().describe("Platform associated with the error (if applicable)"),
-  userId: z.string().optional().describe("User ID associated with the error (if applicable)"),
-  status: z.literal("error").describe("Error status"),
-  error: z.string().describe("Human-readable error message"),
-  errorCode: z.string().describe("Machine-readable error code"),
-  recoverable: z.boolean().describe("Whether the error is recoverable (can be retried)"),
-  details: z.record(z.any()).optional().describe("Additional error details (platform-specific)")
-}).describe("Error detail");
-var EnhancedErrorResponseSchema = z.object({
-  success: z.literal(false).describe("Success indicator (always false for error responses)"),
-  errors: z.array(ErrorDetailSchema).describe("Error information")
-}).describe("Enhanced error response");
-var SuccessDetailSchema = z.object({
-  platform: z.string().describe("Platform associated with the success"),
-  userId: z.string().describe("User ID associated with the success"),
-  status: z.literal("success").describe("Success status"),
-  postId: z.string().optional().describe("Post ID (if applicable)"),
-  postUrl: z.string().optional().describe("Post URL (if applicable)")
-}).catchall(z.any()).describe("Success detail");
-var MultiStatusResponseSchema = z.object({
-  success: z.boolean().describe("Success indicator (true if at least one operation succeeded)"),
-  data: z.object({
-    summary: z.object({
-      total: z.number().describe("Total number of operations"),
-      succeeded: z.number().describe("Number of successful operations"),
-      failed: z.number().describe("Number of failed operations")
-    }).describe("Summary of operations"),
-    results: z.array(SuccessDetailSchema).describe("Successful results"),
-    errors: z.array(ErrorDetailSchema).describe("Failed results")
-  }).describe("Response data")
-}).describe("Multi-status response");
-function EnhancedResponseSchema(schema) {
-  return z.object({
-    success: 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
-    }
-  };
-}
-var BaseError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = this.constructor.name;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor);
-    }
-  }
-};
 var ApiErrorCode = /* @__PURE__ */ ((ApiErrorCode2) => {
   ApiErrorCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
   ApiErrorCode2["INTERNAL_ERROR"] = "INTERNAL_ERROR";
@@ -4245,6 +4089,7 @@ 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";
@@ -4252,100 +4097,125 @@ var ApiErrorCode = /* @__PURE__ */ ((ApiErrorCode2) => {
   ApiErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
   return ApiErrorCode2;
 })(ApiErrorCode || {});
-var ApiError = class _ApiError extends BaseError {
-  constructor(message, code = "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",
-      400,
-      details,
-      true
-    );
-  }
-  /**
-   * Create an unauthorized error
-   */
-  static unauthorized(message = "Unauthorized") {
-    return new _ApiError(
-      message,
-      "UNAUTHORIZED",
-      401,
-      void 0,
-      true
-    );
-  }
-  /**
-   * Create a forbidden error
-   */
-  static forbidden(message = "Forbidden") {
-    return new _ApiError(
-      message,
-      "FORBIDDEN",
-      403,
-      void 0,
-      false
-    );
-  }
-  /**
-   * Create a not found error
-   */
-  static notFound(message = "Resource not found") {
-    return new _ApiError(
-      message,
-      "NOT_FOUND",
-      404,
-      void 0,
-      false
-    );
-  }
-  /**
-   * Create a rate limit error
-   */
-  static rateLimited(message = "Rate limit exceeded", details) {
-    return new _ApiError(
-      message,
-      "RATE_LIMITED",
-      429,
-      details,
-      true
-    );
-  }
-  /**
-   * Create an internal server error
-   */
-  static internal(message = "Internal server error", details) {
-    return new _ApiError(
-      message,
-      "INTERNAL_ERROR",
-      500,
-      details,
-      false
-    );
-  }
-};
-var PlatformError = class extends Error {
-  constructor(message, platform, code = "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 = 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 = z.object({
+  message: z.string().describe("Human-readable error message"),
+  code: ApiErrorCodeSchema.describe("Machine-readable error code"),
+  recoverable: z.boolean().describe("Whether the error can be recovered from"),
+  details: z.record(z.unknown()).optional().describe("Additional error details")
+});
+var ResponseMetaSchema = z.object({
+  requestId: z.string().uuid().describe("Unique identifier for the request"),
+  timestamp: z.string().datetime().describe("ISO timestamp of response generation"),
+  rateLimit: z.object({
+    remaining: z.number().int().nonnegative(),
+    limit: z.number().int().positive(),
+    reset: z.number().int().positive().describe("Unix timestamp (seconds)")
+  }).optional().describe("Rate limit information if applicable"),
+  pagination: z.object({
+    page: z.number().int().positive().optional(),
+    perPage: z.number().int().positive().optional(),
+    total: z.number().int().nonnegative().optional(),
+    limit: z.number().int().nonnegative().optional(),
+    offset: z.number().int().nonnegative().optional(),
+    totalPages: z.number().int().nonnegative().optional(),
+    nextCursor: z.string().optional(),
+    prevCursor: z.string().optional()
+  }).optional().describe("Pagination information if applicable")
+});
+var SuccessDetailSchema = z.object({
+  platform: z.string(),
+  userId: z.string(),
+  additionalData: z.any().optional(),
+  status: z.literal("success")
+}).catchall(z.any());
+var MultiStatusDataSchema = z.object({
+  summary: z.object({
+    total: z.number().int().nonnegative(),
+    succeeded: z.number().int().nonnegative(),
+    failed: z.number().int().nonnegative()
+  }),
+  results: z.array(SuccessDetailSchema),
+  errors: z.array(ErrorDetailSchema)
+});
 var PlatformParamSchema = z.object({
   platform: z.string().describe("Social media platform")
 }).describe("Platform parameter");
@@ -4355,44 +4225,37 @@ var AuthInitRequestSchema = z.object({
   ),
   errorUrl: z.string().url().optional().describe("URL to redirect to on authentication error")
 }).describe("Auth initialization request");
-var AuthUrlResponseSchema = EnhancedResponseSchema(
-  z.object({
-    url: z.string().describe("Authentication URL to redirect the user to"),
-    state: z.string().describe("State parameter for CSRF protection"),
-    platform: PlatformSchema
-  })
-).describe("Auth URL response");
+var AuthUrlResponseSchema = z.object({
+  url: z.string().describe("Authentication URL to redirect the user to"),
+  state: z.string().describe("State parameter for CSRF protection"),
+  platform: PlatformSchema
+}).describe("Auth URL response");
 var AuthCallbackQuerySchema = z.object({
   code: z.string().describe("Authorization code from OAuth provider"),
   state: z.string().describe("State parameter for CSRF protection")
 }).describe("Auth callback query");
-var AuthCallbackResponseSchema = EnhancedResponseSchema(
-  z.object({
-    success: z.boolean().describe("Whether the authentication was successful"),
-    platform: PlatformSchema,
-    userId: z.string().describe("User ID"),
-    redirectUrl: z.string().optional().describe("URL to redirect the user to after authentication")
-  })
-).describe("Auth callback response");
-var AuthStatusResponseSchema = EnhancedResponseSchema(
-  z.object({
-    platform: PlatformSchema,
-    userId: z.string().describe("User ID"),
-    authenticated: z.boolean().describe("Whether the user is authenticated"),
-    tokenStatus: z.object({
-      valid: z.boolean().describe("Whether the token is valid"),
-      expired: z.boolean().describe("Whether the token is expired"),
-      expiresAt: z.string().optional().describe("When the token expires")
-    })
-  })
-).describe("Auth status response");
-var AuthRevokeResponseSchema = EnhancedResponseSchema(
-  z.object({
-    success: z.boolean().describe("Whether the revocation was successful"),
-    platform: PlatformSchema,
-    userId: z.string().describe("User ID")
+var AuthCallbackResponseSchema = z.object({
+  platform: PlatformSchema,
+  userId: z.string().describe("User ID"),
+  redirectUrl: z.string().optional().describe("URL to redirect the user to after authentication")
+}).describe("Auth callback response");
+var AuthStatusResponseSchema = z.object({
+  platform: PlatformSchema,
+  userId: z.string().describe("User ID"),
+  authenticated: z.boolean().describe("Whether the user is authenticated"),
+  tokenStatus: z.object({
+    valid: z.boolean().describe("Whether the token is valid"),
+    expired: z.boolean().describe("Whether the token is expired"),
+    expiresAt: z.string().optional().describe("When the token expires")
   })
-).describe("Auth revoke response");
+}).describe("Auth status response");
+var AuthTokenRequestSchema = z.object({
+  userId: z.string().describe("User ID on the platform")
+}).describe("Auth token request");
+var AuthRevokeResponseSchema = z.object({
+  platform: PlatformSchema,
+  userId: z.string().describe("User ID")
+}).describe("Auth revoke response");
 var ConnectedAccountSchema = z.object({
   platform: PlatformSchema,
   userId: z.string().describe("User ID on the platform"),
@@ -4400,26 +4263,21 @@ var ConnectedAccountSchema = z.object({
   profileUrl: z.string().optional().describe("URL to the user profile"),
   connectedAt: z.string().optional().describe("When the account was connected")
 }).describe("Connected account");
-var ConnectedAccountsResponseSchema = EnhancedResponseSchema(
-  z.array(ConnectedAccountSchema)
-).describe("Connected accounts response");
+var ConnectedAccountsResponseSchema = z.array(ConnectedAccountSchema).describe(
+  "Connected accounts response"
+);
 var NearAuthorizationRequestSchema = z.object({
   // No additional parameters needed, as the NEAR account ID is extracted from the signature
 }).describe("NEAR authorization request");
-var NearAuthorizationResponseSchema = EnhancedResponseSchema(
-  z.object({
-    success: z.boolean().describe("Whether the authorization was successful"),
-    nearAccount: z.string().describe("NEAR account ID"),
-    authorized: z.boolean().describe("Whether the account is authorized")
-  })
-).describe("NEAR authorization response");
-var NearAuthorizationStatusResponseSchema = EnhancedResponseSchema(
-  z.object({
-    nearAccount: z.string().describe("NEAR account ID"),
-    authorized: z.boolean().describe("Whether the account is authorized"),
-    authorizedAt: z.string().optional().describe("When the account was authorized")
-  })
-).describe("NEAR authorization status response");
+var NearAuthorizationResponseSchema = z.object({
+  nearAccount: z.string().describe("NEAR account ID"),
+  authorized: z.boolean().describe("Whether the account is authorized")
+}).describe("NEAR authorization response");
+var NearAuthorizationStatusResponseSchema = z.object({
+  nearAccount: z.string().describe("NEAR account ID"),
+  authorized: z.boolean().describe("Whether the account is authorized"),
+  authorizedAt: z.string().optional().describe("When the account was authorized")
+}).describe("NEAR authorization status response");
 var MediaContentSchema = z.object({
   data: z.union([z.string(), z.instanceof(Blob)]).describe("Media data as string or Blob"),
   mimeType: z.string().optional().describe("Media MIME type"),
@@ -4534,65 +4392,33 @@ var UnlikePostRequestSchema = z.object({
   platform: PlatformSchema.describe("Platform of the post being unliked"),
   postId: z.string().describe("ID of the post to unlike")
 }).describe("Unlike post request");
-var PostResponseSchema = EnhancedResponseSchema(
-  z.union([PostSchema, z.array(PostSchema)])
-).describe("Post response");
-var CreatePostResponseLegacySchema = PostResponseSchema.describe(
-  "Create post response (legacy)"
+var PostResponseSchema = z.union([PostSchema, 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(
-  z.object({
-    success: z.boolean().describe("Whether the deletion was successful"),
-    id: z.string().describe("ID of the deleted post")
-  })
-).describe("Delete post response");
-var LikePostResponseSchema = EnhancedResponseSchema(
-  z.object({
-    success: z.boolean().describe("Whether the like was successful"),
-    id: z.string().describe("ID of the liked post")
-  })
-).describe("Like post response");
-var UnlikePostResponseSchema = EnhancedResponseSchema(
-  z.object({
-    success: z.boolean().describe("Whether the unlike was successful"),
-    id: z.string().describe("ID of the unliked post")
-  })
-).describe("Unlike post response");
+var DeletePostResponseSchema = z.object({
+  id: z.string().describe("ID of the deleted post")
+}).describe("Delete post response");
+var LikePostResponseSchema = z.object({
+  id: z.string().describe("ID of the liked post")
+}).describe("Like post response");
+var UnlikePostResponseSchema = z.object({
+  id: z.string().describe("ID of the unliked post")
+}).describe("Unlike post response");
 var PostMultiStatusResponseSchema = z.object({
-  success: z.boolean().describe("Whether the operation was partially or fully successful"),
-  data: z.object({
-    summary: z.object({
-      total: z.number().describe("Total number of operations"),
-      succeeded: z.number().describe("Number of successful operations"),
-      failed: z.number().describe("Number of failed operations")
-    }),
-    results: z.array(PostSuccessDetailSchema).describe("Successful operations"),
-    errors: z.array(ErrorDetailSchema).describe("Failed operations")
-  })
+  summary: z.object({
+    total: z.number().describe("Total number of operations"),
+    succeeded: z.number().describe("Number of successful operations"),
+    failed: z.number().describe("Number of failed operations")
+  }),
+  results: z.array(PostSuccessDetailSchema).describe("Successful operations"),
+  errors: z.array(ErrorDetailSchema).describe("Failed operations")
 }).describe("Multi-status response for post operations");
-var CreatePostTargetResultSchema = z.object({
-  platform: PlatformSchema.describe("The platform the post was created on"),
-  userId: z.string().describe("The user ID on the platform"),
-  result: z.array(z.any()).describe("The result of the post creation")
-}).describe("Create post target result");
-var CreatePostTargetErrorSchema = z.object({
-  platform: PlatformSchema.optional().describe(
-    "The platform where the error occurred (if applicable)"
-  ),
-  userId: z.string().optional().describe("The user ID where the error occurred (if applicable)"),
-  error: z.string().describe("The error message")
-}).describe("Create post target error");
-var CreatePostResponseSchema = EnhancedResponseSchema(
-  z.object({
-    results: z.array(CreatePostTargetResultSchema).describe("Array of successful post results"),
-    errors: z.array(CreatePostTargetErrorSchema).optional().describe(
-      "Array of errors that occurred (if any)"
-    )
-  })
-).describe("Create post response");
 var RateLimitEndpointParamSchema = z.object({
   endpoint: z.string().optional().describe(
     "Specific endpoint to get rate limit information for (optional)"
@@ -4627,43 +4453,39 @@ var UsageRateLimitSchema = z.object({
   resetSeconds: z.number().describe("Seconds until the rate limit will reset"),
   timeWindow: z.string().describe("Time window for the rate limit")
 }).describe("Usage rate limit");
-var RateLimitStatusResponseSchema = EnhancedResponseSchema(
-  z.object({
-    platform: PlatformSchema,
-    userId: z.string().optional().describe("User ID"),
-    endpoints: z.array(RateLimitEndpointSchema).describe("Rate limits for specific endpoints"),
-    app: z.object({
-      limit: z.number().describe("App-wide rate limit"),
-      remaining: z.number().describe("Remaining requests"),
-      reset: z.number().describe("Reset timestamp (Unix timestamp in seconds)"),
-      resetDate: z.string().describe("Reset date (ISO string)")
-    }).optional().describe("App-wide rate limits")
-  })
-).describe("Rate limit status response");
-var AllRateLimitsResponseSchema = EnhancedResponseSchema(
-  z.object({
-    platforms: z.record(
-      PlatformSchema,
-      z.object({
-        users: z.record(
-          z.string(),
-          z.object({
-            endpoints: z.array(RateLimitEndpointSchema).describe(
-              "Rate limits for specific endpoints"
-            ),
-            lastUpdated: z.string().describe("Last updated date (ISO string)")
-          })
-        ).describe("User-specific rate limits"),
-        app: z.object({
-          limit: z.number().describe("App-wide rate limit"),
-          remaining: z.number().describe("Remaining requests"),
-          reset: z.number().describe("Reset timestamp (Unix timestamp in seconds)"),
-          resetDate: z.string().describe("Reset date (ISO string)")
-        }).optional().describe("App-wide rate limits")
-      })
-    ).describe("Rate limits by platform")
-  })
-).describe("All rate limits response");
+var RateLimitStatusResponseSchema = z.object({
+  platform: PlatformSchema,
+  userId: z.string().optional().describe("User ID"),
+  endpoints: z.array(RateLimitEndpointSchema).describe("Rate limits for specific endpoints"),
+  app: z.object({
+    limit: z.number().describe("App-wide rate limit"),
+    remaining: z.number().describe("Remaining requests"),
+    reset: z.number().describe("Reset timestamp (Unix timestamp in seconds)"),
+    resetDate: z.string().describe("Reset date (ISO string)")
+  }).optional().describe("App-wide rate limits")
+}).describe("Rate limit status response");
+var AllRateLimitsResponseSchema = z.object({
+  platforms: z.record(
+    PlatformSchema,
+    z.object({
+      users: z.record(
+        z.string(),
+        z.object({
+          endpoints: z.array(RateLimitEndpointSchema).describe(
+            "Rate limits for specific endpoints"
+          ),
+          lastUpdated: z.string().describe("Last updated date (ISO string)")
+        })
+      ).describe("User-specific rate limits"),
+      app: z.object({
+        limit: z.number().describe("App-wide rate limit"),
+        remaining: z.number().describe("Remaining requests"),
+        reset: z.number().describe("Reset timestamp (Unix timestamp in seconds)"),
+        resetDate: 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 = z.object({
   platformLimits: z.array(PlatformRateLimitSchema).describe("Platform-specific rate limits"),
   usageLimits: z.record(z.string(), UsageRateLimitSchema).describe(
@@ -4708,16 +4530,12 @@ var AccountActivityEntrySchema = z.object({
   rank: z.number().describe("Rank on the leaderboard"),
   lastActive: z.string().datetime().describe("Timestamp of last activity")
 }).describe("Account activity entry");
-var ActivityLeaderboardResponseSchema = EnhancedResponseSchema(
-  z.object({
-    timeframe: z.nativeEnum(TimePeriod).describe("Timeframe for the leaderboard"),
-    entries: z.array(AccountActivityEntrySchema).describe("Leaderboard entries"),
-    total: z.number().describe("Total number of entries in the leaderboard"),
-    limit: z.number().describe("Maximum number of results returned"),
-    offset: z.number().describe("Offset for pagination"),
-    generatedAt: z.string().datetime().describe("Timestamp when the leaderboard was generated")
-  })
-).describe("Activity leaderboard response");
+var ActivityLeaderboardResponseSchema = z.object({
+  timeframe: z.nativeEnum(TimePeriod).describe("Timeframe for the leaderboard"),
+  entries: z.array(AccountActivityEntrySchema).describe("Leaderboard entries"),
+  generatedAt: z.string().datetime().describe("Timestamp when the leaderboard was generated"),
+  platform: PlatformSchema.optional().describe("Platform filter (if applied)")
+});
 var AccountActivityParamsSchema = z.object({
   signerId: z.string().describe("NEAR account ID")
 }).describe("Account activity params");
@@ -4736,21 +4554,19 @@ var PlatformActivitySchema = z.object({
   score: z.number().describe("Activity score on this platform"),
   lastActive: z.string().datetime().describe("Timestamp of last activity on this platform")
 }).describe("Platform activity");
-var AccountActivityResponseSchema = EnhancedResponseSchema(
-  z.object({
-    signerId: z.string().describe("NEAR account ID"),
-    timeframe: z.nativeEnum(TimePeriod).describe("Timeframe for the activity"),
-    totalPosts: z.number().describe("Total number of posts across all platforms"),
-    totalLikes: z.number().describe("Total number of likes across all platforms"),
-    totalReposts: z.number().describe("Total number of reposts across all platforms"),
-    totalReplies: z.number().describe("Total number of replies across all platforms"),
-    totalQuotes: z.number().describe("Total number of quote posts across all platforms"),
-    totalScore: z.number().describe("Total activity score across all platforms"),
-    rank: z.number().describe("Rank on the leaderboard"),
-    lastActive: z.string().datetime().describe("Timestamp of last activity across all platforms"),
-    platforms: z.array(PlatformActivitySchema).describe("Activity breakdown by platform")
-  })
-).describe("Account activity response");
+var AccountActivityResponseSchema = z.object({
+  signerId: z.string().describe("NEAR account ID"),
+  timeframe: z.nativeEnum(TimePeriod).describe("Timeframe for the activity"),
+  totalPosts: z.number().describe("Total number of posts across all platforms"),
+  totalLikes: z.number().describe("Total number of likes across all platforms"),
+  totalReposts: z.number().describe("Total number of reposts across all platforms"),
+  totalReplies: z.number().describe("Total number of replies across all platforms"),
+  totalQuotes: z.number().describe("Total number of quote posts across all platforms"),
+  totalScore: z.number().describe("Total activity score across all platforms"),
+  rank: z.number().describe("Rank on the leaderboard"),
+  lastActive: z.string().datetime().describe("Timestamp of last activity across all platforms"),
+  platforms: z.array(PlatformActivitySchema).describe("Activity breakdown by platform")
+});
 var AccountPostsParamsSchema = z.object({
   signerId: z.string().describe("NEAR account ID")
 }).describe("Account posts params");
@@ -4778,19 +4594,14 @@ var AccountPostSchema = z.object({
   inReplyToId: z.string().optional().describe("ID of the post this is a reply to (if applicable)"),
   quotedPostId: z.string().optional().describe("ID of the post this is quoting (if applicable)")
 }).describe("Account post");
-var AccountPostsResponseSchema = EnhancedResponseSchema(
-  z.object({
-    signerId: z.string().describe("NEAR account ID"),
-    posts: z.array(AccountPostSchema).describe("List of posts"),
-    total: z.number().describe("Total number of posts matching the query"),
-    limit: z.number().describe("Maximum number of results returned"),
-    offset: z.number().describe("Offset for pagination"),
-    platform: z.string().optional().describe("Platform filter (if applied)"),
-    type: z.enum(["post", "repost", "reply", "quote", "like", "all"]).optional().describe(
-      "Post type filter (if applied)"
-    )
-  })
-).describe("Account posts response");
+var AccountPostsResponseSchema = z.object({
+  signerId: z.string().describe("NEAR account ID"),
+  posts: z.array(AccountPostSchema).describe("List of posts"),
+  platform: z.string().optional().describe("Platform filter (if applied)"),
+  type: z.enum(["post", "repost", "reply", "quote", "like", "all"]).optional().describe(
+    "Post type filter (if applied)"
+  )
+});
 var UserProfileSchema = z.object({
   userId: z.string().describe("User ID on the platform"),
   username: z.string().describe("Username on the platform"),
@@ -4800,118 +4611,107 @@ var UserProfileSchema = z.object({
   platform: PlatformSchema.describe("The platform the user profile is from"),
   lastUpdated: z.number().describe("Timestamp when the profile was last updated")
 }).describe("User profile");
-var ProfileRefreshResultSchema = z.object({
-  success: z.boolean().describe("Whether the profile refresh was successful"),
-  profile: UserProfileSchema.optional().describe("The refreshed user profile (if successful)"),
-  error: z.string().optional().describe("Error message (if unsuccessful)")
-}).describe("Profile refresh result");
-var ProfileRefreshResponseSchema = EnhancedResponseSchema(
-  ProfileRefreshResultSchema
-).describe("Profile refresh response");
+var ProfileRefreshResponseSchema = z.object({
+  profile: UserProfileSchema.optional().describe("The refreshed user profile (if successful)")
+}).describe("Profile refresh response");
 
 // src/core/request.ts
 import { createAuthToken } from "near-sign-verify";
 
 // src/utils/error.ts
-var ERROR_CATEGORIES = {
-  AUTH: [
-    ApiErrorCode.UNAUTHORIZED,
-    ApiErrorCode.FORBIDDEN
-  ],
-  VALIDATION: [
-    ApiErrorCode.VALIDATION_ERROR,
-    ApiErrorCode.INVALID_REQUEST
-  ],
-  NETWORK: [
-    ApiErrorCode.NETWORK_ERROR
-  ],
-  PLATFORM: [
-    ApiErrorCode.PLATFORM_ERROR,
-    ApiErrorCode.PLATFORM_UNAVAILABLE
-  ],
-  CONTENT: [
-    ApiErrorCode.CONTENT_POLICY_VIOLATION,
-    ApiErrorCode.DUPLICATE_CONTENT
-  ],
-  RATE_LIMIT: [
-    ApiErrorCode.RATE_LIMITED
-  ],
-  POST: [
-    ApiErrorCode.POST_CREATION_FAILED,
-    ApiErrorCode.THREAD_CREATION_FAILED,
-    ApiErrorCode.POST_DELETION_FAILED,
-    ApiErrorCode.POST_INTERACTION_FAILED
-  ],
-  MEDIA: [
-    ApiErrorCode.MEDIA_UPLOAD_FAILED
-  ]
-};
-function isErrorOfCategory(error, category) {
-  if (error instanceof ApiError) {
-    return category.includes(error.code);
+var CrosspostError = class extends Error {
+  constructor(message, code, status, details, recoverable = false) {
+    super(message);
+    this.name = "CrosspostError";
+    this.code = code;
+    this.status = status;
+    this.details = details;
+    this.recoverable = recoverable;
   }
-  if (error instanceof PlatformError) {
-    return category.includes(error.code);
+  /**
+   * Get platform from details if available
+   */
+  get platform() {
+    return this.details?.platform;
   }
-  if (error && typeof error === "object" && "code" in error) {
-    return category.includes(error.code);
+  /**
+   * Get userId from details if available
+   */
+  get userId() {
+    return this.details?.userId;
   }
-  return false;
+};
+function isErrorCode(error, codes) {
+  return error instanceof CrosspostError && codes.includes(error.code);
 }
 function isAuthError(error) {
-  return isErrorOfCategory(error, ERROR_CATEGORIES.AUTH);
+  return isErrorCode(error, [
+    ApiErrorCode.UNAUTHORIZED,
+    ApiErrorCode.FORBIDDEN
+  ]);
 }
 function isValidationError(error) {
-  return isErrorOfCategory(error, ERROR_CATEGORIES.VALIDATION);
+  return isErrorCode(error, [
+    ApiErrorCode.VALIDATION_ERROR,
+    ApiErrorCode.INVALID_REQUEST
+  ]);
 }
 function isNetworkError(error) {
-  return isErrorOfCategory(error, ERROR_CATEGORIES.NETWORK);
+  return isErrorCode(error, [
+    ApiErrorCode.NETWORK_ERROR,
+    ApiErrorCode.PLATFORM_UNAVAILABLE
+  ]);
 }
 function isPlatformError(error) {
-  return isErrorOfCategory(error, ERROR_CATEGORIES.PLATFORM) || error instanceof PlatformError;
+  return error instanceof CrosspostError && !!error.details?.platform;
 }
 function isContentError(error) {
-  return isErrorOfCategory(error, ERROR_CATEGORIES.CONTENT);
+  return isErrorCode(error, [
+    ApiErrorCode.CONTENT_POLICY_VIOLATION,
+    ApiErrorCode.DUPLICATE_CONTENT
+  ]);
 }
 function isRateLimitError(error) {
-  return isErrorOfCategory(error, ERROR_CATEGORIES.RATE_LIMIT);
+  return isErrorCode(error, [ApiErrorCode.RATE_LIMITED]);
 }
 function isPostError(error) {
-  return isErrorOfCategory(error, ERROR_CATEGORIES.POST);
+  return isErrorCode(error, [
+    ApiErrorCode.POST_CREATION_FAILED,
+    ApiErrorCode.THREAD_CREATION_FAILED,
+    ApiErrorCode.POST_DELETION_FAILED,
+    ApiErrorCode.POST_INTERACTION_FAILED
+  ]);
 }
 function isMediaError(error) {
-  return isErrorOfCategory(error, ERROR_CATEGORIES.MEDIA);
+  return isErrorCode(error, [ApiErrorCode.MEDIA_UPLOAD_FAILED]);
 }
 function isRecoverableError(error) {
-  if (error instanceof ApiError || error instanceof PlatformError) {
-    return error.recoverable;
-  }
-  return false;
+  return error instanceof CrosspostError && error.recoverable;
 }
 function getErrorMessage(error, defaultMessage = "An error occurred") {
   if (error instanceof Error) {
     return error.message || defaultMessage;
   }
-  if (typeof error === "string") {
-    return error;
-  }
-  if (error && typeof error === "object" && "message" in error) {
-    return error.message || defaultMessage;
-  }
   return defaultMessage;
 }
 function getErrorDetails(error) {
-  if (error instanceof ApiError || error instanceof PlatformError) {
-    return error.details;
-  }
-  if (error && typeof error === "object" && "details" in error) {
+  if (error instanceof CrosspostError) {
     return error.details;
   }
   return void 0;
 }
+function createError(message, code, status, details, recoverable = false) {
+  return new CrosspostError(
+    message,
+    code,
+    status,
+    details,
+    recoverable
+  );
+}
 function enrichErrorWithContext(error, context) {
-  if (error instanceof ApiError) {
-    return new ApiError(
+  if (error instanceof CrosspostError) {
+    return createError(
       error.message,
       error.code,
       error.status,
@@ -4919,25 +4719,12 @@ function enrichErrorWithContext(error, context) {
       error.recoverable
     );
   }
-  if (error instanceof PlatformError) {
-    return new PlatformError(
-      error.message,
-      error.platform,
-      error.code,
-      error.recoverable,
-      error.originalError,
-      error.status,
-      error.userId,
-      { ...error.details || {}, ...context }
-    );
-  }
   const errorMessage = error instanceof Error ? error.message : String(error);
-  return new ApiError(
+  return createError(
     errorMessage || "An error occurred",
     ApiErrorCode.INTERNAL_ERROR,
     500,
-    { originalError: error, ...context },
-    false
+    { originalError: error, ...context }
   );
 }
 async function apiWrapper(apiCall, context) {
@@ -4954,7 +4741,7 @@ async function apiWrapper(apiCall, context) {
       } catch (jsonError) {
         if (jsonError instanceof Error && jsonError.name === "SyntaxError") {
           throw enrichErrorWithContext(
-            new ApiError(
+            createError(
               `API request failed with status ${error.status} and non-JSON response`,
               ApiErrorCode.NETWORK_ERROR,
               error.status,
@@ -4966,7 +4753,7 @@ async function apiWrapper(apiCall, context) {
         throw jsonError;
       }
     }
-    if (error instanceof ApiError || error instanceof PlatformError) {
+    if (error instanceof CrosspostError) {
       throw enrichErrorWithContext(error, context || {});
     }
     throw enrichErrorWithContext(
@@ -4976,50 +4763,68 @@ async function apiWrapper(apiCall, context) {
   }
 }
 function handleErrorResponse(data, status) {
-  const errorData = data?.error || {};
-  const message = errorData?.message || data?.message || "An API error occurred";
-  const codeString = errorData?.code || data?.code || ApiErrorCode.UNKNOWN_ERROR;
-  const code = Object.values(ApiErrorCode).includes(codeString) ? codeString : ApiErrorCode.UNKNOWN_ERROR;
-  const details = errorData?.details || data?.details || {};
-  const recoverable = errorData?.recoverable ?? data?.recoverable ?? false;
-  const platform = errorData?.platform || data?.platform;
-  const enhancedDetails = { ...details };
-  if (typeof enhancedDetails === "object" && !enhancedDetails.originalResponse) {
-    enhancedDetails.originalResponse = data;
-  }
-  if (platform && Object.values(Platform).includes(platform)) {
-    return new PlatformError(
-      message,
-      platform,
-      code,
-      // Use the parsed code
+  if (!data || typeof data !== "object" || !("success" in data)) {
+    return createError(
+      "Invalid API response format",
+      ApiErrorCode.INTERNAL_ERROR,
+      status,
+      { originalResponse: data }
+    );
+  }
+  if (!data.errors || !Array.isArray(data.errors) || data.errors.length === 0) {
+    return createError(
+      "Invalid error response format",
+      ApiErrorCode.INTERNAL_ERROR,
+      status,
+      { originalResponse: data }
+    );
+  }
+  if (data.errors.length === 1) {
+    const errorDetail = data.errors[0];
+    if (!errorDetail.message || !errorDetail.code) {
+      return createError(
+        "Invalid error detail format",
+        ApiErrorCode.INTERNAL_ERROR,
+        status,
+        { originalResponse: data }
+      );
+    }
+    const finalDetails = {
+      ...errorDetail.details || {},
+      ...data.meta || {}
+    };
+    return createError(
+      errorDetail.message,
+      errorDetail.code,
       status,
-      // Cast status
-      enhancedDetails,
-      recoverable
+      finalDetails,
+      errorDetail.recoverable ?? false
     );
   } else {
-    return new ApiError(
-      message,
-      code,
-      // Use the parsed code
+    const firstError = data.errors[0];
+    return createError(
+      "Multiple errors occurred",
+      firstError.code,
       status,
-      // Cast status
-      enhancedDetails,
-      recoverable
+      {
+        errors: data.errors,
+        ...data.meta || {},
+        originalResponse: data
+      },
+      false
     );
   }
 }
 function createNetworkError(error, url, timeout) {
   if (error instanceof DOMException && error.name === "AbortError") {
-    return new ApiError(
+    return createError(
       `Request timed out after ${timeout}ms`,
       ApiErrorCode.NETWORK_ERROR,
       408,
       { url }
     );
   }
-  return new ApiError(
+  return createError(
     error instanceof Error ? error.message : "An unexpected error occurred during the request",
     ApiErrorCode.INTERNAL_ERROR,
     500,
@@ -5042,9 +4847,6 @@ async function makeRequest(method, path, options, data, query) {
       url += `?${queryString}`;
     }
   }
-  if (!options.nearAuthData) {
-    throw ApiError.unauthorized("Authentication required. Please provide NEAR signature.");
-  }
   const context = {
     method,
     path,
@@ -5075,15 +4877,14 @@ async function makeRequest(method, path, options, data, query) {
           responseData = await response.json();
         } catch (jsonError) {
           if (!response.ok) {
-            throw new ApiError(
+            throw new CrosspostError(
               `API request failed with status ${response.status} and non-JSON response`,
               ApiErrorCode.NETWORK_ERROR,
               response.status,
               { originalStatusText: response.statusText }
             );
           }
-          if (response.status === 204) return {};
-          throw new ApiError(
+          throw new CrosspostError(
             `Failed to parse JSON response: ${jsonError instanceof Error ? jsonError.message : String(jsonError)}`,
             ApiErrorCode.INTERNAL_ERROR,
             response.status
@@ -5091,23 +4892,26 @@ async function makeRequest(method, path, options, data, query) {
         }
         if (!response.ok) {
           lastError = handleErrorResponse(responseData, response.status);
-          const shouldRetry = response.status >= 500 || lastError instanceof ApiError && lastError.recoverable;
+          const shouldRetry = lastError instanceof CrosspostError && lastError.code === ApiErrorCode.RATE_LIMITED;
           if (shouldRetry && attempt < options.retries) {
             await new Promise((resolve) => setTimeout(resolve, 1e3 * Math.pow(2, attempt)));
             continue;
           }
           throw lastError;
         }
-        if (responseData && typeof responseData === "object" && "success" in responseData && !responseData.success && responseData.error) {
-          lastError = handleErrorResponse(responseData, response.status);
-          const shouldRetry = lastError instanceof ApiError && lastError.recoverable;
-          if (shouldRetry && attempt < options.retries) {
-            await new Promise((resolve) => setTimeout(resolve, 1e3 * Math.pow(2, attempt)));
-            continue;
+        if (responseData && typeof responseData === "object" && "success" in responseData) {
+          if (responseData.success) {
+            return responseData.data;
+          } else {
+            lastError = handleErrorResponse(responseData, response.status);
+            const shouldRetry = lastError instanceof CrosspostError && lastError.code === ApiErrorCode.RATE_LIMITED;
+            if (shouldRetry && attempt < options.retries) {
+              await new Promise((resolve) => setTimeout(resolve, 1e3 * Math.pow(2, attempt)));
+              continue;
+            }
+            throw lastError;
           }
-          throw lastError;
         }
-        return responseData;
       } catch (error) {
         clearTimeout(timeoutId);
         lastError = error instanceof Error ? error : new Error(String(error));
@@ -5116,13 +4920,13 @@ async function makeRequest(method, path, options, data, query) {
           await new Promise((resolve) => setTimeout(resolve, 1e3 * Math.pow(2, attempt)));
           continue;
         }
-        if (!(error instanceof ApiError)) {
+        if (!(error instanceof CrosspostError)) {
           throw createNetworkError(error, url, options.timeout);
         }
         throw error;
       }
     }
-    throw lastError || new ApiError("Request failed after multiple retries", ApiErrorCode.INTERNAL_ERROR, 500);
+    throw lastError || new CrosspostError("Request failed after multiple retries", ApiErrorCode.INTERNAL_ERROR, 500);
   }, context);
 }
 
@@ -5358,7 +5162,7 @@ var PostApi = class {
   async likePost(request) {
     return makeRequest(
       "POST",
-      `/api/post/like/${request.postId}`,
+      `/api/post/like`,
       this.options,
       request
     );
@@ -5371,7 +5175,7 @@ var PostApi = class {
   async unlikePost(request) {
     return makeRequest(
       "DELETE",
-      `/api/post/like/${request.postId}`,
+      `/api/post/like`,
       this.options,
       request
     );
@@ -5382,17 +5186,9 @@ var PostApi = class {
    * @returns A promise resolving with the delete response.
    */
   async deletePost(request) {
-    const postId = request.posts[0]?.postId || "";
-    if (!postId) {
-      throw new ApiError(
-        "Post ID is required for deletion path",
-        ApiErrorCode.VALIDATION_ERROR,
-        400
-      );
-    }
     return makeRequest(
       "DELETE",
-      `/api/post/${postId}`,
+      `/api/post`,
       this.options,
       request
     );
@@ -5492,56 +5288,43 @@ export {
   AccountActivityEntrySchema,
   AccountActivityParamsSchema,
   AccountActivityQuerySchema,
-  AccountActivityResponseSchema,
   AccountPostSchema,
   AccountPostsParamsSchema,
   AccountPostsQuerySchema,
-  AccountPostsResponseSchema,
   ActivityApi,
   ActivityLeaderboardQuerySchema,
-  ActivityLeaderboardResponseSchema,
   AllRateLimitsResponseSchema,
-  ApiError,
   ApiErrorCode,
-  ApiResponseSchema,
+  ApiErrorCodeSchema,
   AuthApi,
   AuthCallbackQuerySchema,
   AuthCallbackResponseSchema,
   AuthInitRequestSchema,
   AuthRevokeResponseSchema,
   AuthStatusResponseSchema,
+  AuthTokenRequestSchema,
   AuthUrlResponseSchema,
-  BaseError,
   ConnectedAccountSchema,
   ConnectedAccountsResponseSchema,
   CreatePostRequestSchema,
-  CreatePostResponseLegacySchema,
   CreatePostResponseSchema,
-  CreatePostTargetErrorSchema,
-  CreatePostTargetResultSchema,
   CrosspostClient,
   DeletePostRequestSchema,
   DeletePostResponseSchema,
   DeleteResultSchema,
-  ERROR_CATEGORIES,
   EndpointRateLimitResponseSchema,
-  EnhancedErrorResponseSchema,
-  EnhancedResponseMetaSchema,
-  EnhancedResponseSchema,
   ErrorDetailSchema,
-  ErrorResponseSchema,
   LikePostRequestSchema,
   LikePostResponseSchema,
   LikeResultSchema,
   MediaContentSchema,
   MediaSchema,
-  MultiStatusResponseSchema,
+  MultiStatusDataSchema,
   NearAuthorizationRequestSchema,
   NearAuthorizationResponseSchema,
   NearAuthorizationStatusResponseSchema,
   Platform,
   PlatformActivitySchema,
-  PlatformError,
   PlatformParamSchema,
   PlatformRateLimitSchema,
   PlatformSchema,
@@ -5555,7 +5338,6 @@ export {
   PostSuccessDetailSchema,
   PostToDeleteSchema,
   ProfileRefreshResponseSchema,
-  ProfileRefreshResultSchema,
   QuotePostRequestSchema,
   QuotePostResponseSchema,
   RateLimitEndpointParamSchema,
@@ -5567,6 +5349,7 @@ export {
   ReplyToPostResponseSchema,
   RepostRequestSchema,
   RepostResponseSchema,
+  ResponseMetaSchema,
   SUPPORTED_PLATFORMS,
   SuccessDetailSchema,
   SupportedPlatformSchema,
@@ -5578,21 +5361,14 @@ export {
   UsageRateLimitSchema,
   UserProfileSchema,
   apiWrapper,
-  createApiResponse,
-  createEnhancedApiResponse,
-  createEnhancedErrorResponse,
-  createErrorDetail,
-  createErrorResponse,
-  createMultiStatusResponse,
   createNetworkError,
-  createSuccessDetail,
   enrichErrorWithContext,
+  errorCodeToStatusCode,
   getErrorDetails,
   getErrorMessage,
   handleErrorResponse,
   isAuthError,
   isContentError,
-  isErrorOfCategory,
   isMediaError,
   isNetworkError,
   isPlatformError,