ani-client 1.4.4 → 1.5.1

package/dist/index.d.mts

@@ -348,27 +348,32 @@ interface Studio {
     name: string;
     isAnimationStudio: boolean;
     siteUrl: string | null;
-}
-interface StudioConnection {
-    nodes: Studio[];
-}
-interface StudioDetail {
-    id: number;
-    name: string;
-    isAnimationStudio: boolean;
-    siteUrl: string | null;
-    favourites: number | null;
-    media: {
+    favourites?: number | null;
+    media?: {
         pageInfo: PageInfo;
         nodes: Pick<Media, "id" | "title" | "type" | "format" | "coverImage" | "siteUrl">[];
     } | null;
 }
+interface StudioConnection {
+    nodes: Studio[];
+}
 interface SearchStudioOptions {
     query?: string;
     page?: number;
     perPage?: number;
 }
 
+declare enum UserSort {
+    ID = "ID",
+    ID_DESC = "ID_DESC",
+    USERNAME = "USERNAME",
+    USERNAME_DESC = "USERNAME_DESC",
+    WATCHED_TIME = "WATCHED_TIME",
+    WATCHED_TIME_DESC = "WATCHED_TIME_DESC",
+    CHAPTERS_READ = "CHAPTERS_READ",
+    CHAPTERS_READ_DESC = "CHAPTERS_READ_DESC",
+    SEARCH_MATCH = "SEARCH_MATCH"
+}
 interface UserAvatar {
     large: string | null;
     medium: string | null;
@@ -398,11 +403,34 @@ interface User {
         manga: UserStatistics;
     } | null;
 }
+interface SearchUserOptions {
+    query?: string;
+    sort?: UserSort[];
+    page?: number;
+    perPage?: number;
+}
 
 declare enum MediaType {
     ANIME = "ANIME",
     MANGA = "MANGA"
 }
+declare enum MediaSource {
+    ORIGINAL = "ORIGINAL",
+    MANGA = "MANGA",
+    LIGHT_NOVEL = "LIGHT_NOVEL",
+    VISUAL_NOVEL = "VISUAL_NOVEL",
+    VIDEO_GAME = "VIDEO_GAME",
+    OTHER = "OTHER",
+    NOVEL = "NOVEL",
+    DOUJINSHI = "DOUJINSHI",
+    ANIME = "ANIME",
+    WEB_NOVEL = "WEB_NOVEL",
+    LIVE_ACTION = "LIVE_ACTION",
+    GAME = "GAME",
+    COMIC = "COMIC",
+    MULTIMEDIA_PROJECT = "MULTIMEDIA_PROJECT",
+    PICTURE_BOOK = "PICTURE_BOOK"
+}
 declare enum MediaFormat {
     TV = "TV",
     TV_SHORT = "TV_SHORT",
@@ -558,6 +586,13 @@ interface MediaRecommendationNode {
     rating: number | null;
     mediaRecommendation: Pick<Media, "id" | "title" | "type" | "format" | "coverImage" | "averageScore" | "siteUrl">;
 }
+interface NextAiringEpisode {
+    id: number;
+    airingAt: number;
+    episode: number;
+    mediaId: number;
+    timeUntilAiring: number;
+}
 interface Media {
     id: number;
     idMal: number | null;
@@ -576,7 +611,7 @@ interface Media {
     volumes: number | null;
     countryOfOrigin: string | null;
     isLicensed: boolean | null;
-    source: string | null;
+    source: MediaSource | null;
     hashtag: string | null;
     trailer: MediaTrailer | null;
     coverImage: MediaCoverImage;
@@ -599,6 +634,7 @@ interface Media {
     recommendations?: {
         nodes: MediaRecommendationNode[];
     };
+    nextAiringEpisode: NextAiringEpisode | null;
     isAdult: boolean | null;
     siteUrl: string | null;
 }
@@ -609,8 +645,18 @@ interface SearchMediaOptions {
     status?: MediaStatus;
     season?: MediaSeason;
     seasonYear?: number;
+    /** Single genre filter (kept for backward compat) */
     genre?: string;
+    /** Single tag filter (kept for backward compat) */
     tag?: string;
+    /** Filter by multiple genres (media must match ALL) */
+    genres?: string[];
+    /** Filter by multiple tags (media must match ALL) */
+    tags?: string[];
+    /** Exclude media with any of these genres */
+    genresExclude?: string[];
+    /** Exclude media with any of these tags */
+    tagsExclude?: string[];
     isAdult?: boolean;
     sort?: MediaSort[];
     page?: number;
@@ -716,6 +762,96 @@ interface AiringSchedule {
     mediaId: number;
     media: Media;
 }
+type DayOfWeek = "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | "Sunday";
+type WeeklySchedule = Record<DayOfWeek, AiringSchedule[]>;
+
+/** Represents a forum thread on AniList. */
+interface Thread {
+    id: number;
+    title: string;
+    body: string | null;
+    userId: number;
+    replyUserId: number | null;
+    replyCommentId: number | null;
+    replyCount: number;
+    viewCount: number;
+    isLocked: boolean;
+    isSticky: boolean;
+    isSubscribed: boolean;
+    repliedAt: number | null;
+    createdAt: number;
+    updatedAt: number;
+    siteUrl: string | null;
+    user: {
+        id: number;
+        name: string;
+        avatar: UserAvatar;
+    } | null;
+    replyUser: {
+        id: number;
+        name: string;
+        avatar: UserAvatar;
+    } | null;
+    categories: ThreadCategory[] | null;
+    mediaCategories: ThreadMediaCategory[] | null;
+    likes: {
+        id: number;
+        name: string;
+    }[] | null;
+}
+interface ThreadCategory {
+    id: number;
+    name: string;
+}
+interface ThreadMediaCategory {
+    id: number;
+    title: {
+        romaji: string | null;
+        english: string | null;
+        native: string | null;
+        userPreferred: string | null;
+    };
+    type: string;
+    coverImage: {
+        large: string | null;
+        medium: string | null;
+    } | null;
+    siteUrl: string | null;
+}
+/** Sort options for thread queries. */
+declare enum ThreadSort {
+    ID = "ID",
+    ID_DESC = "ID_DESC",
+    TITLE = "TITLE",
+    TITLE_DESC = "TITLE_DESC",
+    CREATED_AT = "CREATED_AT",
+    CREATED_AT_DESC = "CREATED_AT_DESC",
+    UPDATED_AT = "UPDATED_AT",
+    UPDATED_AT_DESC = "UPDATED_AT_DESC",
+    REPLIED_AT = "REPLIED_AT",
+    REPLIED_AT_DESC = "REPLIED_AT_DESC",
+    REPLY_COUNT = "REPLY_COUNT",
+    REPLY_COUNT_DESC = "REPLY_COUNT_DESC",
+    VIEW_COUNT = "VIEW_COUNT",
+    VIEW_COUNT_DESC = "VIEW_COUNT_DESC",
+    IS_STICKY = "IS_STICKY",
+    SEARCH_MATCH = "SEARCH_MATCH"
+}
+/** Options for searching/listing threads. */
+interface SearchThreadOptions {
+    /** Search query */
+    query?: string;
+    /** Filter by media ID */
+    mediaId?: number;
+    /** Filter by category ID */
+    categoryId?: number;
+    /** Sort order */
+    sort?: ThreadSort[];
+    /** Page number */
+    page?: number;
+    /** Results per page (max 50) */
+    perPage?: number;
+}
 
 /**
  * Lightweight AniList GraphQL client with built-in caching and rate limiting.
@@ -725,7 +861,7 @@ interface AiringSchedule {
  * import { AniListClient } from "ani-client";
  *
  * const client = new AniListClient();
- * const anime = await client.getMedia(1); // Cowboy Bebop
+ * const anime = await client.getMedia(1);
  * console.log(anime.title.romaji);
  *
  * // Custom cache & rate limit options
@@ -743,17 +879,12 @@ declare class AniListClient {
     private readonly hooks;
     private readonly inFlight;
     constructor(options?: AniListClientOptions);
-    /**
-     * @internal
-     */
-    private request;
+    /** @internal */
+    request<T>(query: string, variables?: Record<string, unknown>): Promise<T>;
     /** @internal */
     private executeRequest;
-    /**
-     * @internal
-     * Shorthand for paginated queries that follow the `Page { pageInfo, <field>[] }` pattern.
-     */
-    private pagedRequest;
+    /** @internal */
+    pagedRequest<T>(query: string, variables: Record<string, unknown>, field: string): Promise<PagedResult<T>>;
     /**
      * Fetch a single media entry by its AniList ID.
      *
@@ -761,33 +892,6 @@ declare class AniListClient {
      *
      * @param id - The AniList media ID
      * @param include - Optional related data to include
-     * @returns The media object
-     *
-     * @example
-     * ```ts
-     * // Basic usage — same as before (includes relations by default)
-     * const anime = await client.getMedia(1);
-     *
-     * // Include characters sorted by role, 25 results
-     * const anime = await client.getMedia(1, { characters: true });
-     *
-     * // Include characters with voice actors
-     * const anime = await client.getMedia(1, { characters: { voiceActors: true } });
-     *
-     * // Full control
-     * const anime = await client.getMedia(1, {
-     *   characters: { perPage: 50, sort: true },
-     *   staff: true,
-     *   relations: true,
-     *   streamingEpisodes: true,
-     *   externalLinks: true,
-     *   stats: true,
-     *   recommendations: { perPage: 5 },
-     * });
-     *
-     * // Exclude relations for a lighter response
-     * const anime = await client.getMedia(1, { characters: true, relations: false });
-     * ```
      */
     getMedia(id: number, include?: MediaIncludeOptions): Promise<Media>;
     /**
@@ -795,335 +899,81 @@ declare class AniListClient {
      *
      * @param options - Search / filter parameters
      * @returns Paginated results with matching media
-     *
-     * @example
-     * ```ts
-     * const results = await client.searchMedia({
-     *   query: "Naruto",
-     *   type: MediaType.ANIME,
-     *   perPage: 5,
-     * });
-     * ```
      */
     searchMedia(options?: SearchMediaOptions): Promise<PagedResult<Media>>;
-    /**
-     * Get currently trending anime or manga.
-     *
-     * @param type - `MediaType.ANIME` or `MediaType.MANGA` (defaults to ANIME)
-     * @param page - Page number (default 1)
-     * @param perPage - Results per page (default 20, max 50)
-     */
+    /** Get currently trending anime or manga. */
     getTrending(type?: MediaType, page?: number, perPage?: number): Promise<PagedResult<Media>>;
-    /**
-     * Fetch a character by AniList ID.
-     *
-     * @param id - The AniList character ID
-     * @param include - Optional include options (e.g. voice actors)
-     * @returns The character object
-     *
-     * @example
-     * ```ts
-     * const spike = await client.getCharacter(1);
-     * console.log(spike.name.full); // "Spike Spiegel"
-     *
-     * // With voice actors
-     * const spike = await client.getCharacter(1, { voiceActors: true });
-     * spike.media?.edges?.forEach((e) => {
-     *   console.log(e.node.title.romaji);
-     *   e.voiceActors?.forEach((va) => console.log(`  VA: ${va.name.full}`));
-     * });
-     * ```
-     */
-    getCharacter(id: number, include?: CharacterIncludeOptions): Promise<Character>;
-    /**
-     * Search for characters by name.
-     *
-     * @param options - Search / pagination parameters (includes optional `voiceActors`)
-     * @returns Paginated results with matching characters
-     *
-     * @example
-     * ```ts
-     * const result = await client.searchCharacters({ query: "Luffy", perPage: 5 });
-     *
-     * // With voice actors
-     * const result = await client.searchCharacters({ query: "Luffy", voiceActors: true });
-     * ```
-     */
-    searchCharacters(options?: SearchCharacterOptions): Promise<PagedResult<Character>>;
-    /**
-     * Fetch a staff member by AniList ID.
-     *
-     * @param id - The AniList staff ID
-     * @param include - Optional include options to fetch related data (e.g. media)
-     * @returns The staff object
-     *
-     * @example
-     * ```ts
-     * const staff = await client.getStaff(95001);
-     * console.log(staff.name.full);
-     *
-     * // With media the staff worked on
-     * const staff = await client.getStaff(95001, { media: true });
-     * staff.staffMedia?.nodes.forEach((m) => console.log(m.title.romaji));
-     * ```
-     */
-    getStaff(id: number, include?: StaffIncludeOptions): Promise<Staff>;
-    /**
-     * Search for staff (voice actors, directors, etc.).
-     *
-     * @param options - Search / pagination parameters
-     * @returns Paginated results with matching staff
-     *
-     * @example
-     * ```ts
-     * const result = await client.searchStaff({ query: "Miyazaki", perPage: 5 });
-     * ```
-     */
-    searchStaff(options?: SearchStaffOptions): Promise<PagedResult<Staff>>;
-    /**
-     * Fetch a user by AniList ID.
-     *
-     * @param id - The AniList user ID
-     * @returns The user object
-     *
-     * @example
-     * ```ts
-     * const user = await client.getUser(1);
-     * console.log(user.name);
-     * ```
-     */
-    getUser(id: number): Promise<User>;
-    /**
-     * Fetch a user by username.
-     *
-     * @param name - The AniList username
-     * @returns The user object
-     *
-     * @example
-     * ```ts
-     * const user = await client.getUserByName("AniList");
-     * console.log(user.statistics);
-     * ```
-     */
-    getUserByName(name: string): Promise<User>;
-    /**
-     * Execute an arbitrary GraphQL query against the AniList API.
-     * Useful for advanced use-cases not covered by the built-in methods.
-     *
-     * @param query - A valid GraphQL query string
-     * @param variables - Optional variables object
-     */
-    raw<T = unknown>(query: string, variables?: Record<string, unknown>): Promise<T>;
-    /**
-     * Get recently aired anime episodes.
-     *
-     * By default returns episodes that aired in the last 24 hours.
-     *
-     * @param options - Filter / pagination parameters
-     * @returns Paginated list of airing schedule entries
-     *
-     * @example
-     * ```ts
-     * // Episodes that aired in the last 48h
-     * const recent = await client.getAiredEpisodes({
-     *   airingAtGreater: Math.floor(Date.now() / 1000) - 48 * 3600,
-     * });
-     * ```
-     */
+    /** Get the most popular anime or manga. */
+    getPopular(type?: MediaType, page?: number, perPage?: number): Promise<PagedResult<Media>>;
+    /** Get the highest-rated anime or manga. */
+    getTopRated(type?: MediaType, page?: number, perPage?: number): Promise<PagedResult<Media>>;
+    /** Get recently aired anime episodes. */
     getAiredEpisodes(options?: GetAiringOptions): Promise<PagedResult<AiringSchedule>>;
-    /**
-     * Get manga that are currently releasing, sorted by most recently updated.
-     *
-     * This is the closest equivalent to "recently released chapters" on AniList,
-     * since the API does not expose per-chapter airing schedules for manga.
-     *
-     * @param options - Pagination parameters
-     * @returns Paginated list of currently releasing manga
-     *
-     * @example
-     * ```ts
-     * const chapters = await client.getAiredChapters({ perPage: 10 });
-     * ```
-     */
+    /** Get currently releasing manga. */
     getAiredChapters(options?: GetRecentChaptersOptions): Promise<PagedResult<Media>>;
-    /**
-     * Get upcoming (not yet released) anime and/or manga, sorted by popularity.
-     *
-     * @param options - Filter / pagination parameters
-     * @returns Paginated list of planned media
-     *
-     * @example
-     * ```ts
-     * import { MediaType } from "ani-client";
-     *
-     * // Most anticipated upcoming anime
-     * const planning = await client.getPlanning({ type: MediaType.ANIME, perPage: 10 });
-     * ```
-     */
+    /** Get the detailed schedule for the current week, sorted by day. */
+    getWeeklySchedule(date?: Date): Promise<WeeklySchedule>;
+    /** Get upcoming (not yet released) media. */
     getPlanning(options?: GetPlanningOptions): Promise<PagedResult<Media>>;
-    /**
-     * Get recommendations for a specific media.
-     *
-     * Returns other anime/manga that users have recommended based on the given media.
-     *
-     * @param mediaId - The AniList media ID
-     * @param options - Optional sort / pagination parameters
-     * @returns Paginated list of recommendations
-     *
-     * @example
-     * ```ts
-     * // Get recommendations for Cowboy Bebop
-     * const recs = await client.getRecommendations(1);
-     * recs.results.forEach((r) =>
-     *   console.log(`${r.mediaRecommendation.title.romaji} (rating: ${r.rating})`)
-     * );
-     * ```
-     */
+    /** Get recommendations for a specific media. */
     getRecommendations(mediaId: number, options?: Omit<GetRecommendationsOptions, "mediaId">): Promise<PagedResult<Recommendation>>;
-    /**
-     * Get anime (or manga) for a specific season and year.
-     *
-     * @param options - Season, year and optional filter / pagination parameters
-     * @returns Paginated list of media for the given season
-     *
-     * @example
-     * ```ts
-     * import { MediaSeason } from "ani-client";
-     *
-     * const winter2026 = await client.getMediaBySeason({
-     *   season: MediaSeason.WINTER,
-     *   seasonYear: 2026,
-     *   perPage: 10,
-     * });
-     * ```
-     */
+    /** Get anime (or manga) for a specific season and year. */
     getMediaBySeason(options: GetSeasonOptions): Promise<PagedResult<Media>>;
+    /** Fetch a character by AniList ID. Pass `{ voiceActors: true }` to include VA data. */
+    getCharacter(id: number, include?: CharacterIncludeOptions): Promise<Character>;
+    /** Search for characters by name. */
+    searchCharacters(options?: SearchCharacterOptions): Promise<PagedResult<Character>>;
+    /** Fetch a staff member by AniList ID. Pass `{ media: true }` or `{ media: { perPage } }` for media credits. */
+    getStaff(id: number, include?: StaffIncludeOptions): Promise<Staff>;
+    /** Search for staff (voice actors, directors, etc.). */
+    searchStaff(options?: SearchStaffOptions): Promise<PagedResult<Staff>>;
     /**
-     * Get a user's anime or manga list.
-     *
-     * Provide either `userId` or `userName` to identify the user.
-     * Requires `type` (ANIME or MANGA). Optionally filter by list status.
+     * Fetch a user by AniList ID or username.
      *
-     * @param options - User identifier, media type, and optional filters
-     * @returns Paginated list of media list entries
-     *
-     * @example
-     * ```ts
-     * import { MediaType, MediaListStatus } from "ani-client";
-     *
-     * // Get a user's completed anime list
-     * const list = await client.getUserMediaList({
-     *   userName: "AniList",
-     *   type: MediaType.ANIME,
-     *   status: MediaListStatus.COMPLETED,
-     * });
-     * list.results.forEach((entry) =>
-     *   console.log(`${entry.media.title.romaji} — ${entry.score}/100`)
-     * );
-     * ```
+     * @param idOrName - The AniList user ID (number) or username (string)
      */
+    getUser(idOrName: number | string): Promise<User>;
+    /** Search for users by name. */
+    searchUsers(options?: SearchUserOptions): Promise<PagedResult<User>>;
+    /** Get a user's anime or manga list. */
     getUserMediaList(options: GetUserMediaListOptions): Promise<PagedResult<MediaListEntry>>;
-    /**
-     * Fetch a studio by its AniList ID.
-     *
-     * Returns studio details along with its most popular productions.
-     *
-     * @param id - The AniList studio ID
-     */
-    getStudio(id: number): Promise<StudioDetail>;
-    /**
-     * Search for studios by name.
-     *
-     * @param options - Search / pagination parameters
-     * @returns Paginated list of studios
-     *
-     * @example
-     * ```ts
-     * const studios = await client.searchStudios({ query: "MAPPA" });
-     * ```
-     */
-    searchStudios(options?: SearchStudioOptions): Promise<PagedResult<StudioDetail>>;
-    /**
-     * Get all available genres on AniList.
-     *
-     * @returns Array of genre strings (e.g. "Action", "Adventure", ...)
-     */
+    /** Fetch a studio by its AniList ID. */
+    getStudio(id: number): Promise<Studio>;
+    /** Search for studios by name. */
+    searchStudios(options?: SearchStudioOptions): Promise<PagedResult<Studio>>;
+    /** Fetch a forum thread by its AniList ID. */
+    getThread(id: number): Promise<Thread>;
+    /** Get recent forum threads, optionally filtered by search, media, or category. */
+    getRecentThreads(options?: SearchThreadOptions): Promise<PagedResult<Thread>>;
+    /** Get all available genres on AniList. */
     getGenres(): Promise<string[]>;
-    /**
-     * Get all available media tags on AniList.
-     *
-     * @returns Array of tag objects with id, name, description, category, isAdult
-     */
+    /** Get all available media tags on AniList. */
     getTags(): Promise<MediaTag[]>;
+    /** Execute an arbitrary GraphQL query against the AniList API. */
+    raw<T>(query: string, variables?: Record<string, unknown>): Promise<T>;
     /**
-     * Auto-paginating async iterator.
-     *
-     * Wraps any paginated method and yields individual items across all pages.
-     * Stops when `hasNextPage` is `false` or `maxPages` is reached.
+     * Auto-paginating async iterator. Yields individual items across all pages.
      *
      * @param fetchPage - A function that takes a page number and returns a `PagedResult<T>`
      * @param maxPages - Maximum number of pages to fetch (default: Infinity)
-     * @returns An async iterable iterator of individual items
-     *
-     * @example
-     * ```ts
-     * // Iterate over all search results
-     * for await (const anime of client.paginate((page) =>
-     *   client.searchMedia({ query: "Naruto", page, perPage: 10 })
-     * )) {
-     *   console.log(anime.title.romaji);
-     * }
-     *
-     * // Limit to 3 pages
-     * for await (const anime of client.paginate(
-     *   (page) => client.getTrending(MediaType.ANIME, page, 20),
-     *   3,
-     * )) {
-     *   console.log(anime.title.romaji);
-     * }
-     * ```
      */
     paginate<T>(fetchPage: (page: number) => Promise<PagedResult<T>>, maxPages?: number): AsyncGenerator<T, void, undefined>;
-    /**
-     * Fetch multiple media entries in a single API request.
-     * Uses GraphQL aliases to batch up to 50 IDs per call.
-     *
-     * @param ids - Array of AniList media IDs
-     * @returns Array of media objects (same order as input IDs)
-     */
+    /** Fetch multiple media entries in a single API request. */
     getMediaBatch(ids: number[]): Promise<Media[]>;
-    /**
-     * Fetch multiple characters in a single API request.
-     *
-     * @param ids - Array of AniList character IDs
-     * @returns Array of character objects (same order as input IDs)
-     */
+    /** Fetch multiple characters in a single API request. */
     getCharacterBatch(ids: number[]): Promise<Character[]>;
-    /**
-     * Fetch multiple staff members in a single API request.
-     *
-     * @param ids - Array of AniList staff IDs
-     * @returns Array of staff objects (same order as input IDs)
-     */
+    /** Fetch multiple staff members in a single API request. */
     getStaffBatch(ids: number[]): Promise<Staff[]>;
     /** @internal */
     private executeBatch;
-    /**
-     * Clear the entire response cache.
-     */
+    /** Clear the entire response cache. */
     clearCache(): Promise<void>;
-    /**
-     * Number of entries currently in the cache.
-     * For async adapters like Redis, this may return a Promise.
-     */
+    /** Number of entries currently in the cache. */
     get cacheSize(): number | Promise<number>;
-    /**
-     * Remove cache entries whose key matches the given pattern.
-     *
-     * @param pattern — A string (converted to RegExp) or RegExp
-     * @returns Number of entries removed
-     */
+    /** Remove cache entries whose key matches the given pattern. */
     invalidateCache(pattern: string | RegExp): Promise<number>;
+    /** Clean up resources held by the client. */
+    destroy(): Promise<void>;
 }
 
 /**
@@ -1160,7 +1010,10 @@ declare class MemoryCache implements CacheAdapter {
     /**
      * Remove all entries whose key matches the given pattern.
      *
-     * @param pattern — A string (converted to RegExp) or RegExp.
+     * - **String**: treated as a substring match (e.g. `"Media"` removes all keys containing `"Media"`).
+     * - **RegExp**: tested against each key directly.
+     *
+     * @param pattern — A string (substring match) or RegExp.
      * @returns Number of entries removed.
      */
     invalidate(pattern: string | RegExp): number;
@@ -1253,8 +1106,10 @@ declare class RateLimiter {
     private readonly enabled;
     private readonly timeoutMs;
     private readonly retryOnNetworkError;
-    /** @internal */
-    private timestamps;
+    /** @internal — sliding window: circular buffer of timestamps */
+    private readonly timestamps;
+    private head;
+    private count;
     constructor(options?: RateLimitOptions);
     /**
      * Wait until it's safe to make a request (respects rate limit window).
@@ -1262,14 +1117,26 @@ declare class RateLimiter {
     acquire(): Promise<void>;
     /**
      * Execute a fetch with automatic retry on 429 responses and network errors.
+     * Uses exponential backoff with jitter for retry delays.
      */
     fetchWithRetry(url: string, init: RequestInit, hooks?: {
         onRetry?: (attempt: number, reason: string, delayMs: number) => void;
         onRateLimit?: (retryAfterMs: number) => void;
     }): Promise<Response>;
+    /** @internal — Exponential backoff with jitter, capped at 30s */
+    private exponentialDelay;
     /** @internal */
     private fetchWithTimeout;
     private sleep;
 }
 
-export { type AiringSchedule, AiringSort, AniListClient, type AniListClientOptions, AniListError, type AniListHooks, type CacheAdapter, type CacheOptions, type Character, type CharacterImage, type CharacterIncludeOptions, type CharacterMediaEdge, type CharacterName, CharacterRole, CharacterSort, type ExternalLink, type FuzzyDate, type GetAiringOptions, type GetPlanningOptions, type GetRecentChaptersOptions, type GetRecommendationsOptions, type GetSeasonOptions, type GetUserMediaListOptions, type Media, type MediaCharacterConnection, type MediaCharacterEdge, type MediaConnection, type MediaCoverImage, type MediaEdge, MediaFormat, type MediaIncludeOptions, type MediaListEntry, MediaListSort, MediaListStatus, type MediaRecommendationNode, MediaRelationType, MediaSeason, MediaSort, type MediaStaffConnection, type MediaStaffEdge, type MediaStats, MediaStatus, type MediaTag, type MediaTitle, type MediaTrailer, MediaType, MemoryCache, type PageInfo, type PagedResult, type RateLimitOptions, RateLimiter, type Recommendation, RecommendationSort, RedisCache, type RedisCacheOptions, type RedisLikeClient, type ScoreDistribution, type SearchCharacterOptions, type SearchMediaOptions, type SearchStaffOptions, type SearchStudioOptions, type Staff, type StaffImage, type StaffIncludeOptions, type StaffMediaNode, type StaffName, StaffSort, type StatusDistribution, type StreamingEpisode, type Studio, type StudioConnection, type StudioDetail, type User, type UserAvatar, type UserStatistics, type VoiceActor };
+/**
+ * Parses AniList specific markdown into standard HTML.
+ * Includes formatting for spoilers, images, videos (youtube/webm), and standard markdown elements.
+ *
+ * @param text The AniList markdown text to parse
+ * @returns The parsed HTML string
+ */
+declare function parseAniListMarkdown(text: string): string;
+
+export { type AiringSchedule, AiringSort, AniListClient, type AniListClientOptions, AniListError, type AniListHooks, type CacheAdapter, type CacheOptions, type Character, type CharacterImage, type CharacterIncludeOptions, type CharacterMediaEdge, type CharacterName, CharacterRole, CharacterSort, type DayOfWeek, type ExternalLink, type FuzzyDate, type GetAiringOptions, type GetPlanningOptions, type GetRecentChaptersOptions, type GetRecommendationsOptions, type GetSeasonOptions, type GetUserMediaListOptions, type Media, type MediaCharacterConnection, type MediaCharacterEdge, type MediaConnection, type MediaCoverImage, type MediaEdge, MediaFormat, type MediaIncludeOptions, type MediaListEntry, MediaListSort, MediaListStatus, type MediaRecommendationNode, MediaRelationType, MediaSeason, MediaSort, MediaSource, type MediaStaffConnection, type MediaStaffEdge, type MediaStats, MediaStatus, type MediaTag, type MediaTitle, type MediaTrailer, MediaType, MemoryCache, type NextAiringEpisode, type PageInfo, type PagedResult, type RateLimitOptions, RateLimiter, type Recommendation, RecommendationSort, RedisCache, type RedisCacheOptions, type RedisLikeClient, type ScoreDistribution, type SearchCharacterOptions, type SearchMediaOptions, type SearchStaffOptions, type SearchStudioOptions, type SearchThreadOptions, type SearchUserOptions, type Staff, type StaffImage, type StaffIncludeOptions, type StaffMediaNode, type StaffName, StaffSort, type StatusDistribution, type StreamingEpisode, type Studio, type StudioConnection, type Thread, type ThreadCategory, type ThreadMediaCategory, ThreadSort, type User, type UserAvatar, UserSort, type UserStatistics, type VoiceActor, type WeeklySchedule, parseAniListMarkdown };