import { ACHIEVEMENTS_TYPES, FEATURE_NAMES, FeatureName, FeedViewType, FeedViewType as FeedViewType$1, SETTINGS_TABS, UserRole, UserRole as UserRole$1 } from "@folo-services/constants";
import { ExceptionCodeMap } from "@folo-services/exceptions";
import { ActionItem, ActionItem as ActionItem$1, ActionsModel, ActionsModel as ActionsModel$1, AiTaskOptions, AttachmentsModel, ExtraModel, MediaModel, SettingsModel as SettingsModel$1, TaskSchedule, TaskSchedule as TaskSchedule$1, UIMessageParts, aiTokens, collectionsOpenAPISchema, entries, entriesOpenAPISchema, featureFlags, feedAnalytics, feedAnalyticsOpenAPISchema, feeds, inboxesEntriesInsertOpenAPISchema, inboxesEntriesOpenAPISchema, languageSchema, listAnalyticsOpenAPISchema, lists, listsSubscriptions, listsSubscriptionsOpenAPISchema, messaging, rsshub, rsshubUsage, settings, subscriptions, subscriptionsOpenAPISchema, transactions, userFeatureOverrides, users, wallets } from "@folo-services/drizzle";
import z$1, { z } from "zod";
import { FeedOpenApiSchema, InboxOpenApiSchema, ListOpenApiSchema, StatusConfigs, StatusConfigs as StatusConfigs$1 } from "@folo-services/shared";

//#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" | "raw";
/**
 * Request options for API calls
 */
interface RequestOptions {
  method?: HTTPMethod;
  headers?: Record<string, string>;
  body?: unknown;
  query?: Record<string, string | number | boolean | string[]>;
  timeout?: number;
  signal?: AbortSignal;
  requestType?: RequestContentType;
  asRaw?: boolean;
}
/**
 * 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 StructuredSuccessResponse<T = any> extends ResponseStruct<T> {
  code: 0;
  data: T;
}
type PlainSuccessResponse<T = any> = {
  code: 0;
} & 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> = StructuredSuccessResponse<PaginatedData<T>>;
/**
 * Empty success response (for operations that don't return data)
 */
type EmptyResponse = StructuredSuccessResponse<null>;
//#endregion
//#region src/types/schemas.d.ts
/**
 * Shared schemas and common types for the Follow Client SDK
 */
/**
 * Two-factor authentication types
 * Based on the core application's TwoFactorObjectSchema
 */
interface TwoFactorAuth {
  /** 6-digit TOTP code for two-factor authentication */
  TOTPCode?: string;
}
//#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;
//#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;
  asRaw?: boolean;
}
/**
 * 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 };
//#endregion
//#region src/modules/actions/types.d.ts
type ActionsGetResponse = StructuredSuccessResponse<ActionsModel$1 | null>;
interface ActionsPutRequest {
  rules: ActionItem$1[];
}
type ActionsPutResponse = EmptyResponse;
type SupportedLanguages = z$1.infer<typeof languageSchema>;
type ActionId = Exclude<keyof ActionItem$1["result"], "disabled" | "blockRules">;
type ActionFilterItem = Partial<Exclude<ActionItem$1["condition"][number], {
  length: number;
}>>;
type ActionFeedField = Exclude<ActionFilterItem["field"], undefined>;
type ActionOperation = Exclude<ActionFilterItem["operator"], undefined>;
type ActionConditionIndex = {
  ruleIndex: number;
  groupIndex: number;
  conditionIndex: number;
};
//#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 ../../node_modules/drizzle-orm/entity.d.ts
declare const entityKind: unique symbol;
//#endregion
//#region ../../node_modules/drizzle-orm/casing.d.ts
declare class CasingCache {
  static readonly [entityKind]: string;
  private cachedTables;
  private convert;
  constructor(casing?: Casing);
  getColumnCasing(column: Column): string;
  private cacheTable;
  clearCache(): void;
}
//#endregion
//#region ../../node_modules/drizzle-orm/subquery.d.ts
interface Subquery<TAlias extends string = string, TSelectedFields extends Record<string, unknown> = Record<string, unknown>> extends SQLWrapper {}
declare class Subquery<TAlias extends string = string, TSelectedFields extends Record<string, unknown> = Record<string, unknown>> implements SQLWrapper {
  static readonly [entityKind]: string;
  _: {
    brand: 'Subquery';
    sql: SQL;
    selectedFields: TSelectedFields;
    alias: TAlias;
    isWith: boolean;
    usedTables?: string[];
  };
  constructor(sql: SQL, fields: TSelectedFields, alias: string, isWith?: boolean, usedTables?: string[]);
}
//#endregion
//#region ../../node_modules/drizzle-orm/table.d.ts
interface TableConfig<TColumn extends Column = Column<any>> {
  name: string;
  schema: string | undefined;
  columns: Record<string, TColumn>;
  dialect: string;
}
interface Table<T extends TableConfig = TableConfig> extends SQLWrapper {}
declare class Table<T extends TableConfig = TableConfig> implements SQLWrapper {
  static readonly [entityKind]: string;
  readonly _: {
    readonly brand: 'Table';
    readonly config: T;
    readonly name: T['name'];
    readonly schema: T['schema'];
    readonly columns: T['columns'];
    readonly inferSelect: InferSelectModel<Table<T>>;
    readonly inferInsert: InferInsertModel<Table<T>>;
  };
  readonly $inferSelect: InferSelectModel<Table<T>>;
  readonly $inferInsert: InferInsertModel<Table<T>>;
  constructor(name: string, schema: string | undefined, baseName: string);
}
type MapColumnName<TName extends string, TColumn extends Column, TDBColumNames extends boolean> = TDBColumNames extends true ? TColumn['_']['name'] : TName;
type InferModelFromColumns<TColumns extends Record<string, Column>, TInferMode extends 'select' | 'insert' = 'select', TConfig extends {
  dbColumnNames: boolean;
  override?: boolean;
} = {
  dbColumnNames: false;
  override: false;
}> = Simplify<TInferMode extends 'insert' ? { [Key in keyof TColumns & string as RequiredKeyOnly<MapColumnName<Key, TColumns[Key], TConfig['dbColumnNames']>, TColumns[Key]>]: GetColumnData<TColumns[Key], 'query'> } & { [Key in keyof TColumns & string as OptionalKeyOnly<MapColumnName<Key, TColumns[Key], TConfig['dbColumnNames']>, TColumns[Key], TConfig['override']>]?: GetColumnData<TColumns[Key], 'query'> | undefined } : { [Key in keyof TColumns & string as MapColumnName<Key, TColumns[Key], TConfig['dbColumnNames']>]: GetColumnData<TColumns[Key], 'query'> }>;
type InferSelectModel<TTable extends Table, TConfig extends {
  dbColumnNames: boolean;
} = {
  dbColumnNames: false;
}> = InferModelFromColumns<TTable['_']['columns'], 'select', TConfig>;
type InferInsertModel<TTable extends Table, TConfig extends {
  dbColumnNames: boolean;
  override?: boolean;
} = {
  dbColumnNames: false;
  override: false;
}> = InferModelFromColumns<TTable['_']['columns'], 'insert', TConfig>;
//#endregion
//#region ../../node_modules/drizzle-orm/operations.d.ts
type RequiredKeyOnly<TKey extends string, T extends Column> = T extends AnyColumn<{
  notNull: true;
  hasDefault: false;
}> ? TKey : never;
type OptionalKeyOnly<TKey extends string, T extends Column, OverrideT extends boolean | undefined = false> = TKey extends RequiredKeyOnly<TKey, T> ? never : T extends {
  _: {
    generated: undefined;
  };
} ? (T extends {
  _: {
    identity: undefined;
  };
} ? TKey : T['_']['identity'] extends 'always' ? OverrideT extends true ? TKey : never : TKey) : never;
//#endregion
//#region ../../node_modules/drizzle-orm/query-builders/select.types.d.ts
type JoinNullability = 'nullable' | 'not-null';
type ApplyNullability<T, TNullability extends JoinNullability> = TNullability extends 'nullable' ? T | null : TNullability extends 'null' ? null : T;
type ApplyNotNullMapToJoins<TResult, TNullabilityMap extends Record<string, JoinNullability>> = { [TTableName in keyof TResult & keyof TNullabilityMap & string]: ApplyNullability<TResult[TTableName], TNullabilityMap[TTableName]> } & {};
type SelectMode = 'partial' | 'single' | 'multiple';
type SelectResult<TResult, TSelectMode extends SelectMode, TNullabilityMap extends Record<string, JoinNullability>> = TSelectMode extends 'partial' ? SelectPartialResult<TResult, TNullabilityMap> : TSelectMode extends 'single' ? SelectResultFields<TResult> : ApplyNotNullMapToJoins<SelectResultFields<TResult>, TNullabilityMap>;
type SelectPartialResult<TFields, TNullability extends Record<string, JoinNullability>> = TNullability extends TNullability ? { [Key in keyof TFields]: TFields[Key] extends infer TField ? TField extends Table ? TField['_']['name'] extends keyof TNullability ? ApplyNullability<SelectResultFields<TField['_']['columns']>, TNullability[TField['_']['name']]> : never : TField extends Column ? TField['_']['tableName'] extends keyof TNullability ? ApplyNullability<SelectResultField<TField>, TNullability[TField['_']['tableName']]> : never : TField extends SQL | SQL.Aliased ? SelectResultField<TField> : TField extends Subquery ? FromSingleKeyObject<TField['_']['selectedFields'], TField['_']['selectedFields'] extends {
  [key: string]: infer TValue;
} ? SelectResultField<TValue> : never, 'You can only select one column in the subquery'> : TField extends Record<string, any> ? TField[keyof TField] extends AnyColumn<{
  tableName: infer TTableName extends string;
}> | SQL | SQL.Aliased ? Not<IsUnion<TTableName>> extends true ? ApplyNullability<SelectResultFields<TField>, TNullability[TTableName]> : SelectPartialResult<TField, TNullability> : never : never : never } : never;
type SelectResultField<T, TDeep extends boolean = true> = T extends DrizzleTypeError<any> ? T : T extends Table ? Equal<TDeep, true> extends true ? SelectResultField<T['_']['columns'], false> : never : T extends Column<any> ? GetColumnData<T> : T extends SQL | SQL.Aliased ? T['_']['type'] : T extends Record<string, any> ? SelectResultFields<T, true> : never;
type SelectResultFields<TSelectedFields, TDeep extends boolean = true> = Simplify<{ [Key in keyof TSelectedFields]: SelectResultField<TSelectedFields[Key], TDeep> }>;
//#endregion
//#region ../../node_modules/drizzle-orm/sql/sql.d.ts
/**
 * This class is used to indicate a primitive param value that is used in `sql` tag.
 * It is only used on type level and is never instantiated at runtime.
 * If you see a value of this type in the code, its runtime value is actually the primitive param value.
 */
declare class FakePrimitiveParam {
  static readonly [entityKind]: string;
}
interface BuildQueryConfig {
  casing: CasingCache;
  escapeName(name: string): string;
  escapeParam(num: number, value: unknown): string;
  escapeString(str: string): string;
  prepareTyping?: (encoder: DriverValueEncoder<unknown, unknown>) => QueryTypingsValue;
  paramStartIndex?: {
    value: number;
  };
  inlineParams?: boolean;
  invokeSource?: 'indexes' | undefined;
}
type QueryTypingsValue = 'json' | 'decimal' | 'time' | 'timestamp' | 'uuid' | 'date' | 'none';
interface Query {
  sql: string;
  params: unknown[];
}
interface QueryWithTypings extends Query {
  typings?: QueryTypingsValue[];
}
/**
 * Any value that implements the `getSQL` method. The implementations include:
 * - `Table`
 * - `Column`
 * - `View`
 * - `Subquery`
 * - `SQL`
 * - `SQL.Aliased`
 * - `Placeholder`
 * - `Param`
 */
interface SQLWrapper {
  getSQL(): SQL;
  shouldOmitSQLParens?(): boolean;
}
declare class StringChunk implements SQLWrapper {
  static readonly [entityKind]: string;
  readonly value: string[];
  constructor(value: string | string[]);
  getSQL(): SQL<unknown>;
}
declare class SQL<T = unknown> implements SQLWrapper {
  readonly queryChunks: SQLChunk[];
  static readonly [entityKind]: string;
  _: {
    brand: 'SQL';
    type: T;
  };
  private shouldInlineParams;
  constructor(queryChunks: SQLChunk[]);
  append(query: SQL): this;
  toQuery(config: BuildQueryConfig): QueryWithTypings;
  buildQueryFromSourceParams(chunks: SQLChunk[], _config: BuildQueryConfig): Query;
  private mapInlineParam;
  getSQL(): SQL;
  as(alias: string): SQL.Aliased<T>;
  /**
   * @deprecated
   * Use ``sql<DataType>`query`.as(alias)`` instead.
   */
  as<TData>(): SQL<TData>;
  /**
   * @deprecated
   * Use ``sql<DataType>`query`.as(alias)`` instead.
   */
  as<TData>(alias: string): SQL.Aliased<TData>;
  mapWith<TDecoder extends DriverValueDecoder<any, any> | DriverValueDecoder<any, any>['mapFromDriverValue']>(decoder: TDecoder): SQL<GetDecoderResult<TDecoder>>;
  inlineParams(): this;
  /**
   * This method is used to conditionally include a part of the query.
   *
   * @param condition - Condition to check
   * @returns itself if the condition is `true`, otherwise `undefined`
   */
  if(condition: any | undefined): this | undefined;
}
type GetDecoderResult<T> = T extends Column ? T['_']['data'] : T extends DriverValueDecoder<infer TData, any> | DriverValueDecoder<infer TData, any>['mapFromDriverValue'] ? TData : never;
/**
 * Any DB name (table, column, index etc.)
 */
declare class Name implements SQLWrapper {
  readonly value: string;
  static readonly [entityKind]: string;
  protected brand: 'Name';
  constructor(value: string);
  getSQL(): SQL<unknown>;
}
/**
 * Any DB name (table, column, index etc.)
 * @deprecated Use `sql.identifier` instead.
 */
declare function name(value: string): Name;
interface DriverValueDecoder<TData, TDriverParam> {
  mapFromDriverValue(value: TDriverParam): TData;
}
interface DriverValueEncoder<TData, TDriverParam> {
  mapToDriverValue(value: TData): TDriverParam | SQL;
}
interface DriverValueMapper<TData, TDriverParam> extends DriverValueDecoder<TData, TDriverParam>, DriverValueEncoder<TData, TDriverParam> {}
/** Parameter value that is optionally bound to an encoder (for example, a column). */
declare class Param$1<TDataType = unknown, TDriverParamType = TDataType> implements SQLWrapper {
  readonly value: TDataType;
  readonly encoder: DriverValueEncoder<TDataType, TDriverParamType>;
  static readonly [entityKind]: string;
  protected brand: 'BoundParamValue';
  /**
   * @param value - Parameter value
   * @param encoder - Encoder to convert the value to a driver parameter
   */
  constructor(value: TDataType, encoder?: DriverValueEncoder<TDataType, TDriverParamType>);
  getSQL(): SQL<unknown>;
}
/**
 * Anything that can be passed to the `` sql`...` `` tagged function.
 */
type SQLChunk = StringChunk | SQLChunk[] | SQLWrapper | SQL | Table | View | Subquery | AnyColumn | Param$1 | Name | undefined | FakePrimitiveParam | Placeholder;
declare namespace SQL {
  class Aliased<T = unknown> implements SQLWrapper {
    readonly sql: SQL;
    readonly fieldAlias: string;
    static readonly [entityKind]: string;
    _: {
      brand: 'SQL.Aliased';
      type: T;
    };
    constructor(sql: SQL, fieldAlias: string);
    getSQL(): SQL;
  }
}
declare class Placeholder<TName extends string = string, TValue = any> implements SQLWrapper {
  readonly name: TName;
  static readonly [entityKind]: string;
  protected: TValue;
  constructor(name: TName);
  getSQL(): SQL;
}
type ColumnsSelection = Record<string, unknown>;
declare abstract class View<TName extends string = string, TExisting extends boolean = boolean, TSelection extends ColumnsSelection = ColumnsSelection> implements SQLWrapper {
  static readonly [entityKind]: string;
  _: {
    brand: 'View';
    viewBrand: string;
    name: TName;
    existing: TExisting;
    selectedFields: TSelection;
  };
  readonly $inferSelect: InferSelectViewModel<View<Assume<TName, string>, TExisting, TSelection>>;
  constructor({
    name,
    schema,
    selectedFields,
    query
  }: {
    name: TName;
    schema: string | undefined;
    selectedFields: ColumnsSelection;
    query: SQL | undefined;
  });
  getSQL(): SQL<unknown>;
}
type InferSelectViewModel<TView extends View> = Equal<TView['_']['selectedFields'], {
  [x: string]: unknown;
}> extends true ? {
  [x: string]: unknown;
} : SelectResult<TView['_']['selectedFields'], 'single', Record<TView['_']['name'], 'not-null'>>;
//#endregion
//#region ../../node_modules/drizzle-orm/utils.d.ts
type Update<T, TUpdate> = { [K in Exclude<keyof T, keyof TUpdate>]: T[K] } & TUpdate;
type Simplify<T> = { [K in keyof T]: T[K] } & {};
type Not<T extends boolean> = T extends true ? false : true;
type IsNever<T> = [T] extends [never] ? true : false;
type IsUnion<T, U extends T = T> = (T extends any ? (U extends T ? false : true) : never) extends false ? false : true;
type FromSingleKeyObject<T, Result, TError extends string, K = keyof T> = IsNever<K> extends true ? never : IsUnion<K> extends true ? DrizzleTypeError<TError> : Result;
type Assume<T, U> = T extends U ? T : U;
type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
interface DrizzleTypeError<T extends string> {
  $drizzleTypeError: T;
}
type Casing = 'snake_case' | 'camelCase';
//#endregion
//#region ../../node_modules/drizzle-orm/pg-core/sequence.d.ts
type PgSequenceOptions = {
  increment?: number | string;
  minValue?: number | string;
  maxValue?: number | string;
  startWith?: number | string;
  cache?: number | string;
  cycle?: boolean;
};
//#endregion
//#region ../../node_modules/drizzle-orm/column-builder.d.ts
type ColumnDataType = 'string' | 'number' | 'boolean' | 'array' | 'json' | 'date' | 'bigint' | 'custom' | 'buffer' | 'dateDuration' | 'duration' | 'relDuration' | 'localTime' | 'localDate' | 'localDateTime';
type GeneratedStorageMode = 'virtual' | 'stored';
type GeneratedType = 'always' | 'byDefault';
type GeneratedColumnConfig<TDataType> = {
  as: TDataType | SQL | (() => SQL);
  type?: GeneratedType;
  mode?: GeneratedStorageMode;
};
type GeneratedIdentityConfig = {
  sequenceName?: string;
  sequenceOptions?: PgSequenceOptions;
  type: 'always' | 'byDefault';
};
interface ColumnBuilderBaseConfig<TDataType extends ColumnDataType, TColumnType extends string> {
  name: string;
  dataType: TDataType;
  columnType: TColumnType;
  data: unknown;
  driverParam: unknown;
  enumValues: string[] | undefined;
}
type ColumnBuilderRuntimeConfig<TData, TRuntimeConfig extends object = object> = {
  name: string;
  keyAsName: boolean;
  notNull: boolean;
  default: TData | SQL | undefined;
  defaultFn: (() => TData | SQL) | undefined;
  onUpdateFn: (() => TData | SQL) | undefined;
  hasDefault: boolean;
  primaryKey: boolean;
  isUnique: boolean;
  uniqueName: string | undefined;
  uniqueType: string | undefined;
  dataType: string;
  columnType: string;
  generated: GeneratedColumnConfig<TData> | undefined;
  generatedIdentity: GeneratedIdentityConfig | undefined;
} & TRuntimeConfig;
//#endregion
//#region ../../node_modules/drizzle-orm/column.d.ts
interface ColumnBaseConfig<TDataType extends ColumnDataType, TColumnType extends string> extends ColumnBuilderBaseConfig<TDataType, TColumnType> {
  tableName: string;
  notNull: boolean;
  hasDefault: boolean;
  isPrimaryKey: boolean;
  isAutoincrement: boolean;
  hasRuntimeDefault: boolean;
}
type ColumnTypeConfig<T extends ColumnBaseConfig<ColumnDataType, string>, TTypeConfig extends object> = T & {
  brand: 'Column';
  tableName: T['tableName'];
  name: T['name'];
  dataType: T['dataType'];
  columnType: T['columnType'];
  data: T['data'];
  driverParam: T['driverParam'];
  notNull: T['notNull'];
  hasDefault: T['hasDefault'];
  isPrimaryKey: T['isPrimaryKey'];
  isAutoincrement: T['isAutoincrement'];
  hasRuntimeDefault: T['hasRuntimeDefault'];
  enumValues: T['enumValues'];
  baseColumn: T extends {
    baseColumn: infer U;
  } ? U : unknown;
  generated: GeneratedColumnConfig<T['data']> | undefined;
  identity: undefined | 'always' | 'byDefault';
} & TTypeConfig;
type ColumnRuntimeConfig<TData, TRuntimeConfig extends object> = ColumnBuilderRuntimeConfig<TData, TRuntimeConfig>;
interface Column<T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = object, TTypeConfig extends object = object> extends DriverValueMapper<T['data'], T['driverParam']>, SQLWrapper {}
declare abstract class Column<T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = object, TTypeConfig extends object = object> implements DriverValueMapper<T['data'], T['driverParam']>, SQLWrapper {
  readonly table: Table;
  static readonly [entityKind]: string;
  readonly _: ColumnTypeConfig<T, TTypeConfig>;
  readonly name: string;
  readonly keyAsName: boolean;
  readonly primary: boolean;
  readonly notNull: boolean;
  readonly default: T['data'] | SQL | undefined;
  readonly defaultFn: (() => T['data'] | SQL) | undefined;
  readonly onUpdateFn: (() => T['data'] | SQL) | undefined;
  readonly hasDefault: boolean;
  readonly isUnique: boolean;
  readonly uniqueName: string | undefined;
  readonly uniqueType: string | undefined;
  readonly dataType: T['dataType'];
  readonly columnType: T['columnType'];
  readonly enumValues: T['enumValues'];
  readonly generated: GeneratedColumnConfig<T['data']> | undefined;
  readonly generatedIdentity: GeneratedIdentityConfig | undefined;
  protected config: ColumnRuntimeConfig<T['data'], TRuntimeConfig>;
  constructor(table: Table, config: ColumnRuntimeConfig<T['data'], TRuntimeConfig>);
  abstract getSQLType(): string;
  mapFromDriverValue(value: unknown): unknown;
  mapToDriverValue(value: unknown): unknown;
}
type AnyColumn<TPartial extends Partial<ColumnBaseConfig<ColumnDataType, string>> = {}> = Column<Required<Update<ColumnBaseConfig<ColumnDataType, string>, TPartial>>>;
type GetColumnData<TColumn extends Column, TInferMode extends 'query' | 'raw' = 'query'> = TInferMode extends 'raw' ? TColumn['_']['data'] : TColumn['_']['notNull'] extends true ? TColumn['_']['data'] : TColumn['_']['data'] | null;
//#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 = StructuredSuccessResponse<{
  message: string;
}>;
type FeatureFlagResponse = StructuredSuccessResponse<FeatureFlagModel>;
type FeatureFlagListResponse = StructuredSuccessResponse<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 = StructuredSuccessResponse<{
  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 = StructuredSuccessResponse<{
  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 = StructuredSuccessResponse<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/auth/types.d.ts
type AuthUser = SerializedModel<InferSelectModel<typeof users>>;
interface AuthSession {
  expiresAt: string;
  createdAt: string;
  updatedAt: string;
  userId: string;
  id: string;
}
type AuthSessionResponse = PlainSuccessResponse<{
  session: AuthSession | null;
  user: AuthUser | null;
  role: UserRole$1;
  roleEndAt?: string;
  feedSubscriptionLimit: number | null;
  rsshubSubscriptionLimit: number | null;
}>;
//#endregion
//#region src/modules/auth/index.d.ts
/**
 * Authentication module definition with Better Auth integration
 *
 * This module provides client SDK interfaces for all Better Auth endpoints.
 * The endpoints follow Better Auth's standard path conventions under /better-auth prefix.
 */
declare const authModule: ModuleDefinition<{
  getSession: RouteDefinition<void, AuthSessionResponse>;
}>;
type AuthAPI = typeof authModule.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[];
}
interface ChatRequest {
  messages: ChatMessage[];
  model?: "openai/gpt-5-mini" | (string & {});
  context?: ChatContext;
}
type ChatResponse = Response;
interface SummaryRequest {
  id: string;
  language?: LanguageSchema;
  target?: "content" | "readabilityContent";
}
type SummaryResponse = StructuredSuccessResponse<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 = StructuredSuccessResponse<TranslationData | null>;
interface TranslationBatchRequest {
  ids: string[];
  language: LanguageSchema;
  fields: string;
  part?: string;
  mode?: "bilingual" | "translation-only";
}
interface TranslationBatchStreamChunk {
  id: string;
  data: TranslationData;
}
type StreamingJsonResponse<T> = Response & {
  body: ReadableStream<T>;
};
type TranslationBatchResponse = StreamingJsonResponse<TranslationBatchStreamChunk>;
type TextToSpeechSource = "auto" | "content" | "readabilityContent" | "summary";
interface TextToSpeechRequest {
  entryId?: string;
  text?: string;
  voice?: string;
  source?: TextToSpeechSource;
}
type TextToSpeechResponse = Response;
interface TitleRequest {
  chatId?: string;
  messages: ChatMessage[];
}
interface TitleResponse {
  title: string;
  remainingTokens?: number;
}
interface TitleErrorResponse {
  error: string;
}
interface DailyRequest {
  startDate: string;
  view: "0" | "1";
}
type DailyResponse = StructuredSuccessResponse<string>;
interface UsageRequest {}
type UsageResponse = StructuredSuccessResponse<{
  total: number;
  used: number;
  remaining: number;
  resetAt: Date;
}>;
interface RateLimit {
  maxTokens: number;
  currentTokens: number;
  remainingTokens: number;
  windowDuration: number;
  windowResetTime: number;
  usageRate?: number;
  projectedLimitTime?: number | null;
  warningLevel?: string;
}
interface AttachmentLimits {
  maxFiles: number;
  remainingFiles: number;
  windowDuration: number;
  windowResetTime: number;
}
interface TokenUsage {
  total: number;
  used: number;
  remaining: number;
  resetAt: Date;
}
interface FreeQuota {
  shouldCheckDailyLimit: boolean;
  remainingRequests: number;
  remainingMonthlyRequests: number;
  role: string;
  dailyLimit: number;
  monthlyLimit: number;
}
interface TokenUsageHistory {
  id: string;
  createdAt: Date;
  changes: number;
  comment: string | null;
}
interface ConfigResponse {
  defaultModel: string;
  availableModels: string[];
  availableModelsMenu: {
    label: string;
    value?: string;
    paidLevel?: string;
  }[];
  rateLimit: RateLimit;
  attachmentLimits: AttachmentLimits;
  usage: TokenUsage;
  freeQuota: FreeQuota;
}
interface AIMemoryRecord {
  id: string;
  userId: string;
  memory: string;
  importance: number;
  tags: string[] | null;
  source: string | null;
  metadata: Record<string, unknown> | null;
  createdAt: Date;
  updatedAt: Date;
  lastAccessedAt: Date | null;
  expiresAt: Date | null;
}
interface AIMemoryListResponse {
  data: AIMemoryRecord[];
  nextBefore?: Date;
}
interface AIMemoryCreateRequest {
  memory: string;
  importance?: number;
  tags?: string[];
  source?: string;
  metadata?: Record<string, unknown>;
  expiresAt?: Date;
}
interface AIMemoryUpdateRequest {
  memoryId: string;
  memory?: string;
  importance?: number;
  tags?: string[] | null;
  source?: string | null;
  metadata?: Record<string, unknown> | null;
  expiresAt?: Date | null;
}
interface AIMemoryListQuery {
  limit?: number;
  before?: Date;
  importanceGte?: number;
  importanceLte?: number;
}
//#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>;
  translationBatch: RouteDefinition<TranslationBatchRequest, TranslationBatchResponse>;
  tts: RouteDefinition<TextToSpeechRequest, Response>;
  summaryTitle: RouteDefinition<TitleRequest, TitleResponse>;
  daily: RouteDefinition<DailyRequest, DailyResponse>;
  config: RouteDefinition<never, ConfigResponse>;
  memory: {
    list: RouteDefinition<AIMemoryListQuery, AIMemoryListResponse>;
    create: RouteDefinition<AIMemoryCreateRequest, AIMemoryRecord>;
    update: RouteDefinition<AIMemoryUpdateRequest, AIMemoryRecord>;
    delete: RouteDefinition<{
      memoryId: string;
    }, {
      success: boolean;
    }>;
  };
}>;
type AIAPI = typeof aiModule.api;
//#endregion
//#region src/modules/ai-analytics/types.d.ts
interface AnalyticsRequest {
  days?: string;
}
interface UsagePattern {
  operationType: string;
  totalTokens: number;
  operationCount: number;
  percentage: number;
  avgTokensPerOperation: number;
}
interface DailyPattern {
  date: string;
  totalTokens: number;
  operationCount: number;
  peakHour: number | null;
}
interface ModelPattern {
  model: string;
  totalTokens: number;
  operationCount: number;
  percentage: number;
  avgEfficiency: number;
}
interface AnalyticsData {
  patterns: {
    daily: DailyPattern[];
    byOperation: UsagePattern[];
    byModel: ModelPattern[];
  };
  usageHistory: typeof aiTokens.$inferSelect[];
}
type AnalyticsResponse = AnalyticsData;
//#endregion
//#region src/modules/ai-analytics/index.d.ts
/**
 * AI Analytics module definition for usage analytics and insights
 */
declare const aiAnalyticsModule: ModuleDefinition<{
  get: RouteDefinition<AnalyticsRequest, AnalyticsData>;
}>;
type AIAnalyticsAPI = typeof aiAnalyticsModule.api;
//#endregion
//#region src/modules/ai-chat-sessions/types.d.ts
interface ChatIdRequest {
  chatId: string;
}
interface AIChatSession {
  chatId: string;
  userId: string;
  title: string;
  createdAt: DateISOString;
  updatedAt: DateISOString;
  lastSeenAt: DateISOString;
}
interface AIChatMessage {
  id: string;
  chatId: string;
  role: "user" | "assistant" | "system";
  messageParts: UIMessageParts;
  metadata?: unknown;
  status: "pending" | "completed" | "error";
  createdAt: DateISOString;
  finishedAt: DateISOString | null;
}
interface ChatMetadata {
  tokenUsage?: {
    promptTokens: number;
    completionTokens: number;
    totalTokens: number;
  };
  finishReason?: string;
  model?: string;
  [key: string]: any;
}
interface GetSessionRequest extends ChatIdRequest {}
interface ListSessionsQuery {
  limit?: number;
  before?: DateISOString;
}
interface UpdateSessionRequest extends ChatIdRequest {
  title: string;
}
interface DeleteSessionRequest extends ChatIdRequest {}
interface GetMessagesQuery extends ChatIdRequest {
  limit?: number;
  before?: DateISOString;
}
interface MarkSeenRequest extends ChatIdRequest {
  lastSeenAt?: DateISOString;
}
interface GetUnreadQuery {
  limit?: number;
}
type SessionResponse = StructuredSuccessResponse<AIChatSession>;
type ListSessionsResponse = StructuredSuccessResponse<AIChatSession[]> & {
  total: number;
  nextBefore?: DateISOString;
};
type GetMessagesResponse = StructuredSuccessResponse<{
  chatSession: AIChatSession | null;
  messages: AIChatMessage[];
  nextBefore?: DateISOString;
}>;
type GetUnreadResponse = StructuredSuccessResponse<string[]>;
//#endregion
//#region src/modules/ai-chat-sessions/index.d.ts
/**
 * AI Chat Sessions module - comprehensive chat session management
 * Base path: /ai/chat-sessions
 */
declare const aiChatSessionsModule: ModuleDefinition<{
  list: RouteDefinition<ListSessionsQuery, ListSessionsResponse>;
  get: RouteDefinition<GetSessionRequest, SessionResponse>;
  update: RouteDefinition<UpdateSessionRequest, SessionResponse>;
  delete: RouteDefinition<DeleteSessionRequest, {
    success: boolean;
  }>;
  messages: {
    get: RouteDefinition<GetMessagesQuery, GetMessagesResponse>;
  };
  markSeen: RouteDefinition<MarkSeenRequest, SessionResponse>;
  unread: RouteDefinition<GetUnreadQuery, GetUnreadResponse>;
}>;
type AIChatSessionsAPI = typeof aiChatSessionsModule.api;
//#endregion
//#region src/modules/ai-task/types.d.ts
interface AITask {
  id: string;
  name: string;
  prompt: string;
  isEnabled: boolean;
  schedule: TaskSchedule$1;
  createdAt: DateISOString;
  updatedAt: DateISOString;
  lastRunAt: DateISOString | null;
  nextRunAt: DateISOString | null;
  runCount: number;
  lastResult: string | null;
  lastError: string | null;
  options: AiTaskOptions;
}
interface CreateTaskRequest {
  name: string;
  prompt: string;
  isEnabled?: boolean;
  schedule: TaskSchedule$1;
  options: AiTaskOptions;
}
interface UpdateTaskRequest {
  id: string;
  name?: string;
  prompt?: string;
  isEnabled?: boolean;
  schedule?: TaskSchedule$1;
  options?: AiTaskOptions;
}
type TaskListResponse = StructuredSuccessResponse<AITask[]>;
type TaskGetResponse = StructuredSuccessResponse<AITask>;
type TaskCreateResponse = StructuredSuccessResponse<AITask>;
type TaskUpdateResponse = StructuredSuccessResponse<AITask>;
type TaskDeleteResponse = EmptyResponse;
type TaskTestRunResponse = StructuredSuccessResponse<{
  taskId: string;
  sessionId?: string;
  result?: string;
  error?: string;
}>;
//#endregion
//#region src/modules/ai-task/index.d.ts
/**
 * AI Task module - standalone module for managing AI scheduled tasks
 * Base path: /ai/task
 */
declare const aiTaskModule: ModuleDefinition<{
  list: RouteDefinition<never, TaskListResponse>;
  get: RouteDefinition<{
    id: string;
  }, TaskGetResponse>;
  create: RouteDefinition<CreateTaskRequest, TaskCreateResponse>;
  update: RouteDefinition<UpdateTaskRequest, TaskUpdateResponse>;
  delete: RouteDefinition<{
    id: string;
  }, EmptyResponse>;
  testRun: RouteDefinition<{
    id: string;
  }, TaskTestRunResponse>;
}>;
type AITaskAPI = typeof aiTaskModule.api;
//#endregion
//#region src/modules/categories/types.d.ts
interface CategoriesGetQuery {
  view?: string;
}
type CategoriesGetResponse = StructuredSuccessResponse<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 = StructuredSuccessResponse<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
type GoogleAnalyticsRequest = Record<string, any>;
type GoogleAnalyticsResponse = null;
//#endregion
//#region src/modules/data/index.d.ts
/**
 * Data module for Google Analytics data collection
 */
declare const dataModule: ModuleDefinition<{
  sendAnalytics: RouteDefinition<GoogleAnalyticsRequest, null>;
}>;
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;
  media?: MediaModel[] | null;
  authorUrl: string | null;
  authorAvatar: string | null;
  insertedAt: string;
  categories?: string[];
  attachments?: AttachmentsModel[];
  extra?: ExtraModel;
  language?: string | null;
}
type FeedAnalytics$1 = SerializedModel<InferSelectModel<typeof feedAnalytics>>;
interface DiscoveryItem {
  feed?: FeedDiscoveryResult;
  list?: ListDiscoveryResult;
  docs?: string;
  entries?: EntryData[];
  subscriptionCount?: number;
  updatesPerWeek?: number;
  analytics?: FeedAnalytics$1;
}
type DiscoverResponse = StructuredSuccessResponse<DiscoveryItem[]>;
interface RSSHubQuery {
  category?: string;
  namespace?: string;
  lang?: string;
  categories?: string;
}
interface RSSHubRouteMetadata {
  path: string;
  categories: string[];
  example: string;
  parameters: Record<string, string>;
  name: string;
  maintainers: string[];
  location: string;
  description: string;
  view?: number;
}
interface RSSHubNamespace {
  routes: Record<string, RSSHubRouteMetadata>;
  name: string;
  url: string;
  description: string;
  lang: string;
}
type RSSHubResponse = StructuredSuccessResponse<Record<string, RSSHubNamespace>>;
interface RSSHubRouteQuery {
  route: string;
}
interface RSSHubRouteData {
  route: RSSHubRouteMetadata;
  prefix: string;
  name: string;
  description: string;
  url: string;
}
type RSSHubRouteResponse = StructuredSuccessResponse<RSSHubRouteData>;
type RSSHubAnalyticsQuery = Record<string, never>;
interface RSSHubRouteAnalytics {
  subscriptionCount: number;
  topFeeds: FeedDiscoveryResult[];
}
type RSSHubAnalyticsResponse = StructuredSuccessResponse<Record<string, RSSHubRouteAnalytics>>;
//#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<RSSHubQuery, 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$2 = 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>>;
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 {}
interface EntryTagSummary {
  schemaOrgCategory: string | null;
  mediaTopics: string[];
}
type EntryOpenAPISchema = Prettify<SerializedModel<z$1.infer<typeof entriesOpenAPISchema>> & {
  tags?: EntryTagSummary;
}>;
type EntryGetByIdResponse = StructuredSuccessResponse<{
  feeds: FeedOpenApiSchema$2;
  entries: Prettify<Omit<EntryOpenAPISchema, "feedId">>;
  settings?: EntrySettings;
} | null>;
interface EntryWithFeed extends EntryExtraResponse {
  read: boolean;
  view: FeedViewType$1;
  from: string[];
  feeds: FeedOpenApiSchema$2;
  entries: Prettify<Omit<EntryOpenAPISchema, "content" | "feedId">> & {
    tags?: EntryTagSummary;
  };
}
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;
  aiSort?: boolean;
};
type EntryListResponse = StructuredSuccessResponse<EntryWithFeed[]>;
interface EntryTagsQueryRequest {
  tags: {
    schemaOrgCategories?: string[];
    mediaTopics?: string[];
  };
  match?: "any" | "all";
  limit?: number;
  cursor?: string;
  feedId?: string;
  withContent?: boolean;
}
type EntryTagsQueryResponse = StructuredSuccessResponse<EntryWithFeed[]>;
interface EntryPreviewRequest extends IdRequest {}
type EntryPreviewResponse = StructuredSuccessResponse<EntryOpenAPISchema>;
interface EntryReadabilityRequest extends IdRequest {}
type EntryReadabilityResponse = StructuredSuccessResponse<{
  content?: string;
} | null>;
interface EntryTranscriptionRequest {
  url: string;
}
type EntryTranscriptionResponse = StructuredSuccessResponse<{
  srt: string;
  duration: number;
} | 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 = StructuredSuccessResponse<{
  has_new: boolean;
  lastest_at?: string;
  entry_id?: string;
}>;
interface ReadHistoriesQuery {
  page?: number;
  size?: number;
}
type ReadHistoriesResponse = StructuredSuccessResponse<{
  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<SerializedModel<z$1.infer<typeof inboxesEntriesOpenAPISchema>>, "content">>;
}
type InboxListEntryResponse = StructuredSuccessResponse<InboxListEntry[]>;
type InboxEntryGetResponse = StructuredSuccessResponse<{
  feeds: InboxOpenApiSchema$1;
  entries: SerializedModel<z$1.infer<typeof inboxesEntriesOpenAPISchema>>;
} | null>;
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>;
  transcription: RouteDefinition<EntryTranscriptionRequest, EntryTranscriptionResponse>;
  stream: RouteDefinition<EntryStreamRequest, Response>;
  checkNew: RouteDefinition<CheckNewEntriesQuery, CheckNewEntriesResponse>;
  tagsQuery: RouteDefinition<EntryTagsQueryRequest, EntryTagsQueryResponse>;
  readHistories: RouteDefinition<ReadHistoriesInput, ReadHistoriesResponse>;
  inbox: {
    get: RouteDefinition<InboxEntryGetQuery, InboxEntryGetResponse>;
    list: RouteDefinition<InboxListEntryRequestInput, InboxListEntryResponse>;
    delete: RouteDefinition<InboxRemoveInput, StructuredSuccessResponse<any>>;
  };
}>;
type EntriesAPI = typeof entriesModule.api;
//#endregion
//#region src/modules/feeds/types.d.ts
type FeedOpenApiSchema$1 = SerializedModel<FeedOpenApiSchema>;
type FeedModel = SerializedModel<InferSelectModel<typeof feeds>>;
type FeedInsert = SerializedInsertModel<InferInsertModel<typeof feeds>>;
type FeedAnalyticsModel = SerializedModel<InferSelectModel<typeof feedAnalytics>>;
type EntryOpenAPISchema$1 = z.infer<typeof entriesOpenAPISchema>;
type ParsedEntry = Omit<EntryOpenAPISchema$1, "feedId" | "content" | "insertedAt"> & {
  publishedAt: Date;
};
interface FeedGetQuery {
  id?: string;
  url?: string;
  entriesLimit?: number;
}
type FeedGetResponse = StructuredSuccessResponse<{
  feed: FeedOpenApiSchema$1;
  entries: ParsedEntry[];
  subscription?: SerializedModel<z.infer<typeof subscriptionsOpenAPISchema>>;
  readCount: number;
  subscriptionCount: number;
  analytics?: SerializedModel<z.infer<typeof feedAnalyticsOpenAPISchema>>;
}>;
interface FeedRefreshQuery {
  id: string;
}
type FeedRefreshResponse = EmptyResponse;
interface FeedResetQuery {
  id: string;
}
type FeedResetResponse = EmptyResponse;
interface FeedAnalyticsRequest {
  id: string[];
}
type FeedAnalyticsResponse = StructuredSuccessResponse<{
  analytics: Record<string, SerializedModel<z.infer<typeof feedAnalyticsOpenAPISchema>>>;
}>;
interface FeedClaimChallengeRequest {
  feedId: string;
}
type FeedClaimChallengeResponse = EmptyResponse;
interface FeedClaimListItem {
  feed: FeedOpenApiSchema$1;
  subscriptionCount: number;
  tipAmount: number;
}
type FeedClaimListResponse = StructuredSuccessResponse<FeedClaimListItem[]>;
interface FeedClaimMessageQuery {
  feedId: string;
}
interface FeedClaimMessageData {
  content: string;
  description: string;
  json: string;
  xml: string;
}
type FeedClaimMessageResponse = StructuredSuccessResponse<FeedClaimMessageData>;
//#endregion
//#region src/modules/feeds/index.d.ts
/**
 * Feeds module definition with nested routes
 */
declare const feedsModule: ModuleDefinition<{
  get: RouteDefinition<FeedGetQuery, FeedGetResponse>;
  refresh: RouteDefinition<FeedRefreshQuery, EmptyResponse>;
  reset: RouteDefinition<FeedResetQuery, EmptyResponse>;
  analytics: RouteDefinition<FeedAnalyticsRequest, FeedAnalyticsResponse>;
  claim: {
    challenge: RouteDefinition<FeedClaimChallengeRequest, EmptyResponse>;
    list: RouteDefinition<{}, FeedClaimListResponse>;
    message: RouteDefinition<FeedClaimMessageQuery, FeedClaimMessageResponse>;
  };
}>;
type FeedsAPI = typeof feedsModule.api;
//#endregion
//#region src/modules/inboxes/types.d.ts
type InboxSchema = SerializedModel<InboxOpenApiSchema>;
interface InboxGetQuery {
  handle: string;
}
type InboxGetResponse = StructuredSuccessResponse<InboxSchema>;
type InboxListResponse = StructuredSuccessResponse<InboxSchema[]>;
interface InboxCreateRequest {
  handle: string;
  title?: string;
}
type InboxCreateResponse = EmptyResponse;
interface InboxUpdateRequest {
  handle: string;
  title: string;
}
type InboxUpdateResponse = EmptyResponse;
interface InboxDeleteRequest {
  handle: string;
}
type InboxDeleteResponse = EmptyResponse;
type InboxEmailRequest = {
  from: {
    name?: string;
    address?: string;
  };
  to: {
    address: string;
  };
  subject?: string;
  messageId: string;
  date: string;
  html?: string;
};
type InboxEmailResponse = EmptyResponse;
type InboxWebhookRequest = z$1.infer<typeof inboxesEntriesInsertOpenAPISchema>;
type InboxWebhookResponse = EmptyResponse;
//#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, EmptyResponse>;
  put: RouteDefinition<InboxUpdateRequest, EmptyResponse>;
  delete: RouteDefinition<InboxDeleteRequest, EmptyResponse>;
  email: RouteDefinition<InboxEmailRequest, EmptyResponse>;
  webhook: RouteDefinition<{
    guid: string;
    publishedAt: string;
    description?: string | null | undefined;
    title?: string | null | undefined;
    summary?: string | null | undefined;
    content?: string | null | undefined;
    author?: string | null | undefined;
    url?: string | null | undefined;
    language?: string | null | undefined;
    categories?: string[] | null | undefined;
    authorUrl?: string | null | undefined;
    authorAvatar?: string | null | undefined;
    read?: boolean | null | undefined;
    attachments?: {
      url: string;
      duration_in_seconds?: string | number | undefined;
      mime_type?: string | undefined;
      size_in_bytes?: number | undefined;
      title?: string | undefined;
    }[] | null | undefined;
    media?: {
      url: string;
      type: "photo" | "video";
      width?: number | undefined;
      height?: number | undefined;
      preview_image_url?: string | undefined;
      blurhash?: string | undefined;
    }[] | null | undefined;
    extra?: {
      links?: {
        url: string;
        type: string;
        content_html?: string | undefined;
      }[] | null | undefined;
      title_keyword?: string | undefined;
    } | null | undefined;
  }, EmptyResponse>;
}>;
type InboxesAPI = typeof inboxesModule.api;
//#endregion
//#region src/modules/lists/types.d.ts
type FeedSchema = SerializedModel<FeedOpenApiSchema>;
type ListSchema = SerializedModel<ListOpenApiSchema>;
type ListModel = SerializedModel<InferSelectModel<typeof lists>>;
type ListInsert = SerializedInsertModel<InferInsertModel<typeof lists>>;
type ListSubscriptionModel = SerializedModel<InferSelectModel<typeof listsSubscriptions>>;
type ListAnalyticsSchema = z.infer<typeof listAnalyticsOpenAPISchema>;
type ListSubscriptionSchema = z.infer<typeof listsSubscriptionsOpenAPISchema>;
type EntrySchema = z.infer<typeof entriesOpenAPISchema>;
interface GetListQuery {
  listId: string;
  noExtras?: boolean;
}
interface CreateListRequest {
  view: number;
  title: string;
  image?: string | null;
  fee: number;
  description?: string | null;
}
interface UpdateListRequest {
  listId: string;
  view?: number;
  title?: string;
  image?: string | null;
  fee?: number;
  description?: string | null;
}
interface DeleteListRequest {
  listId: string;
}
interface ListsListQuery {
  userId?: string;
}
interface AddFeedsRequest {
  listId: string;
  feedId?: string;
  feedIds?: string[];
}
interface RemoveFeedRequest {
  listId: string;
  feedId: string;
}
interface GetListData {
  list: ListSchema & {
    feeds: FeedSchema[];
  };
  subscription?: ListSubscriptionSchema;
  subscriptionCount: number;
  readCount: number;
  feedCount: number;
  entries: Array<EntrySchema & {
    feeds: FeedSchema;
  }>;
  analytics?: ListAnalyticsSchema;
}
interface ListWithStats extends ListSchema {
  subscriptionCount?: number;
  purchaseAmount?: number;
  feeds: FeedSchema[];
}
type GetListResponse = StructuredSuccessResponse<GetListData>;
type CreateListResponse = StructuredSuccessResponse<ListSchema>;
type UpdateListResponse = StructuredSuccessResponse<null>;
type DeleteListResponse = StructuredSuccessResponse<null>;
type ListUserListsResponse = StructuredSuccessResponse<ListWithStats[]>;
type AddFeedsResponse = StructuredSuccessResponse<FeedSchema[]>;
type RemoveFeedResponse = StructuredSuccessResponse<null>;
//#endregion
//#region src/modules/lists/index.d.ts
/**
 * Lists module definition with core routes
 */
declare const listsModule: ModuleDefinition<{
  get: RouteDefinition<GetListQuery, GetListResponse>;
  list: RouteDefinition<ListsListQuery, ListUserListsResponse>;
  create: RouteDefinition<CreateListRequest, CreateListResponse>;
  update: RouteDefinition<UpdateListRequest, UpdateListResponse>;
  delete: RouteDefinition<DeleteListRequest, DeleteListResponse>;
  addFeeds: RouteDefinition<AddFeedsRequest, AddFeedsResponse>;
  removeFeed: RouteDefinition<RemoveFeedRequest, RemoveFeedResponse>;
}>;
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;
  enabled: 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>;
  enabled?: boolean;
  connectionId: string;
}
type UpdateConnectionResponse = {
  /**
   * If code is 1, the authorizationUrl is required
   */
  code: 0 | 1;
  authorizationUrl?: string;
  connectionId: string;
};
interface ConnectionParams {
  connectionId: string;
}
interface RefreshToolsRequest {
  connectionIds?: string[];
}
type CreateConnectionResponse = {
  /**
   * 0: success, 1: need oauth
   */
  code: 0 | 1;
  authorizationUrl?: string;
  connectionId: string;
};
type GetConnectionsResponse = StructuredSuccessResponse<McpConnectionInfo[]>;
type DeleteConnectionResponse = StructuredSuccessResponse;
type GetToolsResponse = StructuredSuccessResponse<McpTool[]>;
type RefreshToolsResponse = StructuredSuccessResponse<{
  total: number;
  successful: number;
  failed: number;
  results: RefreshResult[];
}>;
//#endregion
//#region src/modules/mcp/index.d.ts
/**
 * MCP (Model Context Protocol) module definition
 * Handles MCP server connections and tool management
 */
declare const mcpModule: 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>;
}>;
type McpAPI = typeof mcpModule.api;
//#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 TestMessagingQuery {
  channel?: string;
}
type GetMessagingTokensResponse = StructuredSuccessResponse<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>;
  testNotification: RouteDefinition<TestMessagingQuery, 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 = StructuredSuccessResponse<UserProfile>;
type GetProfilesBatchResponse = StructuredSuccessResponse<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 = StructuredSuccessResponse<number>;
type CheckRedisResponse = StructuredSuccessResponse<number>;
type CheckBullMQResponse = StructuredSuccessResponse<BullMQStatus>;
type GetRSSHubAnalyticsResponse = StructuredSuccessResponse<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 = StructuredSuccessResponse<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 = StructuredSuccessResponse<{
  read: Record<string, number>;
}>;
/**
 * Response for basic read operations
 */
type ReadOperationResponse = StructuredSuccessResponse<null>;
/**
 * Response for total unread count
 */
type TotalUnreadCountResponse = StructuredSuccessResponse<{
  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 = StructuredSuccessResponse<ReferralsData>;
type GetReferralDaysResponse = StructuredSuccessResponse<ReferralDaysData>;
//#endregion
//#region src/modules/rsshub/types.d.ts
type RSSHubModel = SerializedModel<InferSelectModel<typeof rsshub>>;
type RSSHubUsageModel = SerializedModel<InferSelectModel<typeof rsshubUsage>>;
interface RSSHubOwner {
  id: string;
  handle: string | null;
  name: string | null;
  image: string | null;
}
interface RSSHubCreateRequest {
  id?: string;
  baseUrl: string;
  accessKey?: string;
}
interface RSSHubDeleteRequest {
  id: string;
}
interface RSSHubUseRequest extends TwoFactorAuth {
  id: string | null;
  durationInMonths?: number;
}
interface RSSHubGetQuery {
  id: string;
}
interface RSSHubListItem {
  id: string;
  ownerUserId: string;
  price: number;
  userLimit: number | null;
  description: string | null;
  errorMessage: string | null;
  errorAt: string | null;
  userCount: number;
  owner: RSSHubOwner | null;
}
interface RSSHubInstanceDetails extends Omit<RSSHubModel, "baseUrl" | "accessKey"> {
  baseUrl?: string | null;
  accessKey?: string | null;
}
interface RSSHubPurchase {
  hash: string | null;
  expiresAt: string;
}
interface RSSHubInstanceData {
  instance: RSSHubInstanceDetails;
  purchase: RSSHubPurchase | null;
}
interface RSSHubStatusData {
  usage?: RSSHubUsageModel;
  purchase: RSSHubPurchase | null;
}
type RSSHubCreateResponse = StructuredSuccessResponse<null>;
type RSSHubListResponse = StructuredSuccessResponse<RSSHubListItem[]>;
type RSSHubDeleteResponse = StructuredSuccessResponse<null>;
type RSSHubUseResponse = StructuredSuccessResponse<null>;
type RSSHubGetResponse = StructuredSuccessResponse<RSSHubInstanceData>;
type RSSHubStatusResponse = StructuredSuccessResponse<RSSHubStatusData>;
//#endregion
//#region src/modules/rsshub/index.d.ts
/**
 * RSSHub module definition for RSSHub instance management
 */
declare const rsshubModule: ModuleDefinition<{
  create: RouteDefinition<RSSHubCreateRequest, RSSHubCreateResponse>;
  list: RouteDefinition<{}, RSSHubListResponse>;
  delete: RouteDefinition<RSSHubDeleteRequest, RSSHubDeleteResponse>;
  use: RouteDefinition<RSSHubUseRequest, RSSHubUseResponse>;
  get: RouteDefinition<RSSHubGetQuery, RSSHubGetResponse>;
  status: RouteDefinition<{}, RSSHubStatusResponse>;
}>;
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 = PlainSuccessResponse<{
  settings: Record<SettingsTab, SettingsPayload>;
  updated: Record<SettingsTab, string>;
}>;
interface SettingsGetQuery {
  tab?: string;
}
type SettingsUpdateRequest = Record<string, any>;
type SettingsUpdateResponse = EmptyResponse;
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, EmptyResponse>;
}>;
type SettingsAPI = typeof settingsModule.api;
//#endregion
//#region src/modules/status/types.d.ts
type GetStatusConfigsResponse = StructuredSuccessResponse<StatusConfigs$1>;
//#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 = StructuredSuccessResponse<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 = StructuredSuccessResponse<SubscriptionModel>;
interface SubscriptionDeleteRequest {
  feedIdList?: string[];
  listId?: string;
  url?: string;
  feedId?: string;
}
type SubscriptionDeleteResponse = StructuredSuccessResponse<null>;
interface SubscriptionBatchRequest {
  feedIds: string[];
  view?: number;
  category?: string | null;
  isPrivate?: boolean;
  title?: string | null;
}
type SubscriptionBatchResponse = StructuredSuccessResponse<null>;
interface ParsedSubscription {
  userId: string;
  url: string;
  view: FeedViewType$1;
  category: string | null;
  title: string | null;
}
type SubscriptionParseOpmlResponse = StructuredSuccessResponse<{
  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 = StructuredSuccessResponse<{
  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>;
  /**
   * FormData:
   * file: File
   * items: string
   */
  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 = StructuredSuccessResponse<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 = StructuredSuccessResponse<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/update/types.d.ts
interface UpdateAsset {
  id: number;
  name: string;
  size: number;
  downloadUrl: string;
  contentType?: string | null;
  sha512?: string | null;
}
interface UpdateRelease {
  id: number;
  name: string | null;
  tagName: string;
  version: string;
  publishedAt: string | null;
  body?: string | null;
  url: string;
  assets: UpdateAsset[];
}
interface RendererUpdate {
  version: string;
  hash: string;
  mainHash: string;
  filename: string;
  downloadUrl: string | null;
  size: number | null;
  contentType?: string | null;
  commit?: string | null;
  manifest: {
    name: string;
    downloadUrl: string;
  };
}
interface PlatformUpdateFile {
  filename: string;
  sha512: string;
  size: number;
  downloadUrl: string | null;
  contentType?: string | null;
}
interface PlatformUpdate {
  platform: string;
  version: string;
  releaseDate: string | null;
  manifest: {
    name: string;
    path: string;
    downloadUrl: string;
  };
  files: PlatformUpdateFile[];
}
interface AppUpdate {
  version: string;
  selectedPlatform: PlatformUpdate | null;
  platforms: PlatformUpdate[];
}
interface UpdateDecision {
  type: "renderer" | "app" | "none";
  renderer: RendererUpdate | null;
  app: AppUpdate | null;
}
interface LatestReleasePayload {
  provider: string;
  fetchedAt: string;
  release: UpdateRelease;
  decision: UpdateDecision;
}
type GetLatestReleaseResponse = StructuredSuccessResponse<LatestReleasePayload>;
interface GetLatestReleaseQuery {
  refresh?: string | boolean;
}
interface GetManifestRequest {
  manifestName: string;
  refresh?: string | boolean;
}
type StoreDistribution = "mas" | "mss";
interface DistributionStatusPayload {
  distribution: StoreDistribution;
  storeUrl: string | null;
  storeVersion: string | null;
  rendererUpdate: RendererUpdate | null;
}
type GetDistributionStatusResponse = StructuredSuccessResponse<DistributionStatusPayload>;
interface GetDistributionStatusRequest {
  distribution: StoreDistribution;
  refresh?: string | boolean;
}
//#endregion
//#region src/modules/update/index.d.ts
declare const updatesModule: ModuleDefinition<{
  getLatestRelease: RouteDefinition<GetLatestReleaseQuery, GetLatestReleaseResponse>;
  getManifest: RouteDefinition<GetManifestRequest, string>;
  getDistributionStatus: RouteDefinition<GetDistributionStatusRequest, GetDistributionStatusResponse>;
}>;
type UpdatesAPI = typeof updatesModule.api;
//#endregion
//#region src/modules/wallets/constants.d.ts
declare const TransactionTypes: readonly ["mint", "purchase", "tip", "withdraw", "airdrop"];
//#endregion
//#region src/modules/wallets/types.d.ts
type WalletModel = SerializedModel<InferSelectModel<typeof wallets>>;
type WalletsGetResponse = StructuredSuccessResponse<WalletModel[]>;
type WalletsPostResponse = StructuredSuccessResponse<WalletModel>;
interface TransactionQuery {
  hash?: string;
  type?: TransactionType;
  fromOrToUserId?: string;
  fromUserId?: string;
  toUserId?: string;
  toFeedId?: string;
  createdAfter?: DateISOString;
}
type TransactionModel = SerializedModel<InferSelectModel<typeof transactions>>;
type UserModelPublic = SerializedModel<Omit<InferSelectModel<typeof users>, "email" | "twoFactorEnabled" | "isAnonymous" | "bio" | "website" | "socialLinks" | "stripeCustomerId" | "role" | "roleEndAt">>;
type TransactionFeedModel = SerializedModel<FeedOpenApiSchema>;
interface TransactionWithRelations extends TransactionModel {
  fromUser?: UserModelPublic | null;
  toUser?: UserModelPublic | null;
  toFeed?: TransactionFeedModel | null;
}
type TransactionsGetResponse = StructuredSuccessResponse<TransactionWithRelations[]>;
interface WithdrawRequest extends TwoFactorAuth {
  address: string;
  amount: string;
  toRss3?: boolean;
}
type WithdrawResponse = StructuredSuccessResponse<{
  transactionHash: string;
}>;
type TransactionType = (typeof TransactionTypes)[number];
//#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>;
  transactions: {
    get: RouteDefinition<TransactionQuery, TransactionsGetResponse>;
    withdraw: RouteDefinition<WithdrawRequest, WithdrawResponse>;
  };
}>;
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 actions: ModuleDefinition<{
    get: RouteDefinition<never, ActionsGetResponse>;
    put: RouteDefinition<ActionsPutRequest, 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 auth: ModuleDefinition<{
    getSession: RouteDefinition<void, AuthSessionResponse>;
  }>;
  readonly ai: ModuleDefinition<{
    chat: RouteDefinition<ChatRequest, Response>;
    summary: RouteDefinition<SummaryRequest, SummaryResponse>;
    translation: RouteDefinition<TranslationRequest, TranslationResponse>;
    translationBatch: RouteDefinition<TranslationBatchRequest, TranslationBatchResponse>;
    tts: RouteDefinition<TextToSpeechRequest, Response>;
    summaryTitle: RouteDefinition<TitleRequest, TitleResponse>;
    daily: RouteDefinition<DailyRequest, DailyResponse>;
    config: RouteDefinition<never, ConfigResponse>;
    memory: {
      list: RouteDefinition<AIMemoryListQuery, AIMemoryListResponse>;
      create: RouteDefinition<AIMemoryCreateRequest, AIMemoryRecord>;
      update: RouteDefinition<AIMemoryUpdateRequest, AIMemoryRecord>;
      delete: RouteDefinition<{
        memoryId: string;
      }, {
        success: boolean;
      }>;
    };
  }>;
  readonly aiAnalytics: ModuleDefinition<{
    get: RouteDefinition<AnalyticsRequest, AnalyticsData>;
  }>;
  readonly aiChatSessions: ModuleDefinition<{
    list: RouteDefinition<ListSessionsQuery, ListSessionsResponse>;
    get: RouteDefinition<GetSessionRequest, SessionResponse>;
    update: RouteDefinition<UpdateSessionRequest, SessionResponse>;
    delete: RouteDefinition<DeleteSessionRequest, {
      success: boolean;
    }>;
    messages: {
      get: RouteDefinition<GetMessagesQuery, GetMessagesResponse>;
    };
    markSeen: RouteDefinition<MarkSeenRequest, SessionResponse>;
    unread: RouteDefinition<GetUnreadQuery, GetUnreadResponse>;
  }>;
  readonly aiTask: ModuleDefinition<{
    list: RouteDefinition<never, TaskListResponse>;
    get: RouteDefinition<{
      id: string;
    }, TaskGetResponse>;
    create: RouteDefinition<CreateTaskRequest, TaskCreateResponse>;
    update: RouteDefinition<UpdateTaskRequest, TaskUpdateResponse>;
    delete: RouteDefinition<{
      id: string;
    }, EmptyResponse>;
    testRun: RouteDefinition<{
      id: string;
    }, TaskTestRunResponse>;
  }>;
  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<{
    sendAnalytics: RouteDefinition<GoogleAnalyticsRequest, null>;
  }>;
  readonly discover: ModuleDefinition<{
    discover: RouteDefinition<DiscoverRequest, DiscoverResponse>;
    rsshub: RouteDefinition<RSSHubQuery, 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>;
    transcription: RouteDefinition<EntryTranscriptionRequest, EntryTranscriptionResponse>;
    stream: RouteDefinition<EntryStreamRequest, Response>;
    checkNew: RouteDefinition<CheckNewEntriesQuery, CheckNewEntriesResponse>;
    tagsQuery: RouteDefinition<EntryTagsQueryRequest, EntryTagsQueryResponse>;
    readHistories: RouteDefinition<ReadHistoriesInput, ReadHistoriesResponse>;
    inbox: {
      get: RouteDefinition<InboxEntryGetQuery, InboxEntryGetResponse>;
      list: RouteDefinition<InboxListEntryRequestInput, InboxListEntryResponse>;
      delete: RouteDefinition<InboxRemoveInput, StructuredSuccessResponse<any>>;
    };
  }>;
  readonly feeds: ModuleDefinition<{
    get: RouteDefinition<FeedGetQuery, FeedGetResponse>;
    refresh: RouteDefinition<FeedRefreshQuery, EmptyResponse>;
    reset: RouteDefinition<FeedResetQuery, EmptyResponse>;
    analytics: RouteDefinition<FeedAnalyticsRequest, FeedAnalyticsResponse>;
    claim: {
      challenge: RouteDefinition<FeedClaimChallengeRequest, EmptyResponse>;
      list: RouteDefinition<{}, FeedClaimListResponse>;
      message: RouteDefinition<FeedClaimMessageQuery, FeedClaimMessageResponse>;
    };
  }>;
  readonly inboxes: ModuleDefinition<{
    get: RouteDefinition<InboxGetQuery, InboxGetResponse>;
    list: RouteDefinition<never, InboxListResponse>;
    post: RouteDefinition<InboxCreateRequest, EmptyResponse>;
    put: RouteDefinition<InboxUpdateRequest, EmptyResponse>;
    delete: RouteDefinition<InboxDeleteRequest, EmptyResponse>;
    email: RouteDefinition<InboxEmailRequest, EmptyResponse>;
    webhook: RouteDefinition<{
      guid: string;
      publishedAt: string;
      description?: string | null | undefined;
      title?: string | null | undefined;
      summary?: string | null | undefined;
      content?: string | null | undefined;
      author?: string | null | undefined;
      url?: string | null | undefined;
      language?: string | null | undefined;
      categories?: string[] | null | undefined;
      authorUrl?: string | null | undefined;
      authorAvatar?: string | null | undefined;
      read?: boolean | null | undefined;
      attachments?: {
        url: string;
        duration_in_seconds?: string | number | undefined;
        mime_type?: string | undefined;
        size_in_bytes?: number | undefined;
        title?: string | undefined;
      }[] | null | undefined;
      media?: {
        url: string;
        type: "photo" | "video";
        width?: number | undefined;
        height?: number | undefined;
        preview_image_url?: string | undefined;
        blurhash?: string | undefined;
      }[] | null | undefined;
      extra?: {
        links?: {
          url: string;
          type: string;
          content_html?: string | undefined;
        }[] | null | undefined;
        title_keyword?: string | undefined;
      } | null | undefined;
    }, EmptyResponse>;
  }>;
  readonly lists: ModuleDefinition<{
    get: RouteDefinition<GetListQuery, GetListResponse>;
    list: RouteDefinition<ListsListQuery, ListUserListsResponse>;
    create: RouteDefinition<CreateListRequest, CreateListResponse>;
    update: RouteDefinition<UpdateListRequest, UpdateListResponse>;
    delete: RouteDefinition<DeleteListRequest, DeleteListResponse>;
    addFeeds: RouteDefinition<AddFeedsRequest, AddFeedsResponse>;
    removeFeed: RouteDefinition<RemoveFeedRequest, RemoveFeedResponse>;
  }>;
  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>;
    testNotification: RouteDefinition<TestMessagingQuery, 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<{
    create: RouteDefinition<RSSHubCreateRequest, RSSHubCreateResponse>;
    list: RouteDefinition<{}, RSSHubListResponse>;
    delete: RouteDefinition<RSSHubDeleteRequest, RSSHubDeleteResponse>;
    use: RouteDefinition<RSSHubUseRequest, RSSHubUseResponse>;
    get: RouteDefinition<RSSHubGetQuery, RSSHubGetResponse>;
    status: RouteDefinition<{}, RSSHubStatusResponse>;
  }>;
  readonly settings: ModuleDefinition<{
    get: RouteDefinition<SettingsGetQuery, SettingsGetResponse>;
    update: RouteDefinition<SettingsUpdateInput, EmptyResponse>;
  }>;
  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 updates: ModuleDefinition<{
    getLatestRelease: RouteDefinition<GetLatestReleaseQuery, GetLatestReleaseResponse>;
    getManifest: RouteDefinition<GetManifestRequest, string>;
    getDistributionStatus: RouteDefinition<GetDistributionStatusRequest, GetDistributionStatusResponse>;
  }>;
  readonly wallets: ModuleDefinition<{
    get: RouteDefinition<never, WalletsGetResponse>;
    post: RouteDefinition<never, WalletsPostResponse>;
    transactions: {
      get: RouteDefinition<TransactionQuery, TransactionsGetResponse>;
      withdraw: RouteDefinition<WithdrawRequest, WithdrawResponse>;
    };
  }>;
};
/**
 * 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 StructuredSuccessResponse<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/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, AIAnalyticsAPI, AIChatMessage, AIChatSession, AIChatSessionsAPI, AIMemoryCreateRequest, AIMemoryListQuery, AIMemoryListResponse, AIMemoryRecord, AIMemoryUpdateRequest, AISettings, AITask, AITaskAPI, ActionConditionIndex, ActionFeedField, ActionFilterItem, ActionId, type ActionItem, ActionOperation, ActionsAPI, ActionsGetResponse, type ActionsModel, ActionsPutRequest, ActionsPutResponse, AddFeedsRequest, AddFeedsResponse, AdminAPI, AffectedUser, AffectedUsersInput, AffectedUsersQuery, AffectedUsersResponse, AnalyticsData, AnalyticsRequest, AnalyticsResponse, ApiRequest, ApiResponse, AppUpdate, AppearanceSettings, AttachmentLimits, AuthAPI, AuthSession, AuthSessionResponse, AuthUser, BullMQStatus, CategoriesAPI, CategoriesGetQuery, CategoriesGetResponse, CategoryDeleteRequest, CategoryDeleteResponse, CategoryPatchRequest, CategoryPatchResponse, ChatAttachmentUploadData, ChatContext, ChatIdRequest, ChatMessage, ChatMetadata, ChatRequest, ChatResponse, CheckBullMQRequest, CheckBullMQResponse, CheckNewEntriesQuery, CheckNewEntriesResponse, CheckPostgreSQLResponse, CheckRedisResponse, CleanRequest, CleanResponse, ClientConfig, CollectionCheckQuery, CollectionCheckResponse, CollectionCreateRequest, CollectionCreateResponse, CollectionDeleteRequest, CollectionDeleteResponse, CollectionsAPI, ConfigResponse, ConnectionParams, CreateConnectionRequest, CreateConnectionResponse, CreateListRequest, CreateListResponse, CreateMessagingTokenRequest, CreateMessagingTokenResponse, CreateTaskRequest, DailyPattern, DailyRequest, DailyResponse, DataAPI, DateISOString, DateToString, DeleteConnectionResponse, DeleteListRequest, DeleteListResponse, DeleteMessagingTokenRequest, DeleteMessagingTokenResponse, DeleteSessionRequest, DiscoverAPI, DiscoverRequest, DiscoverResponse, DiscoveryItem, DistributionStatusPayload, EmptyResponse, EntriesAPI, EntryAttachment, EntryData, EntryExtraResponse, EntryGetByIdResponse, EntryGetQuery, EntryIdRequest, EntryInsert, EntryListRequest, EntryListResponse, EntryMedia, EntryModel, EntryOpenAPISchema, EntryPreviewRequest, EntryPreviewResponse, EntryReadabilityRequest, EntryReadabilityResponse, EntrySchema, EntrySettings, EntryStreamItem, EntryStreamRequest, EntryStringKey, EntryTagSummary, EntryTagsQueryRequest, EntryTagsQueryResponse, EntryTranscriptionRequest, EntryTranscriptionResponse, EntryWithFeed, ErrorResponse, ExceptionCodeMap, ExtractResponseData, FEATURE_NAMES, FeatureFlagInsert, FeatureFlagListResponse, FeatureFlagModel, FeatureFlagResponse, FeatureFlagUpdateInput, FeatureFlagUpdateRequest, type FeatureName, FeatureStatsInput, FeatureStatsResponse, FeedAnalyticsModel, FeedAnalyticsRequest, FeedAnalyticsResponse, FeedClaimChallengeRequest, FeedClaimChallengeResponse, FeedClaimListItem, FeedClaimListResponse, FeedClaimMessageData, FeedClaimMessageQuery, FeedClaimMessageResponse, FeedDiscoveryResult, FeedGetQuery, FeedGetResponse, FeedIdRequest, FeedInsert, FeedModel, FeedRefreshQuery, FeedRefreshResponse, FeedResetQuery, FeedResetResponse, FeedSchema, FeedViewType, FeedsAPI, FollowAPIError, FollowAPIErrorResponse, FollowAPIResponse, FollowAuthError, FollowClient, type FollowClientConfig, FollowTimeoutError, FollowValidationError, FreeQuota, GeneralSettings, GetConnectionsResponse, GetDistributionStatusRequest, GetDistributionStatusResponse, GetLatestReleaseQuery, GetLatestReleaseResponse, GetListData, GetListQuery, GetListResponse, GetManifestRequest, GetMessagesQuery, GetMessagesResponse, GetMessagingTokensResponse, GetProfileRequest, GetProfileResponse, GetProfilesBatchRequest, GetProfilesBatchResponse, GetRSSHubAnalyticsRequest, GetRSSHubAnalyticsResponse, GetSessionRequest, GetStatusConfigsResponse, GetToolsResponse, GetTrendingFeedsRequest, GetTrendingFeedsResponse, GetUnreadQuery, GetUnreadResponse, GoogleAnalyticsRequest, GoogleAnalyticsResponse, HTTPMethod, IdRequest, ImportConflictItem, ImportErrorItem, ImportSuccessItem, InboxCreateRequest, InboxCreateResponse, InboxDeleteRequest, InboxDeleteResponse, InboxEmailRequest, InboxEmailResponse, InboxEntryGetQuery, InboxEntryGetResponse, InboxGetQuery, InboxGetResponse, InboxListEntry, InboxListEntryRequestInput, InboxListEntryResponse, InboxListResponse, InboxRemoveInput, InboxSchema, InboxSubscriptionResponse, InboxUpdateRequest, InboxUpdateResponse, InboxWebhookRequest, InboxWebhookResponse, InboxesAPI, IntegrationSettings, LatestReleasePayload, ListAnalyticsSchema, ListDiscoveryResult, ListIdRequest, ListInsert, ListModel, ListSchema, ListSessionsQuery, ListSessionsResponse, ListSubscriptionModel, ListSubscriptionResponse, ListSubscriptionSchema, ListUserListsResponse, ListWithStats, ListsAPI, ListsListQuery, MarkAllAsReadRequest, MarkAllAsReadResponse, MarkAsReadRequest, MarkAsUnreadRequest, MarkReadInput, MarkSeenRequest, MarkUnreadInput, McpAPI, McpConnectionInfo, McpTool, McpTransportType, MessageResponse, MessagingAPI, MessagingChannel, MintRequest, MintResponse, ModelPattern, ModuleAPIs, ModuleRegistry, NetworkError, PaginatedData, PaginatedResponse, PaginationParams, PaginationResponse, ParsedEntry, ParsedSubscription, PlainSuccessResponse, PlatformUpdate, PlatformUpdateFile, ProbesAPI, ProfilesAPI, ROLLOUT_TYPES, RSSHubAPI, RSSHubAnalyticsItem, RSSHubAnalyticsQuery, RSSHubAnalyticsResponse, RSSHubCreateRequest, RSSHubCreateResponse, RSSHubDeleteRequest, RSSHubDeleteResponse, RSSHubGetQuery, RSSHubGetResponse, RSSHubInstanceData, RSSHubInstanceDetails, RSSHubListItem, RSSHubListResponse, RSSHubModel, RSSHubNamespace, RSSHubOwner, RSSHubPurchase, RSSHubQuery, RSSHubResponse, RSSHubRouteAnalytics, RSSHubRouteData, RSSHubRouteMetadata, RSSHubRouteQuery, RSSHubRouteResponse, RSSHubStatusData, RSSHubStatusResponse, RSSHubUsageModel, RSSHubUseRequest, RSSHubUseResponse, RateLimit, ReadHistoriesInput, ReadHistoriesQuery, ReadHistoriesResponse, ReadOperationResponse, ReadStatusQuery, ReadStatusResponse, ReadsAPI, ReferralsAPI, RefreshResult, RefreshToolsRequest, RefreshToolsResponse, RemoveFeedRequest, RemoveFeedResponse, RemoveOverrideInput, RendererUpdate, RequestContentType, RequestOptions, ResponseContentType, ResponseStruct, RolloutType, RolloutValue, SETTINGS_TABS, SerializedInsertModel, SerializedModel, SessionResponse, SettingsAPI, SettingsBackup, SettingsDiff, SettingsGetQuery, SettingsGetResponse, SettingsHistoryEntry, SettingsInsert, SettingsManager, SettingsMetadata, SettingsMigration, SettingsModel, SettingsOperationResult, SettingsPayload, SettingsTab, SettingsUpdateInput, SettingsUpdateRequest, SettingsUpdateResponse, SettingsValidationResult, SettingsValue, StatusAPI, type StatusConfigs, StoreDistribution, StructuredSuccessResponse, SubscriptionBatchRequest, SubscriptionBatchResponse, SubscriptionCreateRequest, SubscriptionCreateResponse, SubscriptionDeleteRequest, SubscriptionDeleteResponse, SubscriptionExportQuery, SubscriptionExportResponse, SubscriptionGetQuery, SubscriptionGetResponse, SubscriptionImportResponse, SubscriptionInsert, SubscriptionModel, SubscriptionParseOpmlResponse, SubscriptionUpdateRequest, SubscriptionUpdateResponse, SubscriptionWithFeed, SubscriptionsAPI, SummaryRequest, SummaryResponse, SupportedLanguages, TaskCreateResponse, TaskDeleteResponse, TaskGetResponse, TaskListResponse, type TaskSchedule, TaskTestRunResponse, TaskUpdateResponse, TestMessagingQuery, TestMessagingResponse, TextToSpeechRequest, TextToSpeechResponse, TextToSpeechSource, TitleErrorResponse, TitleRequest, TitleResponse, TokenUsage, TokenUsageHistory, TotalUnreadCountResponse, TransactionModel, TransactionQuery, TransactionType, TransactionTypes, TransactionWithRelations, TransactionsGetResponse, TranslationBatchRequest, TranslationBatchResponse, TranslationBatchStreamChunk, TranslationData, TranslationRequest, TranslationResponse, TrendingAPI, TrendingFeedItem, TwoFactorAuth, TypedSettings, UpdateAsset, UpdateConnectionRequest, UpdateConnectionResponse, UpdateDecision, UpdateListRequest, UpdateListResponse, UpdateRelease, UpdateSessionRequest, UpdateTaskRequest, UpdatesAPI, UploadAPI, UploadAvatarRequest, UploadAvatarResponse, UploadChatAttachmentRequest, UploadChatAttachmentResponse, UsagePattern, UsageRequest, UsageResponse, UserFeatureOverrideInsert, UserFeatureOverrideModel, UserIdRequest, UserModel, UserModelPublic, UserOverrideInput, UserOverrideRequest, UserProfile, type UserRole, WalletModel, WalletsAPI, WalletsGetResponse, WalletsPostResponse, WithdrawRequest, WithdrawResponse, actionsModule, adminModule, aiAnalyticsModule, aiChatSessionsModule, aiModule, aiTaskModule, authModule, categoriesModule, collectionsModule, dataModule, discoverModule, entriesModule, extractResponseData, feedsModule, inboxesModule, isErrorResponse, isSuccessResponse, listsModule, mcpModule, messagingModule, moduleRegistry, probesModule, profilesModule, readsModule, referralsModule, rsshubModule, settingsModule, statusModule, subscriptionsModule, trendingModule, updatesModule, uploadModule, walletsModule };
//# sourceMappingURL=index.d.mts.map