import { ActionItem, ActionsModel, SettingsModel as SettingsModel$1, achievements, collectionsOpenAPISchema, entries, entriesOpenAPISchema, featureFlags, feedAnalytics, feeds, inboxes, inboxesEntriesOpenAPISchema, invitations, languageSchema, levels, lists, listsSubscriptions, messaging, settings, subscriptions, userFeatureOverrides, users, wallets } from "@folo-services/drizzle";
import { InferInsertModel, InferSelectModel } from "drizzle-orm";
import z$1, { z } from "zod";
import { ACHIEVEMENTS_TYPES, FEATURE_NAMES, FeatureName, FeedViewType, FeedViewType as FeedViewType$1, SETTINGS_TABS } from "@folo-services/constants";
import { FeedOpenApiSchema, InboxOpenApiSchema, ListOpenApiSchema } from "@folo-services/shared";
import { ExceptionCodeMap } from "@folo-services/exceptions";

//#region src/types/api.d.ts
/**
 * Standard Follow API response wrapper
 */
interface FollowAPIResponse<T = any> {
  code: number;
  data: T;
  message?: string;
}
/**
 * Error response from Follow API
 */
interface FollowAPIErrorResponse {
  code: number;
  message: string;
  data?: any;
}
/**
 * Generic type for requests that only contain an id parameter
 */
interface IdRequest {
  id: string;
}
/**
 * Generic type for requests that only contain a feedId parameter
 */
interface FeedIdRequest {
  feedId: string;
}
/**
 * Generic type for requests that only contain a listId parameter
 */
interface ListIdRequest {
  listId: string;
}
/**
 * Generic type for requests that only contain a userId parameter
 */
interface UserIdRequest {
  userId: string;
}
/**
 * Generic type for requests that only contain an entryId parameter
 */
interface EntryIdRequest {
  entryId: string;
}
/**
 * HTTP methods supported by the client
 */
type HTTPMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
/**
 * Request content types
 */
type RequestContentType = "json" | "formData" | "text" | "blob" | "arrayBuffer";
/**
 * Response content types
 */
type ResponseContentType = "json" | "text" | "blob" | "arrayBuffer" | "stream";
/**
 * Request options for API calls
 */
interface RequestOptions {
  method?: HTTPMethod;
  headers?: Record<string, string>;
  body?: unknown;
  query?: Record<string, string | number | boolean>;
  timeout?: number;
  signal?: AbortSignal;
  requestType?: RequestContentType;
}
/**
 * Client configuration options
 */
interface ClientConfig {
  baseURL: string;
  timeout?: number;
  headers?: Record<string, string>;
  credentials?: RequestCredentials;
  fetch?: typeof fetch;
}
/**
 * Pagination parameters
 */
interface PaginationParams {
  page?: number;
  limit?: number;
  before?: string;
  after?: string;
}
/**
 * Pagination response
 */
interface PaginationResponse<T> {
  data: T[];
  pagination: {
    page: number;
    limit: number;
    total: number;
    hasMore: boolean;
  };
}
//#endregion
//#region src/types/date-serialization.d.ts
/**
 * Utility types for handling Date to ISO string serialization in HTTP JSON responses
 */
type DateISOString = string;
/**
 * Recursively converts Date types to DateISOString for JSON serialization
 * This handles the fact that Date objects are serialized as ISO strings in HTTP JSON responses
 */
type DateToString<T> = T extends Date ? DateISOString : T extends (infer U)[] ? DateToString<U>[] : T extends Array<infer U> ? Array<DateToString<U>> : T extends Record<string, any> ? T extends ((...args: any[]) => any) ? T : { [K in keyof T]: DateToString<T[K]> } : T;
/**
 * Converts Drizzle InferSelectModel Date types to DateISOString for HTTP responses
 * Use this for types that will be sent over HTTP as JSON
 */
type SerializedModel<T> = DateToString<T>;
/**
 * Converts Drizzle InferInsertModel Date types to DateISOString for HTTP requests
 * Use this for types that will be received from HTTP as JSON
 */
type SerializedInsertModel<T> = DateToString<T>;
/**
 * Helper type for API responses that contain serialized models
 */
type ApiResponse<T> = SerializedModel<T>;
/**
 * Helper type for API requests that contain serialized models
 */
type ApiRequest<T> = SerializedInsertModel<T>;
//#endregion
//#region src/types/errors.d.ts
/**
 * Base error class for all Follow API errors
 */
declare class FollowAPIError extends Error {
  status: number;
  code?: string | undefined;
  data?: any | undefined;
  constructor(message: string, status: number, code?: string | undefined, data?: any | undefined);
}
declare class NetworkError extends Error {
  constructor(message: string);
}
/**
 * Authentication error for Follow API
 */
declare class FollowAuthError extends FollowAPIError {
  constructor(message?: string, data?: any);
}
/**
 * Validation error for Follow API requests
 */
declare class FollowValidationError extends FollowAPIError {
  validationErrors: any[];
  constructor(message: string, validationErrors: any[]);
}
/**
 * Network timeout error
 */
declare class FollowTimeoutError extends FollowAPIError {
  constructor(message?: string);
}
//#endregion
//#region src/types/response.d.ts
/**
 * Standard API response structure for Follow Server
 * All API responses follow this consistent format
 */
interface ResponseStruct<T = any> {
  /**
   * Response code
   * 0 = success
   * Non-zero = error code (matches ExceptionCodes)
   */
  code: number;
  /**
   * Response message
   * Usually contains error message when code !== 0
   */
  message?: string;
  /**
   * Response data payload
   * Contains actual response data when code === 0
   */
  data?: T;
}
/**
 * Successful API response with data
 */
interface SuccessResponse<T = any> extends ResponseStruct<T> {
  code: 0;
  data: T;
}
type ExtractResponseData<T> = T extends ResponseStruct<infer U> ? U : never;
/**
 * Error API response
 */
interface ErrorResponse extends ResponseStruct<never> {
  code: number;
  message: string;
  data?: any;
}
/**
 * Paginated response structure
 */
interface PaginatedData<T = any> {
  items: T[];
  total: number;
  page?: number;
  limit?: number;
  hasMore?: boolean;
}
/**
 * Paginated API response
 */
type PaginatedResponse<T = any> = SuccessResponse<PaginatedData<T>>;
/**
 * Empty success response (for operations that don't return data)
 */
type EmptyResponse = SuccessResponse<null>;
//#endregion
//#region src/client/interceptors.d.ts
/**
 * Base context object shared by all interceptors
 */
interface BaseInterceptorContext {
  url: string;
  options: RequestOptions;
}
/**
 * Context object passed to request interceptors
 */
interface RequestInterceptorContext extends BaseInterceptorContext {}
/**
 * Context object passed to response interceptors
 */
interface ResponseInterceptorContext extends BaseInterceptorContext {
  response: Response;
}
/**
 * Context object passed to error interceptors
 */
interface ErrorInterceptorContext extends BaseInterceptorContext {
  response: Response | null;
  error: Error;
}
/**
 * Request interceptor function type
 */
type RequestInterceptor = (ctx: RequestInterceptorContext) => Promise<{
  url: string;
  options: RequestOptions;
}> | {
  url: string;
  options: RequestOptions;
};
/**
 * Response interceptor function type
 */
type ResponseInterceptor = (ctx: ResponseInterceptorContext) => Promise<Response> | Response;
/**
 * Error interceptor function type
 */
type ErrorInterceptor = (ctx: ErrorInterceptorContext) => Promise<Error | void> | Error | void;
/**
 * Interceptor manager for handling request/response middleware
 */
//#endregion
//#region src/shared/define-module.d.ts
/**
 * Route definition with type annotations
 */
interface RouteDefinition<TInput = any, TResponse = any> {
  method: HTTPMethod;
  path: string;
  params?: readonly string[];
  /** Fields that should be sent as query parameters */
  query?: readonly string[];
  /** Fields that should be sent as request body */
  body?: readonly string[];
  input?: TInput;
  response?: TResponse;
  requestType?: RequestContentType;
  responseType?: ResponseContentType;
}
/**
 * Nested routes structure - supports any depth of nesting
 */
type NestedRoutes = {
  [key: string]: RouteDefinition | NestedRoutes;
};
/**
 * Module definition interface
 */
interface ModuleDefinition<TRoutes extends NestedRoutes> {
  name: string;
  prefix?: string;
  routes: TRoutes;
  api: ModuleAPI<TRoutes>;
}
/**
 * Fetch options for route requests
 */
interface FetchOptions {
  headers?: Record<string, string>;
  timeout?: number;
  signal?: AbortSignal;
}
/**
 * Check if arguments are required
 */
type IsRequired<TInput> = [TInput] extends [never] ? false : {} extends TInput ? false : true;
/**
 * Route function with proper argument requirements
 */
type RouteFunction<TInput, TResponse> = IsRequired<TInput> extends true ? (args: TInput, options?: FetchOptions) => Promise<TResponse> : (args?: TInput, options?: FetchOptions) => Promise<TResponse>;
/**
 * Generate API types from route structure
 */
type ModuleAPI<TRoutes> = { [K in keyof TRoutes]: TRoutes[K] extends RouteDefinition<infer TInput, infer TResponse> ? RouteFunction<TInput, TResponse> : TRoutes[K] extends NestedRoutes ? ModuleAPI<TRoutes[K]> : never };
/**
 * Legacy route args interface for backward compatibility
 */
//#endregion
//#region src/modules/achievement/types.d.ts
type Achievement = SerializedModel<InferSelectModel<typeof achievements>>;
type AchievementType = "checking" | "completed" | "incomplete" | "audit" | "received";
interface ListAchievementsRequest {
  type?: AchievementType | "all";
}
interface ClaimAchievementRequest {
  actionId: number;
}
interface CheckAchievementRequest {
  actionId: number;
}
interface AuditAchievementRequest {
  actionId: number;
  payload: any;
}
interface AchievementWithPower extends Achievement {
  power: string;
}
interface ListAchievementsData {
  data: AchievementWithPower[];
  total: number;
  done: number;
}
interface AchievementActionResult {
  actionId: number;
  result: boolean;
}
type ListAchievementsResponse = SuccessResponse<AchievementWithPower[]> & {
  total: number;
  done: number;
};
type ClaimAchievementResponse = SuccessResponse<AchievementActionResult>;
type CheckAchievementResponse = SuccessResponse<AchievementActionResult>;
type AuditAchievementResponse = EmptyResponse;
//#endregion
//#region src/modules/achievement/index.d.ts
/**
 * Achievement module for user achievement management
 */
declare const achievementModule: ModuleDefinition<{
  list: RouteDefinition<ListAchievementsRequest, ListAchievementsResponse>;
  claim: RouteDefinition<ClaimAchievementRequest, ClaimAchievementResponse>;
  check: RouteDefinition<CheckAchievementRequest, CheckAchievementResponse>;
  audit: RouteDefinition<AuditAchievementRequest, EmptyResponse>;
}>;
type AchievementAPI = typeof achievementModule.api;
//#endregion
//#region src/modules/admin/types.d.ts
type FeatureFlagModel = SerializedModel<InferSelectModel<typeof featureFlags>>;
type FeatureFlagInsert = SerializedInsertModel<InferInsertModel<typeof featureFlags>>;
type UserFeatureOverrideModel = SerializedModel<InferSelectModel<typeof userFeatureOverrides>>;
type UserFeatureOverrideInsert = SerializedInsertModel<InferInsertModel<typeof userFeatureOverrides>>;
declare const ROLLOUT_TYPES: readonly ["whitelist", "percentage"];
type RolloutType = (typeof ROLLOUT_TYPES)[number];
type RolloutValue = 0 | 1;
type MessageResponse = SuccessResponse<{
  message: string;
}>;
type FeatureFlagResponse = SuccessResponse<FeatureFlagModel>;
type FeatureFlagListResponse = SuccessResponse<FeatureFlagModel[]>;
interface FeatureFlagUpdateRequest {
  description?: string;
  enabled?: boolean;
  rolloutType?: RolloutType;
  rolloutValue?: RolloutValue;
  rolloutPercentage?: number;
  rolloutSeed?: string;
}
interface UserOverrideRequest {
  userId: string;
  forceEnabled: boolean;
  reason?: string;
  expiresAt?: string;
}
type FeatureStatsResponse = SuccessResponse<{
  totalUsers: number;
  enabledUsers: number;
  overrideUsers: number;
  rolloutType: string;
  rolloutPercentage: number;
  enabledOverrides: number;
  disabledOverrides: number;
  enabled: boolean;
  enabledByRollout: number;
  enabledByOverride: number;
  disabledUsers: number;
}>;
interface AffectedUsersQuery {
  page?: number;
  limit?: number;
  filter?: "all" | "enabled" | "disabled" | "override";
  search?: string;
}
interface AffectedUser {
  id: string;
  name: string | null;
  email: string;
  handle: string | null;
  image: string | null;
  createdAt: string;
  status: "enabled" | "disabled";
  reason: "rollout" | "override";
  overrideReason: string | null;
  overrideExpiresAt: string | null;
  overrideCreatedBy: string | null;
}
type AffectedUsersResponse = SuccessResponse<{
  users: AffectedUser[];
  pagination: {
    page: number;
    limit: number;
    total: number;
    totalPages: number;
  };
}>;
interface FeatureFlagUpdateInput {
  name: string;
  description?: string;
  enabled?: boolean;
  rolloutType?: RolloutType;
  rolloutValue?: RolloutValue;
  rolloutPercentage?: number;
  rolloutSeed?: string;
}
interface UserOverrideInput {
  name: string;
  userId: string;
  forceEnabled: boolean;
  reason?: string;
  expiresAt?: string;
}
interface RemoveOverrideInput {
  name: string;
  userId: string;
}
interface FeatureStatsInput {
  name: string;
}
interface AffectedUsersInput {
  name: string;
  page?: number;
  limit?: number;
  filter?: "all" | "enabled" | "disabled" | "override";
  search?: string;
}
interface CleanRequest {
  type: string;
  feedId?: string;
  nsfw?: boolean;
}
type CleanResponse = EmptyResponse;
interface MintRequest {
  userId: string;
  amount: number;
  key: string;
  comment?: string;
}
type MintResponse = SuccessResponse<string>;
//#endregion
//#region src/modules/admin/index.d.ts
/**
 * Admin module definition with nested routes
 */
declare const adminModule: ModuleDefinition<{
  featureFlags: {
    list: RouteDefinition<never, FeatureFlagListResponse>;
    update: RouteDefinition<FeatureFlagUpdateInput, FeatureFlagResponse>;
    override: RouteDefinition<UserOverrideInput, MessageResponse>;
    removeOverride: RouteDefinition<RemoveOverrideInput, MessageResponse>;
    stats: RouteDefinition<FeatureStatsInput, FeatureStatsResponse>;
    affectedUsers: RouteDefinition<AffectedUsersInput, AffectedUsersResponse>;
  };
  clean: {
    execute: RouteDefinition<CleanRequest, EmptyResponse>;
  };
  mint: {
    execute: RouteDefinition<MintRequest, MintResponse>;
  };
}>;
type AdminAPI = typeof adminModule.api;
//#endregion
//#region src/modules/ai/types.d.ts
type LanguageSchema = z.infer<typeof languageSchema>;
interface ChatMessage {
  role: string;
  content: string;
}
interface ChatContext {
  mainEntryId?: string;
  referEntryIds?: string[];
  referFeedIds?: string[];
  selectedText?: string;
}
interface ChatRequest {
  messages: ChatMessage[];
  context?: ChatContext;
}
type ChatResponse = Response;
interface SummaryRequest {
  id: string;
  language?: LanguageSchema;
  target?: "content" | "readabilityContent";
}
type SummaryResponse = SuccessResponse<string | null>;
type EntryStringKey = "title" | "description" | "content" | "readabilityContent";
interface TranslationRequest {
  id: string;
  language: LanguageSchema;
  fields: string;
  part?: string;
}
interface TranslationData {
  title?: string;
  description?: string;
  content?: string;
  readabilityContent?: string;
}
type TranslationResponse = SuccessResponse<TranslationData | null>;
interface TitleRequest {
  messages: ChatMessage[];
}
interface TitleResponse {
  title: string;
  remainingTokens?: number;
}
interface TitleErrorResponse {
  error: string;
}
interface DailyRequest {
  startDate: string;
  view: "0" | "1";
}
type DailyResponse = SuccessResponse<string>;
interface UsageRequest {}
type UsageResponse = SuccessResponse<{
  total: number;
  used: number;
  remaining: number;
  resetAt: Date;
}>;
interface RateLimit {
  maxTokens: number;
  currentTokens: number;
  remainingTokens: number;
  windowDuration: number;
  windowResetTime: number;
}
interface ConfigResponse {
  currentModel: string;
  availableModels: string[];
  rateLimit: RateLimit;
}
//#endregion
//#region src/modules/ai/index.d.ts
/**
 * AI module definition with nested AI-powered features
 */
declare const aiModule: ModuleDefinition<{
  chat: RouteDefinition<ChatRequest, Response>;
  summary: RouteDefinition<SummaryRequest, SummaryResponse>;
  translation: RouteDefinition<TranslationRequest, TranslationResponse>;
  summaryTitle: RouteDefinition<TitleRequest, TitleResponse>;
  daily: RouteDefinition<DailyRequest, DailyResponse>;
  usage: RouteDefinition<UsageRequest, UsageResponse>;
  config: RouteDefinition<never, ConfigResponse>;
}>;
type AIAPI = typeof aiModule.api;
//#endregion
//#region src/modules/boosts/types.d.ts
type User$2 = SerializedModel<InferSelectModel<typeof users>>;
interface GetFeedBoostLevelRequest extends FeedIdRequest {}
interface BoostFeedRequest extends FeedIdRequest {
  amount: string;
  TOTPCode?: string;
}
interface GetFeedBoostersRequest extends FeedIdRequest {}
interface FeedBoostLevelData {
  monthlyBoostCost: number;
  boostCount: number;
  level: number;
  remainingBoostsToLevelUp: number;
  lastValidBoost: {
    hash: string | null;
    expiresAt: string;
  } | null;
}
interface BoostFeedData {
  transactionHash: string;
  expiresAt: string;
}
type GetFeedBoostLevelResponse = SuccessResponse<FeedBoostLevelData>;
type BoostFeedResponse = SuccessResponse<BoostFeedData>;
type GetFeedBoostersResponse = SuccessResponse<Omit<User$2, "email">[]>;
//#endregion
//#region src/modules/boosts/index.d.ts
/**
 * Boosts module for content boosting with power tokens
 */
declare const boostsModule: ModuleDefinition<{
  getFeedBoostLevel: RouteDefinition<GetFeedBoostLevelRequest, GetFeedBoostLevelResponse>;
  boostFeed: RouteDefinition<BoostFeedRequest, BoostFeedResponse>;
  getFeedBoosters: RouteDefinition<GetFeedBoostersRequest, GetFeedBoostersResponse>;
}>;
type BoostsAPI = typeof boostsModule.api;
//#endregion
//#region src/modules/categories/types.d.ts
interface CategoriesGetQuery {
  view?: string;
}
type CategoriesGetResponse = SuccessResponse<string[]>;
interface CategoryPatchRequest {
  feedIdList: string[];
  category: string;
}
type CategoryPatchResponse = EmptyResponse;
interface CategoryDeleteRequest {
  feedIdList: string[];
  deleteSubscriptions: boolean;
}
type CategoryDeleteResponse = EmptyResponse;
//#endregion
//#region src/modules/categories/index.d.ts
/**
 * Categories module definition - Subscription categorization
 */
declare const categoriesModule: ModuleDefinition<{
  get: RouteDefinition<CategoriesGetQuery, CategoriesGetResponse>;
  update: RouteDefinition<CategoryPatchRequest, EmptyResponse>;
  delete: RouteDefinition<CategoryDeleteRequest, EmptyResponse>;
}>;
type CategoriesAPI = typeof categoriesModule.api;
//#endregion
//#region src/modules/collections/types.d.ts
interface CollectionCheckQuery extends EntryIdRequest {}
type CollectionCheckResponse = SuccessResponse<boolean>;
interface CollectionCreateRequest extends EntryIdRequest {
  view?: number;
}
type CollectionCreateResponse = EmptyResponse;
interface CollectionDeleteRequest extends EntryIdRequest {}
type CollectionDeleteResponse = EmptyResponse;
//#endregion
//#region src/modules/collections/index.d.ts
/**
 * Collections module definition - Content collections management
 */
declare const collectionsModule: ModuleDefinition<{
  get: RouteDefinition<CollectionCheckQuery, CollectionCheckResponse>;
  post: RouteDefinition<CollectionCreateRequest, EmptyResponse>;
  delete: RouteDefinition<CollectionDeleteRequest, EmptyResponse>;
}>;
type CollectionsAPI = typeof collectionsModule.api;
//#endregion
//#region src/modules/data/types.d.ts
interface ExportDataRequest {
  format?: string;
  type?: string;
}
type ExportDataResponse = SuccessResponse<string>;
//#endregion
//#region src/modules/data/index.d.ts
/**
 * Data module for data export operations
 */
declare const dataModule: ModuleDefinition<{
  export: RouteDefinition<ExportDataRequest, ExportDataResponse>;
}>;
type DataAPI = typeof dataModule.api;
//#endregion
//#region src/modules/discover/types.d.ts
interface DiscoverRequest {
  keyword: string;
  target?: "feeds" | "lists";
}
interface FeedDiscoveryResult {
  type: "feed";
  id: string;
  url: string;
  title: string | null;
  description: string | null;
  siteUrl: string | null;
  image: string | null;
  ownerUserId?: string;
  owner?: {
    id: string;
    name: string;
    handle: string;
    avatar: string | null;
  };
}
interface ListDiscoveryResult {
  type: "list";
  id: string;
  title: string;
  description: string | null;
  image: string | null;
  view: number;
  fee: number;
  ownerUserId: string;
}
interface EntryData {
  id: string;
  title: string | null;
  content: string | null;
  description: string | null;
  publishedAt: string;
  url: string | null;
  author: string | null;
  feedId: string;
}
interface FeedAnalyticsData {
  feedId: string;
  subscriptionCount: number;
  updatesPerWeek: number;
  totalSubscriptions: number;
  weeklyGrowth: number;
}
interface DiscoveryItem {
  feed?: FeedDiscoveryResult;
  list?: ListDiscoveryResult;
  docs?: string;
  entries?: EntryData[];
  subscriptionCount?: number;
  updatesPerWeek?: number;
  analytics?: FeedAnalyticsData;
}
type DiscoverResponse = SuccessResponse<DiscoveryItem[]>;
interface RSSHubRoute {
  path: string;
  name: string;
  description: string;
  parameters?: Record<string, string>;
  example?: string;
}
type RSSHubResponse = SuccessResponse<RSSHubRoute[]>;
interface RSSHubRouteQuery {
  route: string;
}
interface RSSHubRouteData {
  route: string;
  name: string;
  description: string;
  parameters: Record<string, any>;
  examples: string[];
  documentation: string;
}
type RSSHubRouteResponse = SuccessResponse<RSSHubRouteData>;
interface RSSHubAnalyticsQuery {
  period?: "day" | "week" | "month";
}
interface RSSHubAnalyticsData {
  totalRoutes: number;
  activeRoutes: number;
  totalRequests: number;
  popularRoutes: Array<{
    route: string;
    requests: number;
    name: string;
  }>;
  usage: Array<{
    date: string;
    requests: number;
  }>;
}
type RSSHubAnalyticsResponse = SuccessResponse<RSSHubAnalyticsData>;
//#endregion
//#region src/modules/discover/index.d.ts
/**
 * Discover module definition - Feed and list discovery
 */
declare const discoverModule: ModuleDefinition<{
  discover: RouteDefinition<DiscoverRequest, DiscoverResponse>;
  rsshub: RouteDefinition<never, RSSHubResponse>;
  rsshubRoute: RouteDefinition<RSSHubRouteQuery, RSSHubRouteResponse>;
  rsshubAnalytics: RouteDefinition<RSSHubAnalyticsQuery, RSSHubAnalyticsResponse>;
}>;
type DiscoverAPI = typeof discoverModule.api;
//#endregion
//#region src/types/utils.d.ts
type Prettify<T> = { [K in keyof T]: T[K] } & {};
//#endregion
//#region src/modules/entries/types.d.ts
type FeedOpenApiSchema$1 = SerializedModel<FeedOpenApiSchema>;
type InboxOpenApiSchema$1 = SerializedModel<InboxOpenApiSchema>;
type EntryModel = SerializedModel<InferSelectModel<typeof entries>>;
type EntryInsert = SerializedInsertModel<InferInsertModel<typeof entries>>;
type UserModel = SerializedModel<InferSelectModel<typeof users>>;
type InboxModel$1 = SerializedModel<InferSelectModel<typeof inboxes>>;
interface EntryMedia {
  url: string;
  type: "photo" | "video";
  preview_image_url?: string;
  width?: number;
  height?: number;
  blurhash?: string;
}
interface EntryAttachment {
  url: string;
  title?: string;
  duration_in_seconds?: number;
  mime_type?: string;
  size_in_bytes?: number;
}
interface EntryGetQuery extends IdRequest {}
type EntryOpenAPISchema = SerializedModel<z$1.infer<typeof entriesOpenAPISchema>>;
type EntryGetByIdResponse = SuccessResponse<{
  feeds: FeedOpenApiSchema$1;
  entries: Prettify<Omit<EntryOpenAPISchema, "feedId">>;
} | null>;
interface EntryWithFeed extends EntryExtraResponse {
  read: boolean;
  view: FeedViewType$1;
  from: string[];
  feeds: FeedOpenApiSchema$1;
  entries: Prettify<Omit<EntryOpenAPISchema, "content" | "feedId">>;
}
type EntryListRequest = {
  view?: FeedViewType$1;
  feedId?: string;
  feedIdList?: string[];
  read?: boolean;
  limit?: number;
  publishedAfter?: DateISOString;
  publishedBefore?: DateISOString;
  isCollection?: boolean;
  isArchived?: boolean;
  withContent?: boolean;
  excludePrivate?: boolean;
};
type EntryListResponse = SuccessResponse<EntryWithFeed[]>;
interface EntryPreviewRequest extends IdRequest {}
type EntryPreviewResponse = SuccessResponse<z$1.infer<typeof entriesOpenAPISchema>>;
interface EntryReadabilityRequest extends IdRequest {}
type EntryReadabilityResponse = SuccessResponse<{
  content?: string;
} | null>;
interface EntryStreamRequest {
  ids: string[];
}
interface EntryStreamItem {
  id: string;
  content: string;
}
interface CheckNewEntriesQuery {
  view?: number;
  feedId?: string;
  feedIdList?: string[];
  read?: boolean;
  insertedAfter: number;
}
type CheckNewEntriesResponse = SuccessResponse<{
  has_new: boolean;
  lastest_at?: string;
  entry_id?: string;
}>;
interface ReadHistoriesQuery {
  page?: number;
  size?: number;
}
type ReadHistoriesResponse = SuccessResponse<{
  users: Record<string, Pick<UserModel, "id" | "handle" | "name" | "image">>;
  total: number;
  entryReadHistories: {
    userIds: string[];
    readCount: number;
  } | null;
}>;
interface InboxEntryGetQuery extends IdRequest {}
interface InboxListEntryRequestInput {
  inboxId: string;
  read?: boolean;
  limit?: number;
  publishedAfter?: string;
  publishedBefore?: string;
}
type EntrySettings = SettingsModel$1;
interface EntryExtraResponse {
  collections?: Prettify<Pick<z$1.infer<typeof collectionsOpenAPISchema>, "createdAt">>;
  settings?: EntrySettings;
}
interface InboxListEntry extends EntryExtraResponse {
  read: boolean;
  feeds: InboxOpenApiSchema$1;
  entries: Prettify<Omit<z$1.infer<typeof inboxesEntriesOpenAPISchema>, "content">>;
}
type InboxListEntryResponse = SuccessResponse<InboxListEntry[]>;
interface InboxEntryGetResponse {
  data: {
    entries: EntryModel;
    feed: Pick<InboxModel$1, "secret" | "title"> & {
      type: "inbox";
      id: string;
    };
  };
}
interface MarkReadInput extends IdRequest {}
interface MarkUnreadInput extends IdRequest {}
interface ReadHistoriesInput extends IdRequest {
  page?: number;
  size?: number;
}
interface InboxRemoveInput extends EntryIdRequest {}
//#endregion
//#region src/modules/entries/index.d.ts
/**
 * Entries module definition with nested routes
 */
declare const entriesModule: ModuleDefinition<{
  get: RouteDefinition<EntryGetQuery, EntryGetByIdResponse>;
  list: RouteDefinition<EntryListRequest, EntryListResponse>;
  preview: RouteDefinition<EntryPreviewRequest, EntryPreviewResponse>;
  readability: RouteDefinition<EntryReadabilityRequest, EntryReadabilityResponse>;
  stream: RouteDefinition<EntryStreamRequest, Response>;
  checkNew: RouteDefinition<CheckNewEntriesQuery, CheckNewEntriesResponse>;
  readHistories: RouteDefinition<ReadHistoriesInput, ReadHistoriesResponse>;
  inbox: {
    get: RouteDefinition<InboxEntryGetQuery, InboxEntryGetResponse>;
    list: RouteDefinition<InboxListEntryRequestInput, InboxListEntryResponse>;
    delete: RouteDefinition<InboxRemoveInput, SuccessResponse<any>>;
  };
}>;
type EntriesAPI = typeof entriesModule.api;
//#endregion
//#region src/modules/feeds/types.d.ts
type FeedModel = SerializedModel<InferSelectModel<typeof feeds>>;
interface FeedGetQuery {
  id?: string;
  url?: string;
  entriesLimit?: number;
}
interface FeedGetResponse {
  feed: FeedModel;
  entries?: any[];
  subscription?: any;
  readCount?: number;
  subscriptionCount?: number;
}
interface FeedRefreshRequest {
  url: string;
  force?: boolean;
}
interface FeedRefreshResponse {
  success: boolean;
  message?: string;
}
interface FeedAnalyticsQuery extends FeedIdRequest {
  timeRange?: "7d" | "30d" | "90d";
}
interface FeedAnalyticsResponse {
  views: number;
  subscribers: number;
  engagement: number;
  growth: number;
}
interface FeedResetRequest extends FeedIdRequest {
  reason?: string;
}
interface FeedResetResponse {
  success: boolean;
  message?: string;
}
interface FeedClaimChallengeRequest extends FeedIdRequest {
  challenge: string;
}
interface FeedClaimChallengeResponse {
  success: boolean;
  message?: string;
}
interface FeedClaimListQuery {
  page?: number;
  limit?: number;
  status?: "pending" | "approved" | "rejected";
}
interface FeedClaimItem {
  id: string;
  feedId: string;
  userId: string;
  status: "pending" | "approved" | "rejected";
  createdAt: string;
  updatedAt: string;
}
interface FeedClaimListResponse {
  claims: FeedClaimItem[];
  pagination: {
    page: number;
    limit: number;
    total: number;
    hasMore: boolean;
  };
}
interface FeedClaimMessageRequest extends FeedIdRequest {
  message: string;
}
interface FeedClaimMessageResponse {
  success: boolean;
  message?: string;
}
//#endregion
//#region src/modules/inboxes/types.d.ts
type InboxModel = SerializedModel<InferSelectModel<typeof inboxes>>;
interface InboxTarget extends InboxModel {
  type: "inbox";
}
interface InboxGetQuery {
  handle: string;
}
type InboxGetResponse = SuccessResponse<InboxTarget>;
type InboxListResponse = PaginatedResponse<InboxTarget>;
interface InboxCreateRequest {
  title: string;
  handle: string;
  description?: string;
  image?: string;
}
type InboxCreateResponse = SuccessResponse<InboxTarget>;
interface InboxUpdateRequest {
  id: string;
  title?: string;
  description?: string;
  image?: string;
}
type InboxUpdateResponse = SuccessResponse<InboxTarget>;
interface InboxDeleteRequest {
  id: string;
}
type InboxDeleteResponse = EmptyResponse;
interface InboxEmailRequest {
  inboxId: string;
  action: "enable" | "disable" | "regenerate";
}
interface InboxEmailData {
  email: string;
  enabled: boolean;
  lastUsed?: string;
}
type InboxEmailResponse = SuccessResponse<InboxEmailData>;
interface InboxWebhookRequest {
  inboxId: string;
  url?: string;
  secret?: string;
  enabled?: boolean;
}
interface InboxWebhookData {
  url: string;
  secret: string;
  enabled: boolean;
  lastTriggered?: string;
}
type InboxWebhookResponse = SuccessResponse<InboxWebhookData>;
//#endregion
//#region src/modules/inboxes/index.d.ts
/**
 * Inboxes module definition - Email inboxes management
 */
declare const inboxesModule: ModuleDefinition<{
  get: RouteDefinition<InboxGetQuery, InboxGetResponse>;
  list: RouteDefinition<never, InboxListResponse>;
  post: RouteDefinition<InboxCreateRequest, InboxCreateResponse>;
  put: RouteDefinition<InboxUpdateRequest, InboxUpdateResponse>;
  delete: RouteDefinition<InboxDeleteRequest, EmptyResponse>;
  email: RouteDefinition<InboxEmailRequest, InboxEmailResponse>;
  webhook: RouteDefinition<InboxWebhookRequest, InboxWebhookResponse>;
}>;
type InboxesAPI = typeof inboxesModule.api;
//#endregion
//#region src/modules/invitations/types.d.ts
type Invitation = SerializedModel<InferSelectModel<typeof invitations>>;
type User$1 = SerializedModel<InferSelectModel<typeof users>>;
interface CreateInvitationRequest {
  TOTPCode?: string;
}
interface UseInvitationRequest {
  code: string;
}
interface InvitationWithUser extends Omit<Invitation, "fromUserId"> {
  fromUser: Pick<User$1, "id" | "name" | "image">;
}
type GetInvitationLimitationResponse = SuccessResponse<number>;
type GetInvitationsListResponse = SuccessResponse<InvitationWithUser[]>;
type CreateInvitationResponse = SuccessResponse<string>;
type UseInvitationResponse = SuccessResponse<null>;
//#endregion
//#region src/modules/invitations/index.d.ts
/**
 * Invitations module for managing invitation codes
 */
declare const invitationsModule: ModuleDefinition<{
  getLimitation: RouteDefinition<never, GetInvitationLimitationResponse>;
  list: RouteDefinition<never, GetInvitationsListResponse>;
  create: RouteDefinition<CreateInvitationRequest, CreateInvitationResponse>;
  use: RouteDefinition<UseInvitationRequest, UseInvitationResponse>;
}>;
type InvitationsAPI = typeof invitationsModule.api;
//#endregion
//#region src/modules/lists/types.d.ts
type ListModel = SerializedModel<InferSelectModel<typeof lists>>;
type ListInsert = SerializedInsertModel<InferInsertModel<typeof lists>>;
type ListSubscriptionModel = SerializedModel<InferSelectModel<typeof listsSubscriptions>>;
type ListVisibility = "public" | "private" | "unlisted";
type ListPermission = "read" | "write" | "admin";
interface List extends ListModel {
  feedCount?: number;
  subscriberCount?: number;
  isOwner?: boolean;
  isSubscribed?: boolean;
  permission?: ListPermission;
  owner?: {
    id: string;
    name: string | null;
    handle: string | null;
    avatar: string | null;
  };
}
interface CreateListRequest {
  title: string;
  description?: string;
  visibility?: ListVisibility;
  image?: string;
  feedIds?: string[];
}
interface UpdateListRequest {
  title?: string;
  description?: string;
  visibility?: ListVisibility;
  image?: string;
}
interface ListFeed {
  id: string;
  feedId: string;
  listId: string;
  order: number;
  addedAt: string;
  feed: {
    id: string;
    title: string;
    description?: string;
    image?: string;
    url: string;
    category?: string;
    subscriberCount?: number;
  };
}
interface AddFeedRequest {
  feedId: string;
  order?: number;
}
interface UpdateFeedOrderRequest {
  feeds: Array<{
    feedId: string;
    order: number;
  }>;
}
interface ListEntry {
  id: string;
  title: string;
  description?: string;
  content?: string;
  url: string;
  publishedAt: string;
  readAt?: string;
  starred?: boolean;
  feed: {
    id: string;
    title: string;
    image?: string;
  };
  author?: {
    name: string;
    email?: string;
    url?: string;
  };
}
interface ShareListRequest {
  visibility: ListVisibility;
  shareCode?: string;
  permissions?: {
    allowComments?: boolean;
    allowSubscribe?: boolean;
    allowCopy?: boolean;
  };
}
interface ListPermissions {
  visibility: ListVisibility;
  shareCode?: string;
  permissions: {
    allowComments: boolean;
    allowSubscribe: boolean;
    allowCopy: boolean;
  };
  collaborators: Array<{
    userId: string;
    permission: ListPermission;
    addedAt: string;
    user: {
      id: string;
      name: string | null;
      handle: string | null;
      avatar: string | null;
    };
  }>;
}
interface UpdatePermissionsRequest {
  visibility?: ListVisibility;
  permissions?: {
    allowComments?: boolean;
    allowSubscribe?: boolean;
    allowCopy?: boolean;
  };
  collaborators?: Array<{
    userId: string;
    permission: ListPermission;
  }>;
}
interface ListSubscriber {
  id: string;
  userId: string;
  subscribedAt: string;
  user: {
    id: string;
    name: string | null;
    handle: string | null;
    avatar: string | null;
  };
}
interface DiscoverList {
  id: string;
  title: string;
  description?: string;
  image?: string;
  visibility: ListVisibility;
  feedCount: number;
  subscriberCount: number;
  createdAt: string;
  updatedAt: string;
  owner: {
    id: string;
    name: string | null;
    handle: string | null;
    avatar: string | null;
  };
  tags: string[];
  category?: string;
}
interface ImportListRequest {
  title: string;
  description?: string;
  feedUrls: string[];
  visibility?: ListVisibility;
}
interface ExportFormat {
  format: "opml" | "json" | "csv";
  includeMetadata?: boolean;
}
interface ListAnalytics {
  views: {
    total: number;
    unique: number;
    thisWeek: number;
    thisMonth: number;
  };
  subscribers: {
    total: number;
    new: number;
    growth: number;
  };
  engagement: {
    avgReadTime: number;
    readRate: number;
    shareRate: number;
  };
  topFeeds: Array<{
    feedId: string;
    title: string;
    views: number;
    reads: number;
  }>;
  traffic: Array<{
    date: string;
    views: number;
    uniqueViews: number;
  }>;
}
interface ListsQuery {
  listId: string;
  noExtras?: boolean;
}
interface ListFeedsQuery {
  limit?: number;
  page?: number;
  sort?: "order" | "added" | "title";
  order?: "asc" | "desc";
}
interface ListEntriesQuery {
  read?: boolean;
  starred?: boolean;
  feedId?: string;
  since?: string;
  until?: string;
  limit?: number;
  page?: number;
  sort?: "published" | "added" | "title";
  order?: "asc" | "desc";
}
interface SubscribersQuery {
  limit?: number;
  page?: number;
  sort?: "subscribed" | "name";
  order?: "asc" | "desc";
}
interface DiscoverQuery {
  category?: string;
  search?: string;
  minFeeds?: number;
  minSubscribers?: number;
  limit?: number;
  page?: number;
  sort?: "title" | "created" | "subscribers" | "feeds" | "relevance";
  order?: "asc" | "desc";
}
interface TrendingQuery {
  period?: "day" | "week" | "month";
  category?: string;
  limit?: number;
  page?: number;
}
interface AnalyticsQuery {
  period?: "day" | "week" | "month" | "year";
  since?: string;
  until?: string;
}
type ListResponse = SuccessResponse<List>;
type ListsResponse = PaginatedResponse<List>;
type ListFeedsResponse = PaginatedResponse<ListFeed>;
type ListEntriesResponse = PaginatedResponse<ListEntry>;
type ListPermissionsResponse = SuccessResponse<ListPermissions>;
type ListSubscribersResponse = PaginatedResponse<ListSubscriber>;
type DiscoverListsResponse = PaginatedResponse<DiscoverList>;
type TrendingListsResponse = PaginatedResponse<DiscoverList>;
type ListAnalyticsResponse = SuccessResponse<ListAnalytics>;
type ExportResponse = SuccessResponse<{
  url: string;
}>;
interface RemoveFeedInput {
  id: string;
  feedId: string;
}
interface ExportInput {
  id: string;
  format: "opml" | "json" | "csv";
  includeMetadata?: boolean;
}
interface GetAnalyticsInput {
  id: string;
  period?: "day" | "week" | "month" | "year";
  since?: string;
  until?: string;
}
//#endregion
//#region src/modules/lists/index.d.ts
/**
 * Lists module definition with nested routes
 */
declare const listsModule: ModuleDefinition<{
  list: RouteDefinition<ListsQuery, ListsResponse>;
  create: RouteDefinition<CreateListRequest, ListResponse>;
  removeFeed: RouteDefinition<RemoveFeedInput, EmptyResponse>;
  discover: RouteDefinition<DiscoverQuery, DiscoverListsResponse>;
  trending: RouteDefinition<TrendingQuery, TrendingListsResponse>;
  import: RouteDefinition<ImportListRequest, ListResponse>;
  export: RouteDefinition<ExportInput, ExportResponse>;
  getAnalytics: RouteDefinition<GetAnalyticsInput, ListAnalyticsResponse>;
}>;
type ListsAPI = typeof listsModule.api;
//#endregion
//#region src/modules/mcp/types.d.ts
type McpTransportType = "streamable-http" | "sse";
interface McpConnectionInfo {
  id: string;
  name: string;
  transportType: McpTransportType;
  url?: string;
  isConnected: boolean;
  lastError?: string;
  toolCount: number;
  resourceCount: number;
  promptCount: number;
  createdAt: string;
  lastUsed: string | null;
}
interface McpTool {
  name: string;
  title?: string;
  description?: string;
  inputSchema: {
    type: "object";
    properties?: Record<string, any>;
    required?: string[];
  };
  outputSchema?: {
    type: "object";
    properties?: Record<string, any>;
    required?: string[];
  };
  annotations?: {
    title?: string;
    readOnlyHint?: boolean;
    openWorldHint?: boolean;
  };
}
interface RefreshResult {
  success: boolean;
  error?: string;
}
interface CreateConnectionRequest {
  name: string;
  transportType: McpTransportType;
  url: string;
  headers?: Record<string, string>;
}
interface UpdateConnectionRequest {
  name?: string;
  transportType?: McpTransportType;
  url?: string;
  headers?: Record<string, string>;
  connectionId: string;
}
type UpdateConnectionResponse = {
  code: 0 | 1;
  /**
   * If code is 1, the authorizationUrl is required
   */
  authorizationUrl?: string;
};
interface ConnectionParams {
  connectionId: string;
}
interface RefreshToolsRequest {
  connectionIds?: string[];
}
type CreateConnectionResponse = {
  /**
   * 0: success, 1: need oauth
   */
  code: 0 | 1;
  authorizationUrl?: string;
};
type GetConnectionsResponse = SuccessResponse<McpConnectionInfo[]>;
type DeleteConnectionResponse = SuccessResponse;
type GetToolsResponse = SuccessResponse<McpTool[]>;
type RefreshToolsResponse = SuccessResponse<{
  total: number;
  successful: number;
  failed: number;
  results: RefreshResult[];
}>;
//#endregion
//#region src/modules/messaging/types.d.ts
type MessagingToken = SerializedModel<InferSelectModel<typeof messaging>>;
type MessagingChannel = "macos" | "windows" | "linux" | "ios" | "android" | "web" | "desktop";
interface CreateMessagingTokenRequest {
  token: string;
  channel: MessagingChannel;
}
interface DeleteMessagingTokenRequest {
  channel: MessagingChannel;
}
interface TestMessagingRequest {
  channel?: string;
}
type GetMessagingTokensResponse = SuccessResponse<MessagingToken[]>;
type CreateMessagingTokenResponse = EmptyResponse;
type DeleteMessagingTokenResponse = EmptyResponse;
type TestMessagingResponse = EmptyResponse;
//#endregion
//#region src/modules/messaging/index.d.ts
/**
 * Messaging module for push notification management
 */
declare const messagingModule: ModuleDefinition<{
  getTokens: RouteDefinition<never, GetMessagingTokensResponse>;
  createToken: RouteDefinition<CreateMessagingTokenRequest, EmptyResponse>;
  deleteToken: RouteDefinition<DeleteMessagingTokenRequest, EmptyResponse>;
}>;
type MessagingAPI = typeof messagingModule.api;
//#endregion
//#region src/modules/profiles/types.d.ts
type User = SerializedModel<InferSelectModel<typeof users>>;
type UserProfile = Omit<User, "email">;
interface GetProfileRequest {
  id?: string;
  handle?: string;
}
interface GetProfilesBatchRequest {
  ids: string[];
}
type GetProfileResponse = SuccessResponse<UserProfile>;
type GetProfilesBatchResponse = SuccessResponse<Record<string, UserProfile>>;
//#endregion
//#region src/modules/profiles/index.d.ts
/**
 * Profiles module for user profile management
 */
declare const profilesModule: ModuleDefinition<{
  getProfile: RouteDefinition<GetProfileRequest, GetProfileResponse>;
  getBatch: RouteDefinition<GetProfilesBatchRequest, GetProfilesBatchResponse>;
}>;
type ProfilesAPI = typeof profilesModule.api;
//#endregion
//#region src/modules/probes/types.d.ts
interface CheckBullMQRequest {
  name: "follow-queue" | "admin-wallet-queue";
}
interface GetRSSHubAnalyticsRequest {
  namespace?: string;
  route?: string;
}
interface BullMQStatus {
  current: {
    wait: number;
    completed: number;
    failed: number;
  };
  metrics: {
    completed: {
      data: number[];
      count: number;
    };
    failed: {
      data: number[];
      count: number;
    };
  };
}
interface RSSHubAnalyticsItem {
  successCount: number;
  errorCount: number;
  timestamp: string;
  successRate: number;
}
type CheckPostgreSQLResponse = SuccessResponse<number>;
type CheckRedisResponse = SuccessResponse<number>;
type CheckBullMQResponse = SuccessResponse<BullMQStatus>;
type GetRSSHubAnalyticsResponse = SuccessResponse<RSSHubAnalyticsItem[]>;
//#endregion
//#region src/modules/probes/index.d.ts
/**
 * Probes module for health checks and system monitoring
 */
declare const probesModule: ModuleDefinition<{
  checkPostgreSQL: RouteDefinition<never, CheckPostgreSQLResponse>;
  checkRedis: RouteDefinition<never, CheckRedisResponse>;
  checkBullMQ: RouteDefinition<CheckBullMQRequest, CheckBullMQResponse>;
  getRSSHubAnalytics: RouteDefinition<GetRSSHubAnalyticsRequest, GetRSSHubAnalyticsResponse>;
}>;
type ProbesAPI = typeof probesModule.api;
//#endregion
//#region src/modules/reads/types.d.ts
/**
 * Query parameters for getting read status
 */
interface ReadStatusQuery {
  view?: FeedViewType$1;
}
type ReadStatusResponse = SuccessResponse<Record<string, number>>;
/**
 * Request to mark entries as read
 */
interface MarkAsReadRequest {
  entryIds: string[];
  isInbox?: boolean;
  readHistories?: string[];
}
/**
 * Request to mark single entry as unread
 */
interface MarkAsUnreadRequest {
  entryId: string;
  isInbox?: boolean;
}
/**
 * Request to mark all entries as read (batch operation)
 */
interface MarkAllAsReadRequest {
  view?: number;
  feedId?: string;
  listId?: string;
  inboxId?: string;
  feedIdList?: string[];
  startTime?: number;
  endTime?: number;
  excludePrivate?: boolean;
  insertedBefore?: number;
}
/**
 * Response for mark all as read operation
 */
type MarkAllAsReadResponse = SuccessResponse<{
  read: Record<string, number>;
}>;
/**
 * Response for basic read operations
 */
type ReadOperationResponse = SuccessResponse<null>;
/**
 * Response for total unread count
 */
type TotalUnreadCountResponse = SuccessResponse<{
  count: number;
}>;
//#endregion
//#region src/modules/reads/index.d.ts
/**
 * Reads module definition with nested routes
 */
declare const readsModule: ModuleDefinition<{
  get: RouteDefinition<ReadStatusQuery, ReadStatusResponse>;
  markAsRead: RouteDefinition<MarkAsReadRequest, ReadOperationResponse>;
  markAsUnread: RouteDefinition<MarkAsUnreadRequest, ReadOperationResponse>;
  markAllAsRead: RouteDefinition<MarkAllAsReadRequest, MarkAllAsReadResponse>;
  getTotalCount: RouteDefinition<never, TotalUnreadCountResponse>;
}>;
type ReadsAPI = typeof readsModule.api;
//#endregion
//#region src/modules/referrals/types.d.ts
interface GetReferralDaysRequest {
  code: string;
}
interface VerifyReceiptRequest {
  appReceipt: string;
}
interface ReferralUser {
  id: string;
  name: string | null;
  image: string | null;
}
interface ReferralInvitation {
  code: string;
  createdAt: DateISOString | null;
  usedAt: DateISOString | null;
  toUserId: string | null;
  user: ReferralUser | null;
}
interface ReferralsData {
  referralCycleDays: number;
  invitations: ReferralInvitation[];
}
interface ReferralDaysData {
  referralCycleDays: number;
}
type GetReferralsResponse = SuccessResponse<ReferralsData>;
type GetReferralDaysResponse = SuccessResponse<ReferralDaysData>;
//#endregion
//#region src/modules/rsshub/types.d.ts
interface CreateRSSHubInstanceRequest {
  id?: string;
  baseUrl: string;
  accessKey?: string;
}
interface DeleteRSSHubInstanceRequest {
  id: string;
}
interface UseRSSHubInstanceRequest {
  id: string | null;
  durationInMonths?: number;
  twoFactorCode?: string;
  backupCode?: string;
}
interface GetRSSHubInstanceRequest {
  id: string;
}
interface RSSHubInstanceOwner {
  id: string;
  handle: string | null;
  name: string | null;
  image: string | null;
}
interface RSSHubInstanceListItem {
  id: string;
  ownerUserId: string;
  price: number;
  userLimit: number | null;
  description: string | null;
  errorMessage: string | null;
  errorAt: DateISOString | null;
  userCount: number;
  owner: RSSHubInstanceOwner | null;
}
interface RSSHubInstanceDetails {
  id: string;
  ownerUserId: string;
  price: number;
  userLimit: number | null;
  description: string | null;
  errorAt: DateISOString | null;
  errorMessage: string | null;
  baseUrl?: string | null;
  accessKey?: string | null;
}
interface RSSHubPurchase {
  hash: string | null;
  expiresAt: string;
}
interface RSSHubInstanceData {
  instance: RSSHubInstanceDetails;
  purchase: RSSHubPurchase | null;
}
interface RSSHubUsage {
  id: string;
  rsshubId: string;
  userId: string;
}
interface RSSHubStatusData {
  usage?: RSSHubUsage;
  purchase: RSSHubPurchase | null;
}
type CreateRSSHubInstanceResponse = EmptyResponse;
type GetRSSHubInstancesListResponse = SuccessResponse<RSSHubInstanceListItem[]>;
type DeleteRSSHubInstanceResponse = EmptyResponse;
type UseRSSHubInstanceResponse = EmptyResponse;
type GetRSSHubInstanceResponse = SuccessResponse<RSSHubInstanceData>;
type GetRSSHubStatusResponse = SuccessResponse<RSSHubStatusData>;
//#endregion
//#region src/modules/rsshub/index.d.ts
/**
 * RSSHub module for RSSHub instance management
 */
declare const rsshubModule: ModuleDefinition<{
  createInstance: RouteDefinition<CreateRSSHubInstanceRequest, EmptyResponse>;
  listInstances: RouteDefinition<never, GetRSSHubInstancesListResponse>;
  deleteInstance: RouteDefinition<DeleteRSSHubInstanceRequest, EmptyResponse>;
  useInstance: RouteDefinition<UseRSSHubInstanceRequest, EmptyResponse>;
  getInstance: RouteDefinition<GetRSSHubInstanceRequest, GetRSSHubInstanceResponse>;
  getStatus: RouteDefinition<never, GetRSSHubStatusResponse>;
}>;
type RSSHubAPI = typeof rsshubModule.api;
//#endregion
//#region src/modules/settings/types.d.ts
type SettingsModel = SerializedModel<InferSelectModel<typeof settings>>;
type SettingsInsert = SerializedInsertModel<InferInsertModel<typeof settings>>;
type SettingsTab = "general" | "appearance" | "integration" | "ai";
type SettingsValue = Record<string, any>;
type SettingsPayload = Record<string, any>;
type SettingsGetResponse = SuccessResponse<{
  settings: Record<SettingsTab, SettingsPayload>;
  updated: Record<SettingsTab, string>;
}>;
interface SettingsGetQuery {
  tab?: string;
}
type SettingsUpdateRequest = Record<string, any>;
type SettingsUpdateResponse = SuccessResponse<null>;
interface GeneralSettings {
  language?: string;
  theme?: string;
  timezone?: string;
  notifications?: boolean;
  autoRefresh?: boolean;
  refreshInterval?: number;
  markAsReadOnScroll?: boolean;
  showUnreadCount?: boolean;
  defaultView?: number;
  compactMode?: boolean;
  [key: string]: any;
}
interface AppearanceSettings {
  fontSize?: number;
  fontFamily?: string;
  lineHeight?: number;
  colorScheme?: "light" | "dark" | "system";
  sidebarWidth?: number;
  contentWidth?: number;
  showSidebar?: boolean;
  showToolbar?: boolean;
  customCSS?: string;
  [key: string]: any;
}
interface IntegrationSettings {
  webhookUrl?: string;
  webhookEnabled?: boolean;
  emailNotifications?: boolean;
  pushNotifications?: boolean;
  slackWebhook?: string;
  discordWebhook?: string;
  telegramBotToken?: string;
  telegramChatId?: string;
  [key: string]: any;
}
interface AISettings {
  aiEnabled?: boolean;
  aiModel?: string;
  autoSummarize?: boolean;
  summaryLength?: "short" | "medium" | "long";
  translationEnabled?: boolean;
  targetLanguage?: string;
  sentimentAnalysis?: boolean;
  categoryPrediction?: boolean;
  [key: string]: any;
}
interface TypedSettings {
  general?: GeneralSettings;
  appearance?: AppearanceSettings;
  integration?: IntegrationSettings;
  ai?: AISettings;
}
interface SettingsMetadata {
  tab: SettingsTab;
  lastUpdated: string;
  version?: number;
}
interface SettingsManager {
  get: (tab?: SettingsTab) => Promise<SettingsGetResponse>;
  update: (tab: SettingsTab, payload: SettingsPayload) => Promise<SettingsUpdateResponse>;
  getTab: (tab: SettingsTab) => Promise<SettingsPayload>;
  setTab: (tab: SettingsTab, payload: SettingsPayload) => Promise<SettingsUpdateResponse>;
  reset: (tab: SettingsTab) => Promise<SettingsUpdateResponse>;
  export: () => Promise<TypedSettings>;
  import: (settings: TypedSettings) => Promise<SettingsUpdateResponse>;
}
interface SettingsOperationResult {
  success: boolean;
  error?: string;
  data?: any;
}
interface SettingsValidationResult {
  valid: boolean;
  errors: string[];
  warnings: string[];
}
interface SettingsDiff {
  added: Record<string, any>;
  modified: Record<string, any>;
  removed: string[];
}
interface SettingsHistoryEntry {
  timestamp: string;
  tab: SettingsTab;
  changes: SettingsDiff;
  version: number;
}
interface SettingsMigration {
  fromVersion: number;
  toVersion: number;
  migrationFn: (oldSettings: SettingsPayload) => SettingsPayload;
}
interface SettingsBackup {
  timestamp: string;
  version: number;
  settings: TypedSettings;
  metadata: SettingsMetadata[];
}
interface SettingsUpdateInput {
  tab: SettingsTab;
  [key: string]: any;
}
//#endregion
//#region src/modules/settings/index.d.ts
/**
 * Settings module definition with nested routes
 */
declare const settingsModule: ModuleDefinition<{
  get: RouteDefinition<SettingsGetQuery, SettingsGetResponse>;
  update: RouteDefinition<SettingsUpdateInput, SettingsUpdateResponse>;
}>;
type SettingsAPI = typeof settingsModule.api;
//#endregion
//#region src/modules/status/types.d.ts
declare namespace ServerConfig {
  type DailyClaimAmount = {
    trial: number;
    normal: number;
  };
  interface StatusConfigs {
    AI_CHAT_ENABLED: boolean;
    ANNOUNCEMENT: string;
    DAILY_CLAIM_AMOUNT: DailyClaimAmount;
    DAILY_POWER_PERCENTAGES: number[];
    DAILY_POWER_SUPPLY: number;
    IMPORTING_TITLE: string;
    INVITATION_ENABLED: boolean;
    INVITATION_INTERVAL_DAYS: number;
    INVITATION_PRICE: number;
    IS_RSS3_TESTNET: boolean;
    LEVEL_PERCENTAGES: number[];
    MAS_IN_REVIEW_VERSION?: string;
    MAX_ACTIONS: number;
    MAX_INBOXES: number;
    MAX_LISTS: number;
    MAX_SUBSCRIPTIONS: number;
    MAX_TRIAL_USER_FEED_SUBSCRIPTION: number;
    MAX_TRIAL_USER_LIST_SUBSCRIPTION: number;
    MAX_WEBHOOKS_PER_ACTION: number;
    PRODUCT_HUNT_VOTE_URL: string;
    REFERRAL_ENABLED: boolean;
    REFERRAL_PRO_PREVIEW_STRIPE_PRICE_IN_DOLLAR: number;
    REFERRAL_REQUIRED_INVITATIONS: number;
    REFERRAL_RULE_LINK: string;
    TAX_POINT: string;
  }
}
type GetStatusConfigsResponse = SuccessResponse<ServerConfig.StatusConfigs>;
//#endregion
//#region src/modules/status/index.d.ts
/**
 * Status module for system status and configuration
 */
declare const statusModule: ModuleDefinition<{
  getConfigs: RouteDefinition<never, GetStatusConfigsResponse>;
}>;
type StatusAPI = typeof statusModule.api;
//#endregion
//#region src/modules/subscriptions/types.d.ts
type SubscriptionModel = SerializedModel<InferSelectModel<typeof subscriptions>>;
type SubscriptionInsert = SerializedInsertModel<InferInsertModel<typeof subscriptions>>;
type ListModel$1 = SerializedModel<InferSelectModel<typeof lists>>;
interface SubscriptionWithFeed extends SubscriptionModel {
  feeds: FeedModel & {
    owner?: Omit<UserModel, "email">;
  };
  boost?: {
    boosters: UserModel[];
  };
}
interface ListSubscriptionResponse {
  lists: ListOpenApiSchema;
  category?: string;
  feedId: string;
  listId: string;
  title: string | null;
  userId: string;
  view: FeedViewType$1;
  isPrivate: boolean;
  hideFromTimeline: boolean | null;
  createdAt: string;
}
interface InboxSubscriptionResponse {
  inboxes: InboxOpenApiSchema;
  feedId: string;
  title: string | null;
  userId: string;
  inboxId: string;
  view: FeedViewType$1;
  category: string | null;
  isPrivate: boolean;
  hideFromTimeline: boolean | null;
  createdAt: string;
}
interface SubscriptionGetQuery {
  view?: FeedViewType$1;
  userId?: string;
}
type SubscriptionGetResponse = SuccessResponse<Array<SubscriptionWithFeed | ListSubscriptionResponse | InboxSubscriptionResponse>>;
interface SubscriptionCreateRequest {
  url?: string;
  listId?: string;
  view?: FeedViewType$1;
  category?: string | null;
  isPrivate?: boolean;
  title?: string | null;
  code?: string;
  type?: string;
}
type SubscriptionCreateResponse = {
  code: 0;
  feed: FeedModel | null;
  list: ListModel$1 | null;
  unread: Record<string, number>;
};
interface SubscriptionUpdateRequest {
  view?: number;
  category?: string | null;
  isPrivate?: boolean;
  hideFromTimeline?: boolean | null;
  title?: string | null;
  feedId?: string;
  listId?: string;
}
type SubscriptionUpdateResponse = SuccessResponse<SubscriptionModel>;
interface SubscriptionDeleteRequest {
  feedIdList?: string[];
  listId?: string;
  url?: string;
  feedId?: string;
}
type SubscriptionDeleteResponse = SuccessResponse<null>;
interface SubscriptionBatchRequest {
  feedIds: string[];
  view?: number;
  category?: string | null;
  isPrivate?: boolean;
  title?: string | null;
}
type SubscriptionBatchResponse = SuccessResponse<null>;
interface ParsedSubscription {
  userId: string;
  url: string;
  view: FeedViewType$1;
  category: string | null;
  title: string | null;
}
type SubscriptionParseOpmlResponse = SuccessResponse<{
  subscriptions: ParsedSubscription[];
  remaining: number;
}>;
interface ImportSuccessItem {
  id?: string;
  url?: string;
  title?: string | null;
}
interface ImportConflictItem {
  id: string;
  url: string;
  title?: string | null;
}
interface ImportErrorItem {
  id?: string;
  url: string;
  title?: string | null;
}
type SubscriptionImportResponse = SuccessResponse<{
  successfulItems: ImportSuccessItem[];
  conflictItems: ImportConflictItem[];
  parsedErrorItems: ImportErrorItem[];
}>;
interface SubscriptionExportQuery {
  format?: "opml" | "json";
  categoryId?: string;
  listId?: string;
}
interface SubscriptionExportResponse {
  content: string;
  contentType: string;
  filename: string;
}
//#endregion
//#region src/modules/subscriptions/index.d.ts
/**
 * Subscriptions module definition with nested routes
 */
declare const subscriptionsModule: ModuleDefinition<{
  get: RouteDefinition<SubscriptionGetQuery, SubscriptionGetResponse>;
  create: RouteDefinition<SubscriptionCreateRequest, SubscriptionCreateResponse>;
  update: RouteDefinition<SubscriptionUpdateRequest, SubscriptionUpdateResponse>;
  delete: RouteDefinition<SubscriptionDeleteRequest, SubscriptionDeleteResponse>;
  batchUpdate: RouteDefinition<SubscriptionBatchRequest, SubscriptionBatchResponse>;
  import: RouteDefinition<FormData, SubscriptionImportResponse>;
  export: RouteDefinition<SubscriptionExportQuery, SubscriptionExportResponse>;
  parseOpml: RouteDefinition<ArrayBuffer, SubscriptionParseOpmlResponse>;
}>;
type SubscriptionsAPI = typeof subscriptionsModule.api;
//#endregion
//#region src/modules/trending/types.d.ts
type Feed = SerializedModel<InferSelectModel<typeof feeds>>;
type FeedAnalytics = SerializedModel<InferSelectModel<typeof feedAnalytics>>;
interface GetTrendingFeedsRequest {
  language?: "eng" | "cmn";
  view?: number;
  range?: "1d" | "3d" | "7d" | "30d";
  limit?: number;
}
interface TrendingFeedItem {
  feedId: string;
  view: number | null;
  feed: Feed;
  analytics: FeedAnalytics;
}
type GetTrendingFeedsResponse = SuccessResponse<TrendingFeedItem[]>;
//#endregion
//#region src/modules/trending/index.d.ts
/**
 * Trending module for discovering trending feeds
 */
declare const trendingModule: ModuleDefinition<{
  getFeeds: RouteDefinition<GetTrendingFeedsRequest, GetTrendingFeedsResponse>;
}>;
type TrendingAPI = typeof trendingModule.api;
//#endregion
//#region src/modules/upload/types.d.ts
interface UploadAvatarRequest {
  file: File | Blob;
}
interface UploadChatAttachmentRequest {
  file: File | Blob;
}
type UploadAvatarResponse = {
  code: 0;
  url: string;
};
interface ChatAttachmentUploadData {
  url: string;
  filename: string;
  mimeType: string;
  size: number;
}
type UploadChatAttachmentResponse = SuccessResponse<ChatAttachmentUploadData>;
//#endregion
//#region src/modules/upload/index.d.ts
/**
 * Upload module for file uploads
 */
declare const uploadModule: ModuleDefinition<{
  uploadAvatar: RouteDefinition<UploadAvatarRequest, UploadAvatarResponse>;
  uploadChatAttachment: RouteDefinition<UploadChatAttachmentRequest, UploadChatAttachmentResponse>;
}>;
type UploadAPI = typeof uploadModule.api;
//#endregion
//#region src/modules/wallets/types.d.ts
type WalletModel = SerializedModel<InferSelectModel<typeof wallets>>;
type LevelModel = SerializedModel<InferSelectModel<typeof levels>>;
interface WalletWithLevel extends WalletModel {
  level: Pick<LevelModel, "level" | "rank" | "prevActivityPoints" | "activityPoints"> | null;
  todayDailyPower: string;
}
type WalletsGetResponse = SuccessResponse<WalletWithLevel[]>;
type WalletsPostResponse = SuccessResponse<WalletModel>;
type WalletsRefreshResponse = EmptyResponse;
interface WalletRankingQuery {
  limit?: number;
  offset?: number;
}
interface RankingItem {
  userId: string;
  username?: string;
  avatar?: string;
  balance: string;
  rank: number;
}
type WalletRankingResponse = SuccessResponse<RankingItem[]>;
interface PowerPriceData {
  price: number;
  currency: string;
  lastUpdated: string;
}
type PowerPriceResponse = SuccessResponse<PowerPriceData>;
interface TransactionQuery {
  page?: number;
  limit?: number;
  type?: "tip" | "withdraw" | "claim" | "airdrop";
}
interface TransactionItem {
  id: string;
  type: "tip" | "withdraw" | "claim" | "airdrop";
  amount: string;
  status: "pending" | "success" | "failed";
  hash?: string;
  createdAt: string;
  fromUserId?: string;
  toUserId?: string;
  entryId?: string;
}
type TransactionsGetResponse = SuccessResponse<TransactionItem[]>;
interface TipRequest {
  toUserId: string;
  amount: string;
  entryId?: string;
}
type TipResponse = SuccessResponse<{
  txHash: string;
}>;
type ClaimDailyResponse = SuccessResponse<{
  amount: string;
  txHash?: string;
}>;
interface WithdrawRequest {
  amount: string;
  toAddress: string;
}
type WithdrawResponse = SuccessResponse<{
  txHash: string;
}>;
interface ClaimCheckData {
  canClaim: boolean;
  lastClaimTime?: string;
  nextClaimTime?: string;
  amount?: string;
}
type ClaimCheckResponse = SuccessResponse<ClaimCheckData>;
interface AirdropData {
  isEligible: boolean;
  amount?: string;
  claimedAt?: string;
  requirements?: string[];
}
type AirdropGetResponse = SuccessResponse<AirdropData>;
type AirdropClaimResponse = SuccessResponse<{
  txHash: string;
  amount: string;
}>;
type AirdropUpdateResponse = EmptyResponse;
//#endregion
//#region src/modules/wallets/index.d.ts
/**
 * Wallets module definition - Web3 wallet operations and transactions
 */
declare const walletsModule: ModuleDefinition<{
  get: RouteDefinition<never, WalletsGetResponse>;
  post: RouteDefinition<never, WalletsPostResponse>;
  refresh: RouteDefinition<never, EmptyResponse>;
  ranking: RouteDefinition<WalletRankingQuery, WalletRankingResponse>;
  powerPrice: RouteDefinition<never, PowerPriceResponse>;
  transactions: {
    get: RouteDefinition<TransactionQuery, TransactionsGetResponse>;
    tip: RouteDefinition<TipRequest, TipResponse>;
    claimDaily: RouteDefinition<never, ClaimDailyResponse>;
    withdraw: RouteDefinition<WithdrawRequest, WithdrawResponse>;
    claimCheck: RouteDefinition<never, ClaimCheckResponse>;
  };
  airdrop: {
    get: RouteDefinition<never, AirdropGetResponse>;
    claim: RouteDefinition<never, AirdropClaimResponse>;
    update: RouteDefinition<never, EmptyResponse>;
  };
}>;
type WalletsAPI = typeof walletsModule.api;
//#endregion
//#region src/modules/registry.d.ts
/**
 * Central module registry
 * All modules now use the new unified system
 */
declare const moduleRegistry: {
  readonly achievement: ModuleDefinition<{
    list: RouteDefinition<ListAchievementsRequest, ListAchievementsResponse>;
    claim: RouteDefinition<ClaimAchievementRequest, ClaimAchievementResponse>;
    check: RouteDefinition<CheckAchievementRequest, CheckAchievementResponse>;
    audit: RouteDefinition<AuditAchievementRequest, EmptyResponse>;
  }>;
  readonly admin: ModuleDefinition<{
    featureFlags: {
      list: RouteDefinition<never, FeatureFlagListResponse>;
      update: RouteDefinition<FeatureFlagUpdateInput, FeatureFlagResponse>;
      override: RouteDefinition<UserOverrideInput, MessageResponse>;
      removeOverride: RouteDefinition<RemoveOverrideInput, MessageResponse>;
      stats: RouteDefinition<FeatureStatsInput, FeatureStatsResponse>;
      affectedUsers: RouteDefinition<AffectedUsersInput, AffectedUsersResponse>;
    };
    clean: {
      execute: RouteDefinition<CleanRequest, EmptyResponse>;
    };
    mint: {
      execute: RouteDefinition<MintRequest, MintResponse>;
    };
  }>;
  readonly ai: ModuleDefinition<{
    chat: RouteDefinition<ChatRequest, Response>;
    summary: RouteDefinition<SummaryRequest, SummaryResponse>;
    translation: RouteDefinition<TranslationRequest, TranslationResponse>;
    summaryTitle: RouteDefinition<TitleRequest, TitleResponse>;
    daily: RouteDefinition<DailyRequest, DailyResponse>;
    usage: RouteDefinition<UsageRequest, UsageResponse>;
    config: RouteDefinition<never, ConfigResponse>;
  }>;
  readonly boosts: ModuleDefinition<{
    getFeedBoostLevel: RouteDefinition<GetFeedBoostLevelRequest, GetFeedBoostLevelResponse>;
    boostFeed: RouteDefinition<BoostFeedRequest, BoostFeedResponse>;
    getFeedBoosters: RouteDefinition<GetFeedBoostersRequest, GetFeedBoostersResponse>;
  }>;
  readonly categories: ModuleDefinition<{
    get: RouteDefinition<CategoriesGetQuery, CategoriesGetResponse>;
    update: RouteDefinition<CategoryPatchRequest, EmptyResponse>;
    delete: RouteDefinition<CategoryDeleteRequest, EmptyResponse>;
  }>;
  readonly collections: ModuleDefinition<{
    get: RouteDefinition<CollectionCheckQuery, CollectionCheckResponse>;
    post: RouteDefinition<CollectionCreateRequest, EmptyResponse>;
    delete: RouteDefinition<CollectionDeleteRequest, EmptyResponse>;
  }>;
  readonly data: ModuleDefinition<{
    export: RouteDefinition<ExportDataRequest, ExportDataResponse>;
  }>;
  readonly discover: ModuleDefinition<{
    discover: RouteDefinition<DiscoverRequest, DiscoverResponse>;
    rsshub: RouteDefinition<never, RSSHubResponse>;
    rsshubRoute: RouteDefinition<RSSHubRouteQuery, RSSHubRouteResponse>;
    rsshubAnalytics: RouteDefinition<RSSHubAnalyticsQuery, RSSHubAnalyticsResponse>;
  }>;
  readonly entries: ModuleDefinition<{
    get: RouteDefinition<EntryGetQuery, EntryGetByIdResponse>;
    list: RouteDefinition<EntryListRequest, EntryListResponse>;
    preview: RouteDefinition<EntryPreviewRequest, EntryPreviewResponse>;
    readability: RouteDefinition<EntryReadabilityRequest, EntryReadabilityResponse>;
    stream: RouteDefinition<EntryStreamRequest, Response>;
    checkNew: RouteDefinition<CheckNewEntriesQuery, CheckNewEntriesResponse>;
    readHistories: RouteDefinition<ReadHistoriesInput, ReadHistoriesResponse>;
    inbox: {
      get: RouteDefinition<InboxEntryGetQuery, InboxEntryGetResponse>;
      list: RouteDefinition<InboxListEntryRequestInput, InboxListEntryResponse>;
      delete: RouteDefinition<InboxRemoveInput, SuccessResponse<any>>;
    };
  }>;
  readonly feeds: ModuleDefinition<{
    get: RouteDefinition<FeedGetQuery, FeedGetResponse>;
    refresh: RouteDefinition<FeedRefreshRequest, FeedRefreshResponse>;
    analytics: RouteDefinition<FeedAnalyticsQuery, FeedAnalyticsResponse>;
    reset: RouteDefinition<FeedResetRequest, FeedResetResponse>;
    claim: {
      challenge: RouteDefinition<FeedClaimChallengeRequest, FeedClaimChallengeResponse>;
      list: RouteDefinition<FeedClaimListQuery, FeedClaimListResponse>;
      message: RouteDefinition<FeedClaimMessageRequest, FeedClaimMessageResponse>;
    };
  }>;
  readonly inboxes: ModuleDefinition<{
    get: RouteDefinition<InboxGetQuery, InboxGetResponse>;
    list: RouteDefinition<never, InboxListResponse>;
    post: RouteDefinition<InboxCreateRequest, InboxCreateResponse>;
    put: RouteDefinition<InboxUpdateRequest, InboxUpdateResponse>;
    delete: RouteDefinition<InboxDeleteRequest, EmptyResponse>;
    email: RouteDefinition<InboxEmailRequest, InboxEmailResponse>;
    webhook: RouteDefinition<InboxWebhookRequest, InboxWebhookResponse>;
  }>;
  readonly invitations: ModuleDefinition<{
    getLimitation: RouteDefinition<never, GetInvitationLimitationResponse>;
    list: RouteDefinition<never, GetInvitationsListResponse>;
    create: RouteDefinition<CreateInvitationRequest, CreateInvitationResponse>;
    use: RouteDefinition<UseInvitationRequest, UseInvitationResponse>;
  }>;
  readonly lists: ModuleDefinition<{
    list: RouteDefinition<ListsQuery, ListsResponse>;
    create: RouteDefinition<CreateListRequest, ListResponse>;
    removeFeed: RouteDefinition<RemoveFeedInput, EmptyResponse>;
    discover: RouteDefinition<DiscoverQuery, DiscoverListsResponse>;
    trending: RouteDefinition<TrendingQuery, TrendingListsResponse>;
    import: RouteDefinition<ImportListRequest, ListResponse>;
    export: RouteDefinition<ExportInput, ExportResponse>;
    getAnalytics: RouteDefinition<GetAnalyticsInput, ListAnalyticsResponse>;
  }>;
  readonly mcp: ModuleDefinition<{
    createConnection: RouteDefinition<CreateConnectionRequest, CreateConnectionResponse>;
    updateConnection: RouteDefinition<UpdateConnectionRequest, UpdateConnectionResponse>;
    getConnections: RouteDefinition<never, GetConnectionsResponse>;
    deleteConnection: RouteDefinition<ConnectionParams, DeleteConnectionResponse>;
    getTools: RouteDefinition<ConnectionParams, GetToolsResponse>;
    refreshTools: RouteDefinition<RefreshToolsRequest, RefreshToolsResponse>;
  }>;
  readonly messaging: ModuleDefinition<{
    getTokens: RouteDefinition<never, GetMessagingTokensResponse>;
    createToken: RouteDefinition<CreateMessagingTokenRequest, EmptyResponse>;
    deleteToken: RouteDefinition<DeleteMessagingTokenRequest, EmptyResponse>;
  }>;
  readonly profiles: ModuleDefinition<{
    getProfile: RouteDefinition<GetProfileRequest, GetProfileResponse>;
    getBatch: RouteDefinition<GetProfilesBatchRequest, GetProfilesBatchResponse>;
  }>;
  readonly probes: ModuleDefinition<{
    checkPostgreSQL: RouteDefinition<never, CheckPostgreSQLResponse>;
    checkRedis: RouteDefinition<never, CheckRedisResponse>;
    checkBullMQ: RouteDefinition<CheckBullMQRequest, CheckBullMQResponse>;
    getRSSHubAnalytics: RouteDefinition<GetRSSHubAnalyticsRequest, GetRSSHubAnalyticsResponse>;
  }>;
  readonly reads: ModuleDefinition<{
    get: RouteDefinition<ReadStatusQuery, ReadStatusResponse>;
    markAsRead: RouteDefinition<MarkAsReadRequest, ReadOperationResponse>;
    markAsUnread: RouteDefinition<MarkAsUnreadRequest, ReadOperationResponse>;
    markAllAsRead: RouteDefinition<MarkAllAsReadRequest, MarkAllAsReadResponse>;
    getTotalCount: RouteDefinition<never, TotalUnreadCountResponse>;
  }>;
  readonly referrals: ModuleDefinition<{
    getReferrals: RouteDefinition<never, GetReferralsResponse>;
    getDays: RouteDefinition<GetReferralDaysRequest, GetReferralDaysResponse>;
    verifyReceipt: RouteDefinition<VerifyReceiptRequest, EmptyResponse>;
  }>;
  readonly rsshub: ModuleDefinition<{
    createInstance: RouteDefinition<CreateRSSHubInstanceRequest, EmptyResponse>;
    listInstances: RouteDefinition<never, GetRSSHubInstancesListResponse>;
    deleteInstance: RouteDefinition<DeleteRSSHubInstanceRequest, EmptyResponse>;
    useInstance: RouteDefinition<UseRSSHubInstanceRequest, EmptyResponse>;
    getInstance: RouteDefinition<GetRSSHubInstanceRequest, GetRSSHubInstanceResponse>;
    getStatus: RouteDefinition<never, GetRSSHubStatusResponse>;
  }>;
  readonly settings: ModuleDefinition<{
    get: RouteDefinition<SettingsGetQuery, SettingsGetResponse>;
    update: RouteDefinition<SettingsUpdateInput, SettingsUpdateResponse>;
  }>;
  readonly status: ModuleDefinition<{
    getConfigs: RouteDefinition<never, GetStatusConfigsResponse>;
  }>;
  readonly subscriptions: ModuleDefinition<{
    get: RouteDefinition<SubscriptionGetQuery, SubscriptionGetResponse>;
    create: RouteDefinition<SubscriptionCreateRequest, SubscriptionCreateResponse>;
    update: RouteDefinition<SubscriptionUpdateRequest, SubscriptionUpdateResponse>;
    delete: RouteDefinition<SubscriptionDeleteRequest, SubscriptionDeleteResponse>;
    batchUpdate: RouteDefinition<SubscriptionBatchRequest, SubscriptionBatchResponse>;
    import: RouteDefinition<FormData, SubscriptionImportResponse>;
    export: RouteDefinition<SubscriptionExportQuery, SubscriptionExportResponse>;
    parseOpml: RouteDefinition<ArrayBuffer, SubscriptionParseOpmlResponse>;
  }>;
  readonly trending: ModuleDefinition<{
    getFeeds: RouteDefinition<GetTrendingFeedsRequest, GetTrendingFeedsResponse>;
  }>;
  readonly upload: ModuleDefinition<{
    uploadAvatar: RouteDefinition<UploadAvatarRequest, UploadAvatarResponse>;
    uploadChatAttachment: RouteDefinition<UploadChatAttachmentRequest, UploadChatAttachmentResponse>;
  }>;
  readonly wallets: ModuleDefinition<{
    get: RouteDefinition<never, WalletsGetResponse>;
    post: RouteDefinition<never, WalletsPostResponse>;
    refresh: RouteDefinition<never, EmptyResponse>;
    ranking: RouteDefinition<WalletRankingQuery, WalletRankingResponse>;
    powerPrice: RouteDefinition<never, PowerPriceResponse>;
    transactions: {
      get: RouteDefinition<TransactionQuery, TransactionsGetResponse>;
      tip: RouteDefinition<TipRequest, TipResponse>;
      claimDaily: RouteDefinition<never, ClaimDailyResponse>;
      withdraw: RouteDefinition<WithdrawRequest, WithdrawResponse>;
      claimCheck: RouteDefinition<never, ClaimCheckResponse>;
    };
    airdrop: {
      get: RouteDefinition<never, AirdropGetResponse>;
      claim: RouteDefinition<never, AirdropClaimResponse>;
      update: RouteDefinition<never, EmptyResponse>;
    };
  }>;
};
/**
 * Type definition for the module registry
 */
type ModuleRegistry = typeof moduleRegistry;
/**
 * Generate API types from the registry
 */
type ModuleAPIs = { [K in keyof ModuleRegistry]: ModuleRegistry[K]["api"] };
//#endregion
//#region src/client/core.d.ts
/**
 * Configuration options for the Follow Client
 */
interface FollowClientConfig extends Partial<ClientConfig> {
  enableDefaultInterceptors?: boolean;
  authToken?: string;
}
declare class FollowClient {
  private httpClient;
  api: ModuleAPIs;
  constructor(config?: FollowClientConfig);
  /**
   * Initialize API route groups with proper typing
   */
  private initializeRoutes;
  /**
   * Setup default interceptors
   */
  private setupDefaultInterceptors;
  /**
   * Set authentication token for API requests
   */
  setAuthToken(token: string): void;
  /**
   * Remove authentication token
   */
  removeAuthToken(): void;
  /**
   * Set custom headers for API requests
   */
  setHeaders(headers: Record<string, string>): void;
  /**
   * Set custom fetch instance
   */
  setFetch(fetchInstance: typeof fetch): void;
  /**
   * Update client configuration
   */
  updateConfig(config: Partial<FollowClientConfig>): void;
  /**
   * Get current configuration (readonly)
   */
  getConfig(): Readonly<Required<ClientConfig>>;
  /**
   * Make a custom HTTP request using the underlying HTTP client
   * This allows direct access to the HTTP client for custom requests
   */
  request<T>(path: string, options?: RequestOptions): Promise<T>;
  /**
   * Batch multiple requests
   */
  batch<T extends readonly any[]>(requests: readonly [...T]): Promise<{ [K in keyof T]: Awaited<T[K]> }>;
  /**
   * Create a new instance with different configuration
   */
  clone(config?: Partial<FollowClientConfig>): FollowClient;
  /**
   * Add request interceptor
   */
  addRequestInterceptor(interceptor: RequestInterceptor): () => void;
  /**
   * Add response interceptor
   */
  addResponseInterceptor(interceptor: ResponseInterceptor): () => void;
  /**
   * Add error interceptor
   */
  addErrorInterceptor(interceptor: ErrorInterceptor): () => void;
}
//#endregion
//#region src/helper/index.d.ts
/**
 * Type guard to check if response is successful
 */
declare function isSuccessResponse<T>(response: ResponseStruct<T>): response is SuccessResponse<T>;
/**
 * Type guard to check if response is an error
 */
declare function isErrorResponse(response: ResponseStruct<any>): response is ErrorResponse;
/**
 * Extract data from successful response, throw error if unsuccessful
 */
declare function extractResponseData<T>(response: ResponseStruct<T>): T;
//#endregion
//#region src/modules/actions/types.d.ts
type ActionsGetResponse = SuccessResponse<ActionsModel | null>;
interface ActionsPutRequest {
  rules: ActionItem[];
}
//#endregion
//#region src/modules/actions/index.d.ts
/**
 * Actions module definition - User automation rules
 */
declare const actionsModule: ModuleDefinition<{
  get: RouteDefinition<never, ActionsGetResponse>;
  put: RouteDefinition<ActionsPutRequest, EmptyResponse>;
}>;
type ActionsAPI = typeof actionsModule.api;
//#endregion
//#region src/modules/feeds/index.d.ts
/**
 * Feeds module definition with nested routes
 */
declare const feedsModule: ModuleDefinition<{
  get: RouteDefinition<FeedGetQuery, FeedGetResponse>;
  refresh: RouteDefinition<FeedRefreshRequest, FeedRefreshResponse>;
  analytics: RouteDefinition<FeedAnalyticsQuery, FeedAnalyticsResponse>;
  reset: RouteDefinition<FeedResetRequest, FeedResetResponse>;
  claim: {
    challenge: RouteDefinition<FeedClaimChallengeRequest, FeedClaimChallengeResponse>;
    list: RouteDefinition<FeedClaimListQuery, FeedClaimListResponse>;
    message: RouteDefinition<FeedClaimMessageRequest, FeedClaimMessageResponse>;
  };
}>;
type FeedsAPI = typeof feedsModule.api;
//#endregion
//#region src/modules/referrals/index.d.ts
/**
 * Referrals module for referral system management
 */
declare const referralsModule: ModuleDefinition<{
  getReferrals: RouteDefinition<never, GetReferralsResponse>;
  getDays: RouteDefinition<GetReferralDaysRequest, GetReferralDaysResponse>;
  verifyReceipt: RouteDefinition<VerifyReceiptRequest, EmptyResponse>;
}>;
type ReferralsAPI = typeof referralsModule.api;
//#endregion
export { ACHIEVEMENTS_TYPES, AIAPI, AISettings, AchievementAPI, AchievementActionResult, AchievementType, AchievementWithPower, ActionsAPI, AddFeedRequest, AdminAPI, AffectedUser, AffectedUsersInput, AffectedUsersQuery, AffectedUsersResponse, AirdropClaimResponse, AirdropData, AirdropGetResponse, AirdropUpdateResponse, AnalyticsQuery, ApiRequest, ApiResponse, AppearanceSettings, AuditAchievementRequest, AuditAchievementResponse, BoostFeedData, BoostFeedRequest, BoostFeedResponse, BoostsAPI, BullMQStatus, CategoriesAPI, CategoriesGetQuery, CategoriesGetResponse, CategoryDeleteRequest, CategoryDeleteResponse, CategoryPatchRequest, CategoryPatchResponse, ChatAttachmentUploadData, ChatContext, ChatMessage, ChatRequest, ChatResponse, CheckAchievementRequest, CheckAchievementResponse, CheckBullMQRequest, CheckBullMQResponse, CheckNewEntriesQuery, CheckNewEntriesResponse, CheckPostgreSQLResponse, CheckRedisResponse, ClaimAchievementRequest, ClaimAchievementResponse, ClaimCheckData, ClaimCheckResponse, ClaimDailyResponse, CleanRequest, CleanResponse, ClientConfig, CollectionCheckQuery, CollectionCheckResponse, CollectionCreateRequest, CollectionCreateResponse, CollectionDeleteRequest, CollectionDeleteResponse, CollectionsAPI, ConfigResponse, CreateInvitationRequest, CreateInvitationResponse, CreateListRequest, CreateMessagingTokenRequest, CreateMessagingTokenResponse, CreateRSSHubInstanceRequest, CreateRSSHubInstanceResponse, DailyRequest, DailyResponse, DataAPI, DateISOString, DateToString, DeleteMessagingTokenRequest, DeleteMessagingTokenResponse, DeleteRSSHubInstanceRequest, DeleteRSSHubInstanceResponse, DiscoverAPI, DiscoverList, DiscoverListsResponse, DiscoverQuery, DiscoverRequest, DiscoverResponse, DiscoveryItem, EmptyResponse, EntriesAPI, EntryAttachment, EntryData, EntryExtraResponse, EntryGetByIdResponse, EntryGetQuery, EntryIdRequest, EntryInsert, EntryListRequest, EntryListResponse, EntryMedia, EntryModel, EntryOpenAPISchema, EntryPreviewRequest, EntryPreviewResponse, EntryReadabilityRequest, EntryReadabilityResponse, EntrySettings, EntryStreamItem, EntryStreamRequest, EntryStringKey, EntryWithFeed, ErrorResponse, ExceptionCodeMap, ExportDataRequest, ExportDataResponse, ExportFormat, ExportInput, ExportResponse, ExtractResponseData, FEATURE_NAMES, FeatureFlagInsert, FeatureFlagListResponse, FeatureFlagModel, FeatureFlagResponse, FeatureFlagUpdateInput, FeatureFlagUpdateRequest, FeatureName, FeatureStatsInput, FeatureStatsResponse, FeedAnalyticsData, FeedBoostLevelData, FeedDiscoveryResult, FeedIdRequest, FeedViewType, FeedsAPI, FollowAPIError, FollowAPIErrorResponse, FollowAPIResponse, FollowAuthError, FollowClient, FollowClientConfig, FollowTimeoutError, FollowValidationError, GeneralSettings, GetAnalyticsInput, GetFeedBoostLevelRequest, GetFeedBoostLevelResponse, GetFeedBoostersRequest, GetFeedBoostersResponse, GetInvitationLimitationResponse, GetInvitationsListResponse, GetMessagingTokensResponse, GetProfileRequest, GetProfileResponse, GetProfilesBatchRequest, GetProfilesBatchResponse, GetRSSHubAnalyticsRequest, GetRSSHubAnalyticsResponse, GetRSSHubInstanceRequest, GetRSSHubInstanceResponse, GetRSSHubInstancesListResponse, GetRSSHubStatusResponse, GetStatusConfigsResponse, GetTrendingFeedsRequest, GetTrendingFeedsResponse, HTTPMethod, IdRequest, ImportConflictItem, ImportErrorItem, ImportListRequest, ImportSuccessItem, InboxCreateRequest, InboxCreateResponse, InboxDeleteRequest, InboxDeleteResponse, InboxEmailData, InboxEmailRequest, InboxEmailResponse, InboxEntryGetQuery, InboxEntryGetResponse, InboxGetQuery, InboxGetResponse, InboxListEntry, InboxListEntryRequestInput, InboxListEntryResponse, InboxListResponse, InboxModel, InboxRemoveInput, InboxSubscriptionResponse, InboxTarget, InboxUpdateRequest, InboxUpdateResponse, InboxWebhookData, InboxWebhookRequest, InboxWebhookResponse, InboxesAPI, IntegrationSettings, InvitationWithUser, InvitationsAPI, LevelModel, List, ListAchievementsData, ListAchievementsRequest, ListAchievementsResponse, ListAnalytics, ListAnalyticsResponse, ListDiscoveryResult, ListEntriesQuery, ListEntriesResponse, ListEntry, ListFeed, ListFeedsQuery, ListFeedsResponse, ListIdRequest, ListInsert, ListModel, ListPermission, ListPermissions, ListPermissionsResponse, ListResponse, ListSubscriber, ListSubscribersResponse, ListSubscriptionModel, ListSubscriptionResponse, ListVisibility, ListsAPI, ListsQuery, ListsResponse, MarkAllAsReadRequest, MarkAllAsReadResponse, MarkAsReadRequest, MarkAsUnreadRequest, MarkReadInput, MarkUnreadInput, MessageResponse, MessagingAPI, MessagingChannel, MintRequest, MintResponse, ModuleAPIs, ModuleRegistry, NetworkError, PaginatedData, PaginatedResponse, PaginationParams, PaginationResponse, ParsedSubscription, PowerPriceData, PowerPriceResponse, ProbesAPI, ProfilesAPI, ROLLOUT_TYPES, RSSHubAPI, RSSHubAnalyticsData, RSSHubAnalyticsItem, RSSHubAnalyticsQuery, RSSHubAnalyticsResponse, RSSHubInstanceData, RSSHubInstanceDetails, RSSHubInstanceListItem, RSSHubInstanceOwner, RSSHubPurchase, RSSHubResponse, RSSHubRoute, RSSHubRouteData, RSSHubRouteQuery, RSSHubRouteResponse, RSSHubStatusData, RSSHubUsage, RankingItem, RateLimit, ReadHistoriesInput, ReadHistoriesQuery, ReadHistoriesResponse, ReadOperationResponse, ReadStatusQuery, ReadStatusResponse, ReadsAPI, ReferralsAPI, RemoveFeedInput, RemoveOverrideInput, RequestContentType, RequestOptions, ResponseContentType, ResponseStruct, RolloutType, RolloutValue, SETTINGS_TABS, SerializedInsertModel, SerializedModel, ServerConfig, SettingsAPI, SettingsBackup, SettingsDiff, SettingsGetQuery, SettingsGetResponse, SettingsHistoryEntry, SettingsInsert, SettingsManager, SettingsMetadata, SettingsMigration, SettingsModel, SettingsOperationResult, SettingsPayload, SettingsTab, SettingsUpdateInput, SettingsUpdateRequest, SettingsUpdateResponse, SettingsValidationResult, SettingsValue, ShareListRequest, StatusAPI, SubscribersQuery, SubscriptionBatchRequest, SubscriptionBatchResponse, SubscriptionCreateRequest, SubscriptionCreateResponse, SubscriptionDeleteRequest, SubscriptionDeleteResponse, SubscriptionExportQuery, SubscriptionExportResponse, SubscriptionGetQuery, SubscriptionGetResponse, SubscriptionImportResponse, SubscriptionInsert, SubscriptionModel, SubscriptionParseOpmlResponse, SubscriptionUpdateRequest, SubscriptionUpdateResponse, SubscriptionWithFeed, SubscriptionsAPI, SuccessResponse, SummaryRequest, SummaryResponse, TestMessagingRequest, TestMessagingResponse, TipRequest, TipResponse, TitleErrorResponse, TitleRequest, TitleResponse, TotalUnreadCountResponse, TransactionItem, TransactionQuery, TransactionsGetResponse, TranslationData, TranslationRequest, TranslationResponse, TrendingAPI, TrendingFeedItem, TrendingListsResponse, TrendingQuery, TypedSettings, UpdateFeedOrderRequest, UpdateListRequest, UpdatePermissionsRequest, UploadAPI, UploadAvatarRequest, UploadAvatarResponse, UploadChatAttachmentRequest, UploadChatAttachmentResponse, UsageRequest, UsageResponse, UseInvitationRequest, UseInvitationResponse, UseRSSHubInstanceRequest, UseRSSHubInstanceResponse, UserFeatureOverrideInsert, UserFeatureOverrideModel, UserIdRequest, UserModel, UserOverrideInput, UserOverrideRequest, UserProfile, WalletModel, WalletRankingQuery, WalletRankingResponse, WalletWithLevel, WalletsAPI, WalletsGetResponse, WalletsPostResponse, WalletsRefreshResponse, WithdrawRequest, WithdrawResponse, achievementModule, actionsModule, adminModule, aiModule, boostsModule, categoriesModule, collectionsModule, dataModule, discoverModule, entriesModule, extractResponseData, feedsModule, inboxesModule, invitationsModule, isErrorResponse, isSuccessResponse, listsModule, messagingModule, moduleRegistry, probesModule, profilesModule, readsModule, referralsModule, rsshubModule, settingsModule, statusModule, subscriptionsModule, trendingModule, uploadModule, walletsModule };
//# sourceMappingURL=index.d.cts.map