@follow-app/client-sdk/dist/index.d.cts

TypeScript client SDK for Follow RSS Server API

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 { ACHIEVEMENTS_TYPES, FEATURE_NAMES, FeatureName, FeedViewType, FeedViewType as FeedViewType$1, SETTINGS_TABS, UserRole, UserRole as UserRole$1 } from "@folo-services/constants";
import { FeedOpenApiSchema, InboxOpenApiSchema, ListOpenApiSchema, StatusConfigs, StatusConfigs as StatusConfigs$1 } from "@folo-services/shared";
import { ExceptionCodeMap } from "@folo-services/exceptions";

//#region src/types/api.d.ts
/**
 * Standard Follow API response wrapper
 */
interface FollowAPIResponse<T = any> {
  code: number;
  data: T;
  message?: string;
}
/**
 * Error response from Follow API
 */
interface FollowAPIErrorResponse {
  code: number;
  message: string;
  data?: any;
}
/**
 * Generic type for requests that only contain an id parameter
 */
interface IdRequest {
  id: string;
}
/**
 * Generic type for requests that only contain a feedId parameter
 */
interface FeedIdRequest {
  feedId: string;
}
/**
 * Generic type for requests that only contain a listId parameter
 */
interface ListIdRequest {
  listId: string;
}
/**
 * Generic type for requests that only contain a userId parameter
 */
interface UserIdRequest {
  userId: string;
}
/**
 * Generic type for requests that only contain an entryId parameter
 */
interface EntryIdRequest {
  entryId: string;
}
/**
 * HTTP methods supported by the client
 */
type HTTPMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
/**
 * Request content types
 */
type RequestContentType = "json" | "formData" | "text" | "blob" | "arrayBuffer";
/**
 * Response content types
 */
type ResponseContentType = "json" | "text" | "blob" | "arrayBuffer" | "stream" | "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<S