ani-client 1.5.0 → 1.6.0

package/dist/index.d.mts

@@ -67,6 +67,16 @@ interface RateLimitOptions {
     timeoutMs?: number;
     /** Retry on network errors like ECONNRESET / ETIMEDOUT (default: true) */
     retryOnNetworkError?: boolean;
+    /**
+     * Custom retry delay strategy. Receives the attempt number (0-based) and the base delay,
+     * and should return the delay in ms before retrying.
+     * When omitted, the default exponential backoff with jitter is used.
+     *
+     * @example
+     * // Linear backoff: 1s, 2s, 3s, ...
+     * retryStrategy: (attempt) => (attempt + 1) * 1000
+     */
+    retryStrategy?: (attempt: number, baseDelayMs: number) => number;
 }
 /** Event hooks for logging, debugging, and monitoring. */
 interface AniListHooks {
@@ -79,7 +89,25 @@ interface AniListHooks {
     /** Called when a request is retried (429 or network error). */
     onRetry?: (attempt: number, reason: string, delayMs: number) => void;
     /** Called when a request completes. */
-    onResponse?: (query: string, durationMs: number, fromCache: boolean) => void;
+    onResponse?: (query: string, durationMs: number, fromCache: boolean, rateLimitInfo?: RateLimitInfo) => void;
+}
+/** Rate limit information parsed from AniList API response headers. */
+interface RateLimitInfo {
+    /** Maximum number of requests allowed per window. */
+    limit: number;
+    /** Remaining requests in the current window. */
+    remaining: number;
+    /** UNIX timestamp (seconds) when the rate limit window resets. */
+    reset: number;
+}
+/** Metadata about the last request, useful for debugging and monitoring. */
+interface ResponseMeta {
+    /** Duration of the request in milliseconds. */
+    durationMs: number;
+    /** Whether the response was served from cache. */
+    fromCache: boolean;
+    /** Rate limit information from the API response headers (not present for cached responses). */
+    rateLimitInfo?: RateLimitInfo;
 }
 interface AniListClientOptions {
     /** Optional AniList OAuth token for authenticated requests */
@@ -94,6 +122,8 @@ interface AniListClientOptions {
     rateLimit?: RateLimitOptions;
     /** Event hooks for logging, debugging, and monitoring */
     hooks?: AniListHooks;
+    /** Optional AbortSignal to cancel all requests made by this client */
+    signal?: AbortSignal;
 }
 
 declare enum StaffSort {
@@ -357,10 +387,6 @@ interface Studio {
 interface StudioConnection {
     nodes: Studio[];
 }
-/**
- * @deprecated Use `Studio` instead. `StudioDetail` is an alias kept for backward compatibility.
- */
-type StudioDetail = Studio;
 interface SearchStudioOptions {
     query?: string;
     page?: number;
@@ -413,6 +439,58 @@ interface SearchUserOptions {
     page?: number;
     perPage?: number;
 }
+interface FavoriteMediaNode {
+    id: number;
+    title: {
+        romaji: string | null;
+        english: string | null;
+        native: string | null;
+        userPreferred: string | null;
+    };
+    coverImage: {
+        large: string | null;
+        medium: string | null;
+    };
+    type: string | null;
+    format: string | null;
+    siteUrl: string | null;
+}
+interface FavoriteCharacterNode {
+    id: number;
+    name: {
+        full: string | null;
+        native: string | null;
+    };
+    image: {
+        large: string | null;
+        medium: string | null;
+    };
+    siteUrl: string | null;
+}
+interface FavoriteStaffNode {
+    id: number;
+    name: {
+        full: string | null;
+        native: string | null;
+    };
+    image: {
+        large: string | null;
+        medium: string | null;
+    };
+    siteUrl: string | null;
+}
+interface FavoriteStudioNode {
+    id: number;
+    name: string;
+    siteUrl: string | null;
+}
+interface UserFavorites {
+    anime: FavoriteMediaNode[];
+    manga: FavoriteMediaNode[];
+    characters: FavoriteCharacterNode[];
+    staff: FavoriteStaffNode[];
+    studios: FavoriteStudioNode[];
+}
 
 declare enum MediaType {
     ANIME = "ANIME",
@@ -766,6 +844,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.
@@ -775,7 +943,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
@@ -791,19 +959,27 @@ declare class AniListClient {
     private readonly cacheAdapter;
     private readonly rateLimiter;
     private readonly hooks;
+    private readonly signal?;
     private readonly inFlight;
+    private _rateLimitInfo?;
+    private _lastRequestMeta?;
     constructor(options?: AniListClientOptions);
     /**
-     * @internal
+     * The current rate limit information from the last API response.
+     * Updated after every non-cached request.
      */
-    private request;
-    /** @internal */
-    private executeRequest;
+    get rateLimitInfo(): RateLimitInfo | undefined;
     /**
-     * @internal
-     * Shorthand for paginated queries that follow the `Page { pageInfo, <field>[] }` pattern.
+     * Metadata about the last request (duration, cache status, rate limit info).
+     * Useful for debugging and monitoring.
      */
-    private pagedRequest;
+    get lastRequestMeta(): ResponseMeta | undefined;
+    /** @internal */
+    request<T>(query: string, variables?: Record<string, unknown>): Promise<T>;
+    /** @internal */
+    private executeRequest;
+    /** @internal */
+    pagedRequest<T>(query: string, variables: Record<string, unknown>, field: string): Promise<PagedResult<T>>;
     /**
      * Fetch a single media entry by its AniList ID.
      *
@@ -811,33 +987,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>;
     /**
@@ -845,370 +994,93 @@ 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>>;
-    /**
-     * Get the most popular anime or manga.
-     *
-     * Convenience wrapper around `searchMedia` with `sort: POPULARITY_DESC`.
-     *
-     * @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 the most popular anime or manga. */
     getPopular(type?: MediaType, page?: number, perPage?: number): Promise<PagedResult<Media>>;
-    /**
-     * Get the highest-rated anime or manga.
-     *
-     * Convenience wrapper around `searchMedia` with `sort: SCORE_DESC`.
-     *
-     * @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 the highest-rated anime or manga. */
     getTopRated(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}`));
-     * });
-     * ```
-     */
+    /** Get recently aired anime episodes. */
+    getAiredEpisodes(options?: GetAiringOptions): Promise<PagedResult<AiringSchedule>>;
+    /** Get currently releasing manga. */
+    getAiredChapters(options?: GetRecentChaptersOptions): Promise<PagedResult<Media>>;
+    /** 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. */
+    getRecommendations(mediaId: number, options?: Omit<GetRecommendationsOptions, "mediaId">): Promise<PagedResult<Recommendation>>;
+    /** 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.
-     *
-     * @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 });
-     * ```
-     */
+    /** Search for characters by name. */
     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));
-     * ```
-     */
+    /** 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.).
-     *
-     * @param options - Search / pagination parameters
-     * @returns Paginated results with matching staff
-     *
-     * @example
-     * ```ts
-     * const result = await client.searchStaff({ query: "Miyazaki", perPage: 5 });
-     * ```
-     */
+    /** Search for staff (voice actors, directors, etc.). */
     searchStaff(options?: SearchStaffOptions): Promise<PagedResult<Staff>>;
     /**
      * Fetch a user by AniList ID or username.
      *
      * @param idOrName - The AniList user ID (number) or username (string)
-     * @returns The user object
-     *
-     * @example
-     * ```ts
-     * const user = await client.getUser(1);
-     * const user2 = await client.getUser("AniList");
-     * console.log(user.name);
-     * ```
      */
     getUser(idOrName: number | string): Promise<User>;
-    /**
-     * Fetch a user by username.
-     *
-     * @deprecated Use `getUser(name)` instead.
-     * @param name - The AniList username
-     * @returns The user object
-     */
-    getUserByName(name: string): Promise<User>;
-    /**
-     * Search for users by name.
-     *
-     * @param options - Search / pagination parameters
-     * @returns Paginated results with matching users
-     *
-     * @example
-     * ```ts
-     * const result = await client.searchUsers({ query: "AniList", perPage: 5 });
-     * ```
-     */
+    /** Search for users by name. */
     searchUsers(options?: SearchUserOptions): Promise<PagedResult<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,
-     * });
-     * ```
-     */
-    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 });
-     * ```
-     */
-    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 });
-     * ```
-     */
-    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})`)
-     * );
-     * ```
-     */
-    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,
-     * });
-     * ```
-     */
-    getMediaBySeason(options: GetSeasonOptions): Promise<PagedResult<Media>>;
-    /**
-     * 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.
-     *
-     * @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`)
-     * );
-     * ```
-     */
+    /** 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<Studio>;
-    /**
-     * Search for studios by name.
+     * Fetch a user's favorite anime, manga, characters, staff, and studios.
      *
-     * @param options - Search / pagination parameters
-     * @returns Paginated list of studios
+     * @param idOrName - AniList user ID (number) or username (string)
+     * @returns The user's favorites grouped by category
      *
      * @example
-     * ```ts
-     * const studios = await client.searchStudios({ query: "MAPPA" });
+     * ```typescript
+     * const favs = await client.getUserFavorites("AniList");
+     * favs.anime.forEach(a => console.log(a.title.romaji));
      * ```
      */
+    getUserFavorites(idOrName: number | string): Promise<UserFavorites>;
+    /** Fetch a studio by its AniList ID. */
+    getStudio(id: number): Promise<Studio>;
+    /** Search for studios by name. */
     searchStudios(options?: SearchStudioOptions): Promise<PagedResult<Studio>>;
-    /**
-     * Get all available genres on AniList.
-     *
-     * @returns Array of genre strings (e.g. "Action", "Adventure", ...)
-     */
+    /** 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.
-     *
-     * Clears the in-memory cache and aborts any pending in-flight requests.
-     * If using a custom cache adapter (e.g. Redis), call its close/disconnect
-     * method separately.
-     */
+    /** Clean up resources held by the client. */
     destroy(): Promise<void>;
 }
 
@@ -1342,6 +1214,7 @@ declare class RateLimiter {
     private readonly enabled;
     private readonly timeoutMs;
     private readonly retryOnNetworkError;
+    private readonly retryStrategy?;
     /** @internal — sliding window: circular buffer of timestamps */
     private readonly timestamps;
     private head;
@@ -1359,11 +1232,20 @@ declare class RateLimiter {
         onRetry?: (attempt: number, reason: string, delayMs: number) => void;
         onRateLimit?: (retryAfterMs: number) => void;
     }): Promise<Response>;
-    /** @internal — Exponential backoff with jitter, capped at 30s */
+    /** @internal — Exponential backoff with jitter, capped at 30s (or custom strategy) */
     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, 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 SearchUserOptions, 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, UserSort, 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 FavoriteCharacterNode, type FavoriteMediaNode, type FavoriteStaffNode, type FavoriteStudioNode, 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 RateLimitInfo, type RateLimitOptions, RateLimiter, type Recommendation, RecommendationSort, RedisCache, type RedisCacheOptions, type RedisLikeClient, type ResponseMeta, 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, type UserFavorites, UserSort, type UserStatistics, type VoiceActor, type WeeklySchedule, parseAniListMarkdown };