kenjitsu-extensions 1.0.0

package/dist/main.d.ts

@@ -0,0 +1,2522 @@
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD';
+interface RequestConfig {
+    url: string;
+    method?: HttpMethod;
+    headers?: Record<string, string>;
+    body?: any;
+    params?: Record<string, string>;
+    retries?: number;
+    timeout?: number;
+    delayBetweenRequests?: number;
+}
+interface FetchResponse<T = any> {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    data: T;
+    config: RequestConfig;
+}
+type RequestInterceptor = (config: RequestConfig) => Promise<RequestConfig> | RequestConfig;
+type ResponseInterceptor = (response: FetchResponse) => Promise<FetchResponse> | FetchResponse;
+declare class FetchClient {
+    private readonly defaultOptions;
+    private lastRequestTime;
+    private lastUserAgent;
+    private readonly requestInterceptors;
+    private readonly responseInterceptors;
+    constructor(options?: Partial<RequestConfig>);
+    useRequestInterceptor(interceptor: RequestInterceptor): void;
+    useResponseInterceptor(interceptor: ResponseInterceptor): void;
+    getUserAgent(): string | null;
+    private delayIfNeeded;
+    request<T = any>(config: RequestConfig): Promise<FetchResponse<T>>;
+    get<T = any>(url: string, config?: Partial<RequestConfig>): Promise<FetchResponse<T>>;
+    post<T = any>(url: string, data?: any, config?: Partial<RequestConfig>): Promise<FetchResponse<T>>;
+}
+
+declare abstract class BaseClass {
+    protected readonly client: FetchClient;
+    constructor(requestTimeout?: number);
+    protected createSlug(text: string): string;
+    protected normalizeKey(input: string): string;
+    protected getMappedValue<T extends string, U extends string>(input: T, mapping: Record<string, U>): U;
+}
+
+interface IBase {
+    id: string | null;
+    name: string | null;
+    posterImage: string | null;
+}
+interface IBaseEpisodes {
+    episodeId: string | null;
+    episodeNumber: number | null;
+}
+interface ISubServers {
+    serverId: number | string | null;
+    serverName: string | null;
+    mediaId: number | string | null;
+    eid?: string | null;
+}
+type IDubServers = ISubServers;
+type IRawServers = ISubServers;
+interface IServerInfo {
+    sub: ISubServers[];
+    dub: IDubServers[];
+    raw: IRawServers[];
+    episodeNumber: number | null;
+}
+type ISubOrDub = 'sub' | 'dub' | 'raw';
+interface IResponse<T> {
+    data: T;
+    error?: string;
+}
+interface ISubtitles {
+    url: string | null;
+    lang: string | null;
+    default?: boolean | null;
+}
+interface IOutro {
+    start: number | null;
+    end: number | null;
+}
+interface ITracks {
+    url: string | null;
+    type: string | null;
+    quality?: string | null;
+}
+interface IVideoSource {
+    intro?: IOutro;
+    outro?: IOutro;
+    subtitles?: ISubtitles[];
+    tracks?: ITracks[];
+    sources: ISource[];
+    download?: string | null;
+    posterImage?: string | null;
+}
+interface ISource {
+    url: string | null;
+    isM3u8: boolean | null;
+    type: string | null;
+    quality?: string | null;
+}
+type IAnimeCategory = 'MOVIE' | 'TV' | 'ONA' | 'OVA' | 'SPECIALS';
+interface ISourceBaseResponse<T> extends IResponse<T> {
+    headers: {
+        Referer: string | null;
+    };
+}
+interface IBasePaginated<T> extends IResponse<T> {
+    hasNextPage: boolean;
+    currentPage: number;
+}
+interface IHomeResSpecialPages {
+    error?: string;
+}
+
+interface IZBase extends IBase {
+    romaji: string | null;
+}
+interface IZAnime extends IZBase {
+    type?: string | null;
+    episodes: {
+        sub: number | null;
+        dub: number | null;
+    };
+    totalEpisodes: number | null;
+}
+interface IZSearchSuggestions extends IZBase {
+    releaseDate: string | null;
+    type: string | null;
+    duration: string | null;
+}
+interface IZSpotlight extends IZAnime {
+    spotlight?: string | null;
+    synopsis: string | null;
+    releaseDate: string | null;
+    quality: string | null;
+}
+interface IZAnimeInfo extends IZSpotlight {
+    anilistId: number | null;
+    malId: number | null;
+    altnames: string | null;
+    japanese: string | null;
+    status: string | null;
+    score: string | null;
+    genres: string[] | null;
+    studios: string[] | null;
+    rating: string | null;
+    producers: string[] | null;
+}
+interface IZRelatedSeasons {
+    id: string | null;
+    name: string | null;
+    season: string | null;
+    seasonPoster: string | null;
+}
+interface IZPromotionVIds {
+    url: string | null;
+    title: string | null;
+    thumbnail: string | null;
+}
+interface IZCharacters {
+    id: string | null;
+    name: string | null;
+    posterImage: string | null;
+    role: string | null;
+    voiceActor: {
+        id: string | null;
+        name: string | null;
+        posterImage: string | null;
+        language: string | null;
+    } | null;
+}
+interface IZEpisodes {
+    episodeId: string | null;
+    episodeNumber: number | null;
+    romaji: string | null;
+    title: string | null;
+    hasSub: boolean;
+    hasDub: boolean;
+}
+type HiAnimeServers = 'hd-1' | 'hd-2';
+interface IZPaginated$1<T> extends IBasePaginated<T> {
+    lastPage: number;
+}
+interface IZHomeResponse<T> extends IHomeResSpecialPages {
+    data: IZAnime[];
+    trending: IZBase[];
+    topAiring: IZAnime[];
+    mostPopular: IZAnime[];
+    recentlyUpdated: IZAnime[];
+    recentlyCompleted: IZAnime[];
+    recentlyAdded: IZAnime[];
+    favourites: IZAnime[];
+    topAnime: {
+        daily: IZAnime[];
+        weekly: IZAnime[];
+        monthly: IZAnime[];
+    };
+}
+interface IZSourceResponse<T> extends ISourceBaseResponse<T> {
+    syncData?: {
+        anilistId: string | null;
+        malId: string | null;
+        name: string | null;
+    };
+}
+interface IZoroAnimeInfoScrape<T> extends IResponse<T> {
+    relatedSeasons: IZRelatedSeasons[] | [];
+    recommendedAnime: IZAnime[] | [];
+    relatedAnime: IZAnime[] | [];
+    mostPopular: IZAnime[];
+    promotionVideos: IZPromotionVIds[];
+    characters: IZCharacters[];
+}
+interface IZoroInfoResponse<T> extends IZoroAnimeInfoScrape<T> {
+    providerEpisodes: IZEpisodes[] | [];
+}
+declare const HIGenres: {
+    readonly action: "action";
+    readonly adventure: "adventure";
+    readonly cars: "cars";
+    readonly comedy: "comedy";
+    readonly dementia: "dementia";
+    readonly demons: "demons";
+    readonly drama: "drama";
+    readonly ecchi: "ecchi";
+    readonly fantasy: "fantasy";
+    readonly game: "game";
+    readonly harem: "harem";
+    readonly historical: "historical";
+    readonly horror: "horror";
+    readonly isekai: "isekai";
+    readonly josei: "josei";
+    readonly kids: "kids";
+    readonly magic: "magic";
+    readonly 'martial-arts': "martial-arts";
+    readonly mecha: "mecha";
+    readonly military: "military";
+    readonly music: "music";
+    readonly mystery: "mystery";
+    readonly parody: "parody";
+    readonly police: "police";
+    readonly psychological: "psychological";
+    readonly romance: "romance";
+    readonly samurai: "samurai";
+    readonly school: "school";
+    readonly 'sci-fi': "sci-fi";
+    readonly seinen: "seinen";
+    readonly shoujo: "shoujo";
+    readonly 'shoujo-ai': "shoujo-ai";
+    readonly shounen: "shounen";
+    readonly 'shounen-ai': "shounen-ai";
+    readonly 'slice-of-life': "slice-of-life";
+    readonly space: "space";
+    readonly sports: "sports";
+    readonly 'super-power': "super-power";
+    readonly supernatural: "supernatural";
+    readonly thriller: "thriller";
+    readonly vampire: "vampire";
+};
+type HIGenre = keyof typeof HIGenres;
+
+/**
+ * A class for interacting with the HiAnime platform (hianime.to) to search for anime, fetch detailed information,
+ * retrieve episode lists, get available streaming servers, and fetch curated anime lists.
+ */
+declare class HiAnime extends BaseClass {
+    private readonly baseUrl;
+    constructor(baseUrl?: string);
+    /**
+     * Parses paginated anime search results from a Cheerio instance.
+     * Extracts anime details and pagination information from the provided HTML selector.
+     * @param $ CheerioAPI instance
+     * @param selector CSS selector for anime items
+     * @returns An object containing anime list and pagination details
+     */
+    private parsePaginatedResults;
+    /**
+     * Parses search suggestion results from a Cheerio instance.
+     * Extracts anime suggestion details from the provided HTML.
+     * @param $ CheerioAPI instance
+     * @returns An array containing an array of search suggestions
+     */
+    private parseSearchSuggestions;
+    /**
+     * Parses detailed anime information from a Cheerio instance.
+     * Extracts anime details, characters, recommendations, related anime, seasons, and promotion videos.
+     * @param $ CheerioAPI instance
+     * @returns Object containing anime details and related data
+     */
+    private parseAnimeInfo;
+    /**
+     * Parses the HiAnime homepage data from a Cheerio instance.
+     * Extracts spotlight, trending, top airing, most popular, favorites, recently completed, recently added, recently updated, and top anime rankings.
+     * @param $ CheerioAPI instance
+     * @returns An object containing various curated anime lists
+     */
+    private parseHome;
+    /**
+     * Parses paginated sections like top airing, most popular, etc., from a Cheerio instance.
+     * Extracts anime details, pagination information, and top anime rankings.
+     * @param $ CheerioAPI instance
+     * @returns RepetitiveSections containing anime list, pagination details, and top anime rankings
+     */
+    private parsePaginatedSections;
+    /**
+     * Parses episode data for an anime from a Cheerio instance.
+     * Extracts episode IDs, titles, and numbers from the provided HTML.
+     * @param $ CheerioAPI instance
+     * @returns Response containing an array of episode information
+     */
+    private parseEpisodes;
+    /**
+     * Parses streaming server data for an episode from a Cheerio instance.
+     * Extracts sub, dub, and raw server details along with episode number.
+     * @param $ CheerioAPI instance
+     * @returns Response containing server information
+     */
+    private parseServerData;
+    /**
+     * Finds the server ID for a given category and server name from the server data.
+     * @param servers Server information containing sub, dub, and raw server lists
+     * @param category Sub or dub category
+     * @param server Server name to find
+     * @returns The media ID of the matching server
+     * @throws Error if the category or server is not found
+     */
+    private findServerId;
+    /**
+     * Searches for anime based on the provided query string.
+     * @param {string} query - The search query string (required).
+     * @param {number} [page=1] - The page number for pagination (optional, defaults to 1).
+     * @returns  A promise that resolves to an object containing an array of anime titles, pagination details, or an error message.
+     */
+    search(query: string, page?: number): Promise<IZPaginated$1<IZAnime[] | []>>;
+    /**
+     * Fetches search suggestions for a given query string from the HiAnime platform.
+     * @param {string} query - The search query string (required).
+     @returns A promise that resolves to an object containing an array of anime titles or an error message.
+     */
+    searchSuggestions(query: string): Promise<IResponse<IZSearchSuggestions[] | []>>;
+    /**
+     * Fetches curated lists from the HiAnime homepage.
+     * @returns Promise resolving to an object with various curated anime lists
+     */
+    fetchHome(): Promise<IZHomeResponse<IZSpotlight[] | []>>;
+    /**
+     * Fetches a paginated list of top airing anime.
+     * @param {number} page - Page number for pagination (default: 1)
+     * @returns  Promise resolving to an object with top airing anime and pagination details
+     */
+    fetchTopAiring(page?: number): Promise<IZPaginated$1<IZAnime[] | []>>;
+    /**
+     * Fetches a paginated list of the most favorited anime.
+     * @param {number} page - Page number for pagination (default: 1)
+     * @returns  Promise resolving to an object  with favorited anime and pagination details
+     */
+    fetchMostFavourites(page?: number): Promise<IZPaginated$1<IZAnime[] | []>>;
+    /**
+     * Fetches a paginated list of the most popular anime.
+     * @param {number} page - Page number for pagination (default: 1)
+     * @returns  Promise resolving to an object  with popular anime and pagination details
+     */
+    fetchMostPopular(page?: number): Promise<IZPaginated$1<IZAnime[] | []>>;
+    /**
+     * Fetches a paginated list of recently completed anime.
+     * @param {number} page - Page number for pagination (default: 1)
+     * @returns Promise resolving to an object  with recently completed anime and pagination details
+     */
+    fetchRecentlyCompleted(page?: number): Promise<IZPaginated$1<IZAnime[] | []>>;
+    /**
+     * Fetches a paginated list of recently added anime.
+     * @param {number} page - Page number for pagination (default: 1)
+     * @returns Promise resolving to an object with recently added anime and pagination details
+     */
+    fetchRecentlyAdded(page?: number): Promise<IZPaginated$1<IZAnime[] | []>>;
+    /**
+     * Fetches a paginated list of recently updated anime.
+     * @param {number} page - Page number for pagination (default: 1)
+     * @returns  Promise resolving to an object  with recently updated anime and pagination details
+     */
+    fetchRecentlyUpdated(page?: number): Promise<IZPaginated$1<IZAnime[] | []>>;
+    /**
+     * Fetches a list of anime titles sorted alphabetically, optionally filtered by a starting character.
+     * @param {any} sort Optional letter (A-Z) or "0-9" to filter anime
+     * @param {number} page - Page number for pagination (default: 1)
+     *@returns  Promise resolving to an object  with alphabetically sorted anime and pagination details
+     */
+    fetchAtoZList(sort?: any, page?: number): Promise<IZPaginated$1<IZAnime[] | []>>;
+    /**
+     * Fetches a list of anime by genre.
+     * @param {string} genre -The genre to filter anime by
+     * @param {number} page - Page number for pagination (default: 1)
+     * @returns  Promise resolving to an object with genre-specific anime and pagination details
+     */
+    fetchGenre(genre: string, page?: number): Promise<IZPaginated$1<IZAnime[] | []>>;
+    /**
+     * Fetches a list of subbed anime.
+     * @param {number} page - Page number for pagination (default: 1)
+     * @returns  Promise resolving to an object with subbed anime and pagination details
+     */
+    fetchSubbedAnime(page?: number): Promise<IZPaginated$1<IZAnime[] | []>>;
+    /**
+     * Fetches a list of dubbed anime.
+     * @param {number} page - Page number for pagination (default: 1)
+     * @returns  Promise resolving to an object with dubbed anime and pagination details
+     */
+    fetchDubbedAnime(page?: number): Promise<IZPaginated$1<IZAnime[] | []>>;
+    /**
+     * Fetches a list of anime by category.
+     * @param { IAnimeCategory} category - The category of anime to fetch (MOVIE, TV, ONA, OVA, SPECIALS).
+     * @param {number} [page=1] - The page number for pagination (default: 1).
+     * @returns  - Promise resolving to paginated anime results.
+     */
+    fetchAnimeCategory(category: IAnimeCategory, page?: number): Promise<IZPaginated$1<IZAnime[] | []>>;
+    /**
+     * Fetches detailed information about a specific anime including episodes.
+     * @param {string} animeId - The unique identifier for the anime (e.g., "bleach-806") (required).
+     * @returns A promise that resolves to an object containing anime details,provider episodes, related seasons, characters, recommendations, or an error message.
+     */
+    fetchAnimeInfo(animeId: string): Promise<IZoroInfoResponse<IZAnimeInfo | null>>;
+    /**
+     * Fetches episode data for a specific anime.
+     * @param {string} animeId - The unique identifier for the anime (e.g., "bleach-806") (required).
+     * @returns  A promise that resolves to an object containing an array of episode information or an error message.
+     */
+    fetchEpisodes(animeId: string): Promise<IResponse<IZEpisodes[] | []>>;
+    /**
+     * Fetches available streaming servers for a specific anime episode.
+     * @param {string} episodeId - The unique identifier for the episode  (required).
+     * @returns  A promise that resolves to an object containing available streaming server details (sub, dub, raw) or an error message.
+     */
+    fetchServers(episodeId: string): Promise<IResponse<IServerInfo | null>>;
+    /**
+     * Fetches streaming sources for a given anime episode from a specified server and category.
+     * @param {string} episodeId - The unique identifier for the episode (required).
+     * @param {HiAnimeServers}  server - The streaming server to use (optional, defaults to hd-2). Note: hd-1 may return a 403 error due to CORS restrictions; use a proxy or switch to hd-2 or hd-3
+     * @param {HISubOrDub} category  - The audio category (Subtitled or Dubbed) (optional, defaults to SubOrDub.SUB).
+     * @returns  A promise that resolves to an object containing streaming sources, headers, sync data (AniList/MAL IDs), or an error message.
+     */
+    fetchSources(episodeId: string, server?: HiAnimeServers, category?: ISubOrDub): Promise<IZSourceResponse<IVideoSource | null>>;
+}
+
+interface IAllAnimeInfo extends IBase {
+    native: string;
+    type: string;
+    season: string;
+    releaseDate: number;
+    score: number;
+    genres: string[];
+    synopsis: string;
+    studios: string[];
+    status: string;
+}
+interface IAllAnime extends IBase {
+    native: string | null;
+    romaji: string | null;
+}
+interface IAllAnimeEpisodes extends IBaseEpisodes {
+    hasSub: boolean | null;
+    hasDub: boolean | null;
+    hasRaw: boolean;
+}
+type AllAnimeServers = 'mp4upload' | 'internal-s-mp4' | 'internal-default-hls' | 'internal-ak' | 'internal-yt-mp4';
+
+interface IMovieTvBase {
+    id: string | null;
+    name: string | null;
+    posterImage: string | null;
+    type: 'Movie' | 'TV' | null;
+    quality?: string | null;
+}
+interface IMovieSlider extends IMovieTvBase {
+    synopsis: string | null;
+    score: number | null;
+    duration: string | null;
+    genre: string[] | null;
+}
+interface IMovie extends IMovieTvBase {
+    type: 'Movie';
+    releaseDate: string | number | null;
+    duration: string | null;
+}
+interface ITvShow extends IMovieTvBase {
+    type: 'TV';
+    seasons: number | null;
+    totalEpisodes: number | null;
+}
+interface IMovieInfo extends IMovieTvBase {
+    releaseDate: string | null;
+    synopsis: string | null;
+    duration: string | null;
+    production: string[] | null;
+    country: string[] | null;
+    casts: string[] | null;
+    trailer: string | null;
+    score: number | null;
+    genre: string[] | null;
+}
+type IMovieOrTv = IMovie | ITvShow;
+interface IMovieInfoResponse<T> extends IResponse<T> {
+    recommended: IMovieOrTv[] | [];
+    providerEpisodes: IMovieEpisodes[] | [];
+}
+interface IMovieEpisodes {
+    title: string | null;
+    episodeId: string | null;
+    seasonNumber: number | null;
+    episodeNumber: number | null;
+}
+interface IMovieServers {
+    serverId: string | null;
+    serverName: string | null;
+}
+interface IHomeHIResponse<T> extends IHomeResSpecialPages {
+    featured?: IMovieSlider[] | [];
+    trending: {
+        Movies: IMovieOrTv[] | [];
+        Tv: IMovieOrTv[] | [];
+    };
+    recentReleases: {
+        Movies: IMovieOrTv[] | [];
+        Tv: IMovieOrTv[] | [];
+    };
+    upcoming: IMovieOrTv[] | [];
+}
+interface IZPaginated<T> extends IBasePaginated<T> {
+    lastPage: number;
+}
+declare const HIMovieGenres: {
+    readonly action: "action";
+    readonly actionandadventure: "action-adventure";
+    readonly adventure: "adventure";
+    readonly animation: "animation";
+    readonly biography: "biography";
+    readonly comedy: "comedy";
+    readonly crime: "crime";
+    readonly documentary: "documentary";
+    readonly drama: "drama";
+    readonly family: "family";
+    readonly fantasy: "fantasy";
+    readonly history: "history";
+    readonly horror: "horror";
+    readonly kids: "kids";
+    readonly music: "music";
+    readonly mystery: "mystery";
+    readonly news: "news";
+    readonly reality: "reality";
+    readonly romance: "romance";
+    readonly scifiandfantasy: "sci-fi-fantasy";
+    readonly sciencefiction: "science-fiction";
+    readonly soap: "soap";
+    readonly talk: "talk";
+    readonly thriller: "thriller";
+    readonly tvmovie: "tv-movie";
+    readonly war: "war";
+    readonly warandpolitics: "war-politics";
+    readonly western: "western";
+};
+type IMovieGenre = keyof typeof HIMovieGenres;
+declare const HIMovieCountryCode: {
+    readonly argentina: "AR";
+    readonly australia: "AU";
+    readonly austria: "AT";
+    readonly belgium: "BE";
+    readonly brazil: "BR";
+    readonly canada: "CA";
+    readonly china: "CN";
+    readonly czechrepublic: "CZ";
+    readonly denmark: "DK";
+    readonly finland: "FI";
+    readonly france: "FR";
+    readonly germany: "DE";
+    readonly hongkong: "HK";
+    readonly hungary: "HU";
+    readonly india: "IN";
+    readonly ireland: "IE";
+    readonly israel: "IL";
+    readonly italy: "IT";
+    readonly japan: "JP";
+    readonly luxembourg: "LU";
+    readonly mexico: "MX";
+    readonly netherlands: "NL";
+    readonly newzealand: "NZ";
+    readonly norway: "NO";
+    readonly poland: "PL";
+    readonly romania: "RO";
+    readonly russia: "RU";
+    readonly southafrica: "ZA";
+    readonly southkorea: "KR";
+    readonly spain: "ES";
+    readonly sweden: "SE";
+    readonly switzerland: "CH";
+    readonly taiwan: "TW";
+    readonly thailand: "TH";
+    readonly unitedkingdom: "GB";
+    readonly unitedstates: "US";
+};
+type IMovieCountry = keyof typeof HIMovieCountryCode;
+
+/**
+ * Class to handle interactions with the AllAnime API.
+ * @extends BaseClass
+ */
+declare class AllAnime extends BaseClass {
+    /**
+     * Base URL for the AllAnime API.
+     * @private
+     */
+    private readonly baseUrl;
+    /**
+     * Initializes the AllAnime class.
+     */
+    constructor();
+    /**
+     * Number of items per page for search results.
+     * @private
+     */
+    private readonly pageSize;
+    private advancedSearch;
+    /**
+     * GraphQL query for searching anime shows.
+     * @private
+     */
+    private SearchQuery;
+    /**
+     * GraphQL query for fetching animeinfo.
+     * @private
+     */
+    private AnimeInfoQuery;
+    /**
+     * GraphQL query for fetching episode details for a specific show.
+     * @private
+     */
+    private EpisodesQuery;
+    /**
+     * GraphQL query for fetching streaming sources for a specific episode.
+     * @private
+     */
+    private StreamsQuery;
+    private decryptSource;
+    /**
+     * Searches for anime based on a query string and pagination.
+     * @param query - The search query string.
+     * @param page - The page number for paginated results (default: 1).
+     * @returns A promise resolving to paginated anime search results.
+     * @throws Error if the search query is empty.
+     */
+    search(query: string): Promise<IResponse<IAllAnime[] | []>>;
+    /**
+     * Fetches anime details for a specific anime by its ID.
+     * @param id - The ID of the anime show.
+     * @returns A promise resolving to a anime info or an error.
+    
+     */
+    fetchAnimeInfo(id: string): Promise<IResponse<IAllAnimeInfo | null>>;
+    /**
+     * Fetches episode details for a specific anime by its ID.
+     * @param id - The ID of the anime show.
+     * @returns A promise resolving to a list of episodes or an error.
+     * @throws Error if the ID is empty.
+     */
+    fetchEpisodes(id: string): Promise<IResponse<IAllAnimeEpisodes[] | []>>;
+    /**
+     * Fetches available servers for a specific episode.
+     * @param id - The episode ID in the format 'allanime-<showId>-episode-<episodeNumber>'.
+     * @param category - The translation type (sub, dub, or raw, default: 'sub').
+     * @returns A promise resolving to a list of servers or an error.
+     */
+    fetchServers(id: string, category?: ISubOrDub): Promise<IResponse<IMovieServers[] | []>>;
+    private fetchServersInternal;
+    private getReferer;
+    /**
+     
+     * Fetches streaming sources for a given anime episode from a specified server and category.
+     * @param {string} episodeId - The unique identifier for the episode (required).
+     * @param {HISubOrDub} version  - The audio category (Subtitled or Dubbed) (optional, defaults to SubOrDub.SUB).
+     * @param {string}  server - The streaming server to use (optional, defaults to okru).
+     * @returns  A promise that resolves to an object containing streaming sources, headers, or an error message.
+     */
+    fetchSources(episodeId: string, server?: AllAnimeServers, version?: ISubOrDub): Promise<ISourceBaseResponse<IVideoSource | null>>;
+}
+
+interface IAnizone extends IBase {
+    releaseDate: string | number | null;
+    status: string | null;
+    genres: string[] | null;
+    type: string | null;
+}
+interface IAnizoneInfo extends IAnizone {
+    coverImage: string | null;
+    synopsis: string | null;
+    totalEpisodes: number | null;
+}
+interface IAniZoneEpisodes extends IBaseEpisodes {
+    thumbnail: string | null;
+    teaser: string | null;
+    airDate: string | null;
+    title: string | null;
+}
+interface IAnizoneInfoResponse<T> extends IResponse<T> {
+    providerEpisodes: IAniZoneEpisodes[] | [];
+}
+interface IAnizoneUpdates<T> extends IResponse<T> {
+    recentlyAdded: IBase[] | [];
+}
+
+/**
+ * Anizone class for interacting with the Anizone anime streaming platform.
+ * Extends BaseClass to provide functionality for searching anime, fetching anime details,
+ * retrieving video sources for episodes, and fetching recent updates.
+ * @extends BaseClass
+ */
+declare class Anizone extends BaseClass {
+    private readonly baseUrl;
+    constructor(baseUrl?: string);
+    /**
+     * Parses search results from the Anizone website to extract anime information.
+     * @private
+     * @param {cheerio.CheerioAPI} $ - Cheerio instance for parsing HTML.
+     * @returns {IResponse<IAnizone[] | []>} - An object containing an array of parsed anime data or an empty array.
+     */
+    private parseSearchResults;
+    /**
+     * Parses anime information and episode data from the Anizone anime page.
+     * @private
+     * @param {cheerio.CheerioAPI} $ - Cheerio instance for parsing HTML.
+     * @returns {IAnizoneInfoResponse<IAnizoneInfo | null>} - An object containing parsed anime info and episode data, or null if not found.
+     */
+    private parseAnimeinfo;
+    /**
+     * Parses video sources, subtitles, and other media data from an episode page.
+     * @private
+     * @param {cheerio.CheerioAPI} $ - Cheerio instance for parsing HTML.
+     * @returns  - An object containing parsed video source data.
+     */
+    private parseSources;
+    /**
+     * Parses recent updates from the Anizone homepage, including recently added anime and latest episodes.
+     * @private
+     * @param {cheerio.CheerioAPI} $ - Cheerio instance for parsing HTML.
+     * @returns  - An object containing arrays of recently added anime and latest episodes.
+     */
+    private parseUpdates;
+    private formatQuery;
+    /**
+     * Searches for anime on the Anizone platform using a query string.
+     * @param {string} query - The search query for finding anime.
+     * @returns - A promise resolving to an object containing search results or an error message.
+     */
+    search(query: string): Promise<IResponse<IAnizone[] | []>>;
+    /**
+     * Fetches recent updates from the Anizone homepage, including recently added anime and latest episodes.
+     * @returns - A promise resolving to an object containing arrays of recently added anime, latest episodes, or an error message.
+     */
+    fetchUpdates(): Promise<IAnizoneUpdates<IAniZoneEpisodes[] | []>>;
+    /**
+     * Fetches detailed information and episode list for a specific anime.
+     * @param {string} animeId - The unique identifier for the anime.
+     * @returns - A promise resolving to an object containing anime details and episodes or an error message.
+     */
+    fetchAnimeInfo(animeId: string): Promise<IAnizoneInfoResponse<IAnizoneInfo | null>>;
+    /**
+     * Fetches video sources and related metadata for a specific episode.
+     * @param {string} episodeId - The unique identifier for the episode.
+     * @returns {Promise<ISourceBaseResponse<IVideoSource | null>>} - A promise resolving to an object containing video sources, headers, or an error message.
+     */
+    fetchSources(episodeId: string): Promise<ISourceBaseResponse<IVideoSource | null>>;
+}
+
+interface IPaheAnime extends IBase {
+    score: number | null;
+    type: string | null;
+    releaseDate: number | null;
+    season: string | null;
+    totalEpisodes: number | null;
+}
+interface IPaheInfo extends IBase {
+    anilistId: number | null;
+    malId: number | null;
+    altnames: string | null;
+    japanese: string | null;
+    status: string | null;
+    score: string | null;
+    genres: string[] | null;
+    studios: string | null;
+    producers: string | null;
+    romaji: string | null;
+    episodes: {
+        sub: number | null;
+        dub: number | null;
+    };
+    totalEpisodes: number | null;
+    duration: string | null;
+    type: string | null;
+    synopsis: string | null;
+    releaseDate: string | null;
+}
+interface IPaheEpisodes extends IBaseEpisodes {
+    title: string | null;
+    thumbnail: string | null;
+}
+interface IPaheAnimeInfoResponse<T> extends IResponse<T> {
+    providerEpisodes: IPaheEpisodes[] | [];
+}
+interface IPaheServersResponse<T> extends IResponse<T> {
+    download: IServerInfo | null;
+}
+interface IPahePaginated<T> extends IBasePaginated<T> {
+    lastPage: number;
+    perPage: number;
+    totalResults: number;
+}
+
+/**
+ * A class for interacting with the Animepahe platform  to search for anime, fetch detailed information,
+ * retrieve episode lists, get available streaming servers, and sources.
+ */
+declare class Animepahe extends BaseClass {
+    private readonly baseUrl;
+    constructor(baseUrl?: string);
+    private headers;
+    /**
+     * Parses HTML content to extract detailed anime information.
+     * @private
+     * @param {cheerio.CheerioAPI} $ - The Cheerio API instance for parsing HTML.
+     * @param {string} animeId - The unique identifier for the anime.
+     * @returns {IPaheInfo} An object containing parsed anime information.
+     */
+    private parseAnimeInfo;
+    /**
+     * Parses HTML content to extract streaming server information for an episode.
+     * @private
+     * @param {cheerio.CheerioAPI} $ - The Cheerio API instance for parsing HTML.
+     * @returns {{servers: HIServerInfo; download: HIServerInfo}} An object containing streaming servers and download servers.
+     */
+    private parseServers;
+    /**
+     * Finds available server IDs for a specific audio category from the parsed server data.
+     * @private
+     * @param {IServerInfo} servers - The parsed streaming server information.
+     * @param {IServerInfo} download - The parsed download server information.
+     * @param {ISubOrDub} category - The audio category to filter servers for ('sub', 'dub', or 'raw').
+     * @returns {Array<{serverId: string; serverName: string; downloadId: string | null}>} An array of server objects with IDs and download information.
+     * @throws {Error} If no servers are available for the specified category.
+     */
+    private findServerIds;
+    /**
+     * Searches for anime based on the provided query string.
+     * @param {string} query - The search query string (required).
+     * @returns  A promise that resolves to an object containing an array of anime titles, pagination details, or an error message.
+     */
+    search(query: string): Promise<IPahePaginated<IPaheAnime[] | []>>;
+    /**
+     *  Fetches recently updated anime. Mostly those that are airing
+     * @param {number} [page] - The page number for pagination (optional, defaults to 1).
+     * @returns
+     */
+    fetchRecentEpisodes(page?: number): Promise<IPahePaginated<IPaheEpisodes[] | []>>;
+    /**
+     * Fetches detailed information about a specific anime including episodes.
+     * @param {string} animeId - The unique identifier for the anime (required).
+     * @returns  A promise that resolves to an object containing anime details, or an error message.
+     */
+    fetchAnimeInfo(animeId: string): Promise<IPaheAnimeInfoResponse<IPaheInfo | null>>;
+    /**
+     * Fetches episode data for a specific anime.
+     * @param {string} animeId - The unique identifier for the anime (required).
+     * @returns  A promise that resolves to an object containing an array of episode information or an error message.
+     */
+    fetchEpisodes(animeId: string): Promise<IResponse<IPaheEpisodes[] | []>>;
+    /**
+     * Fetches available streaming servers for a specific anime episode.
+     * @param {string} episodeId - The unique identifier for the episode  (required).
+     * @returns  A promise that resolves to an object containing available streaming server details (sub, dub, raw) or an error message.
+     */
+    fetchServers(episodeId: string): Promise<IPaheServersResponse<IServerInfo | null>>;
+    /**
+     * Fetches streaming sources for a given anime episode from a specified server and category.
+     * @param {string} episodeId - The unique identifier for the episode (required).
+     * @param {ISubOrDub} category  - The audio category (Subtitled or Dubbed) (optional, defaults to SubOrDub.SUB).
+     * @returns  A promise that resolves to an object containing streaming sources, headers,  or an error message.
+     */
+    fetchSources(episodeId: string, category?: ISubOrDub): Promise<ISourceBaseResponse<IVideoSource | null>>;
+}
+
+interface IAKAnime extends IBase {
+    romaji: string | null;
+    type: string | null;
+    episodes: {
+        sub: number | null;
+        dub: number | null;
+    };
+    totalEpisodes: number | null;
+}
+interface IAKSlider extends IAKAnime {
+    synopsis: string | null;
+    quality: string | null;
+    releaseDate: string | null;
+    rating: string | null;
+}
+interface IAKEpisodes extends IBaseEpisodes {
+    title: string | null;
+    hasSub: boolean;
+    hasDub: boolean;
+}
+interface IAKRelatedSeasons {
+    id: string | null;
+    name: string | null;
+    season: string | null;
+    totalEpisodes: number | null;
+    seasonPoster: string | null;
+}
+interface IAKInfo extends IBase {
+    anilistId: number | null;
+    malId: number | null;
+    altnames: string | null;
+    japanese: string | null;
+    status: string | null;
+    score: string | null;
+    genres: string[] | null;
+    studios: string[] | null;
+    rating: string | null;
+    producers: string[] | null;
+    romaji: string | null;
+    episodes: {
+        sub: number | null;
+        dub: number | null;
+    };
+    totalEpisodes: number | null;
+    type: string | null;
+    synopsis: string | null;
+    releaseDate: string | null;
+}
+interface IAKPaginated<T> extends IBasePaginated<T> {
+    lastPage: number;
+    totalResults: number;
+}
+interface IAKHomeResponse<T> extends IHomeResSpecialPages {
+    recentlyUpdated: IAKAnime[];
+    recentlyCompleted: IAKAnime[];
+    recentlyAdded: IAKAnime[];
+    data: IAKAnime[];
+    trending: {
+        now: IAKAnime[];
+        daily: IAKAnime[];
+        weekly: IAKAnime[];
+        monthly: IAKAnime[];
+    };
+    upcoming: IAKAnime[];
+}
+interface IAKInfoResponse<T> extends IResponse<T> {
+    relatedSeasons: IAKRelatedSeasons[] | [];
+    recommendedAnime: IAKAnime[] | [];
+    relatedAnime: IAKAnime[] | [];
+    providerEpisodes: IAKEpisodes[] | [];
+}
+
+interface IMetaAnime {
+    malId: number;
+    anilistId?: number;
+    image: string;
+    color?: string;
+    bannerImage?: string;
+    title: {
+        romaji: string;
+        english: string;
+        native: string;
+    };
+    trailer: string;
+    format: string;
+    status: string;
+    synonyms?: string[];
+    country?: string;
+    year?: number;
+    duration: number;
+    score: number;
+    genres: string[];
+    episodes: number;
+    synopsis: string;
+    season: string;
+    releaseDate: string;
+    endDate: string;
+    studio: string;
+    producers: string[];
+}
+interface IMetaCharacters {
+    role: string;
+    id: number;
+    name: string;
+    image: string;
+    voiceActors: voiceActors[];
+}
+type voiceActors = {
+    name: string;
+    image: string;
+    language: string;
+};
+interface IAnilistCharacters {
+    anilistId: number;
+    malId: number;
+    title: {
+        romaji: string;
+        english: string;
+        native: string;
+    };
+    characters: IMetaCharacters[];
+}
+interface IRelatedAnilistData {
+    anilistId: number;
+    malId: number;
+    title: {
+        romaji: string;
+        english: string;
+        native: string;
+    };
+    type: string;
+    score: number;
+    image: string;
+    bannerImage: string;
+    color: string;
+    synonyms: string[];
+    country: string;
+    year: number;
+}
+interface NextAiringEpisode {
+    episode: number;
+    id: number;
+    airingAt: number;
+    timeUntilAiring: number;
+}
+interface BaseAnimeSchedule {
+    malId: number;
+    anilistId: number;
+    bannerImage: string;
+    image: string;
+    title: {
+        romaji: string;
+        english: string | null;
+        native: string | null;
+    };
+    format: string;
+    releaseDate: string;
+    endDate: string;
+    status: string;
+    nextAiringEpisode: NextAiringEpisode | null;
+}
+interface MediaSchedule extends BaseAnimeSchedule {
+    color: string;
+    duration: number | null;
+}
+interface AiringSchedule extends BaseAnimeSchedule {
+    popularity: number;
+    score: number;
+    genres: string[];
+    episodes: number | null;
+    synopsis: string;
+    season: string | null;
+}
+type Provider = 'hianime' | 'allanime' | 'animepahe' | 'anizone' | 'animekai';
+declare const Seasons: readonly ["WINTER", "SPRING", "SUMMER", "FALL"];
+type Seasons = (typeof Seasons)[number];
+declare const JSort: readonly ["airing", "bypopularity", "upcoming", "favorite", "rating"];
+type JSort = (typeof JSort)[number];
+type IMetaFormat = 'TV' | 'MOVIE' | 'SPECIAL' | 'OVA' | 'ONA' | 'MUSIC';
+interface IMetaDataMap {
+    native?: string;
+    english?: string;
+    romaji: string;
+    type: string;
+    season: string;
+    year: number;
+    episodes: number;
+}
+interface IMetaAnimePaginated<T> extends IBasePaginated<T> {
+    lastPage: number;
+    perPage: number;
+}
+interface IMetaProviderEpisodes {
+    episodeNumber: number | null;
+    rating: number | null;
+    aired: boolean | null;
+    episodeId: string | null;
+    title: string | null;
+    overview: string | null;
+    thumbnail: string | null;
+    provider: string | null;
+}
+interface IMetaProviderEpisodesResponse<T> extends IResponse<T> {
+    providerEpisodes: IMetaProviderEpisodes[] | [];
+}
+interface IProviderId {
+    id: string | null;
+    name: string | null;
+    native?: string | null;
+    romaji: string | null;
+    provider: string | null;
+    score: number | null;
+}
+interface IMetaProviderIdResponse<T> extends IResponse<T> {
+    provider: IProviderId | null;
+}
+
+/**
+ * A class for interacting with the AnimeKai Provider.
+ *
+ * It aims to search for anime, fetch detailed information, retrieve available streaming servers,
+ * and obtain direct episode sources.
+ */
+declare class Animekai extends BaseClass {
+    constructor(baseUrl?: string);
+    private readonly baseUrl;
+    private readonly megaup;
+    private readonly headers;
+    /**
+     * Scrapes anime data from recently added/upcoming/recently completed sections.
+     * @private
+     * @param  $ - The Cheerio API instance for parsing HTML.
+     * @param  selector - CSS selector for the anime elements to scrape.
+     * @returns  An array of parsed anime objects.
+     */
+    private scrapeUpdates;
+    /**
+     * Scrapes trending anime cards from different time periods (now, daily, weekly, monthly).
+     * @private
+     * @param  $ - The Cheerio API instance for parsing HTML.
+     * @param selector - CSS selector for the trending anime elements.
+     * @returns  An array of parsed trending anime objects.
+     */
+    private scrapeTrendingCard;
+    /**
+     * Parses the homepage HTML to extract curated anime sections including featured, trending, and recently updated content.
+     * @param {cheerio.CheerioAPI} $ - The Cheerio API instance for parsing HTML.
+     * @returns  An object containing various curated anime lists.
+     */
+    private parseHome;
+    /**
+     * Parses paginated anime search or category results from HTML.
+     * @private
+     * @param {cheerio.CheerioAPI} $ - The Cheerio API instance for parsing HTML.
+     * @param {cheerio.SelectorType} selector - CSS selector for the anime items in the paginated results.
+     * @returns An object containing paginated anime results with metadata.
+     */
+    private parsePaginated;
+    /**
+     * Parses related/recommended anime sections from the anime info page.
+     * @private
+     * @param {cheerio.CheerioAPI} $ - The Cheerio API instance for parsing HTML.
+     * @param {cheerio.SelectorType} selector - CSS selector for the related/recommended anime elements.
+     * @returns An array of parsed related or recommended anime objects.
+     */
+    private parseInfoSections;
+    /**
+     * Parses detailed anime information from the anime watch page.
+     * @private
+     * @param {cheerio.CheerioAPI} $ - The Cheerio API instance for parsing HTML.
+     * @returns  An object containing parsed anime info, rating data, related seasons, and recommendations.
+     */
+    private parseAnimeInfo;
+    /**
+     * Parses episode list from the AJAX endpoint response.
+     * @private
+     * @param {cheerio.CheerioAPI} $ - The Cheerio API instance for parsing HTML.
+     * @param {string} animeId - The unique identifier for the anime.
+     * @returns An array of parsed episode objects with language availability.
+     */
+    private parseEpisodes;
+    /**
+     * Parses server information from the episode links AJAX response.
+     * @private
+     * @param {cheerio.CheerioAPI} $ - The Cheerio API instance for parsing HTML.
+     * @returns An object containing parsed server information.
+     */
+    private parseServers;
+    /**
+     * Extracts media IDs for a specific audio category from the server information.
+     * @private
+     * @param {IServerInfo} servers - The parsed server information object.
+     * @param {ISubOrDub} category - The audio category to filter servers for ('sub', 'dub', or 'raw').
+     * @param  {string}  server - The streaming server to use (optional, defaults to server-1).
+     * @returns {string} A valid media ID for the specified category.
+     * @throws {Error} If no servers or valid media IDs are found for the category.
+     */
+    private findServerIds;
+    /**
+     * Fetches curated lists from the Animekai homepage.
+     * @returns Promise resolving to an object with various curated anime lists
+     */
+    fetchHome(): Promise<IAKHomeResponse<IAKSlider[] | []>>;
+    /**
+     * Fetches a list of anime by category.
+     * @param { IAnimeCategory} category - The category of anime to fetch (MOVIE, TV, ONA, OVA, SPECIALS).
+     * @param {number} [page=1] - The page number for pagination (default: 1).
+     * @returns - Promise resolving to paginated anime results.
+     */
+    fetchAnimeCategory(category: IAnimeCategory, page?: number): Promise<IAKPaginated<IAKAnime[] | []>>;
+    /**
+     * Searches for anime titles based on the provided query string.
+     * @param {string} query - The search query string (required).
+     * @param {number} [page] - The page number for pagination (optional, defaults to 1).
+     * @returns  A promise that resolves to an object containing an array of anime results related to the search query.
+     */
+    search(query: string, page?: number): Promise<IAKPaginated<IAKAnime[] | []>>;
+    /**
+     * Fetches a paginated list of recently added anime.
+     * @param {IMetaFormat} category - The format which to fetch anime (optional,  defaults to TV)
+     * @param {number} page - Page number for pagination (default: 1)
+     * @returns  Promise resolving to an object with recently added anime and pagination details
+     */
+    fetchRecentlyAdded(category: IMetaFormat, page?: number): Promise<IAKPaginated<IAKAnime[] | []>>;
+    /**
+     * Fetches a paginated list of recently added anime.
+     * @param {IMetaFormat} category - The format which to fetch anime (optional,  defaults to TV)
+     * @param {number} page - Page number for pagination (default: 1)
+     * @returns  Promise resolving to an object with top airing anime and pagination details
+     */
+    fetchTopAiring(category?: IMetaFormat, page?: number): Promise<IAKPaginated<IAKAnime[] | []>>;
+    /**
+     * Fetches a paginated list of recently updated anime.
+     * @param {IMetaFormat} category - The format which to fetch anime (optional,  defaults to TV)
+     * @param {number} page - Page number for pagination (default: 1)
+     * @returns Promise resolving to an object with recently updated anime and pagination details
+     */
+    fetchRecentlyUpdated(category?: IMetaFormat, page?: number): Promise<IAKPaginated<IAKAnime[] | []>>;
+    /**
+     * Fetches a paginated list of recently completed anime.
+     * @param {IMetaFormat} category - The format which to fetch anime (optional,  defaults to TV)
+     * @param {number} page - Page number for pagination (default: 1)
+     * @returns Promise resolving to an object with recently completed anime and pagination details
+     */
+    fetchRecentlyCompleted(category?: IMetaFormat, page?: number): Promise<IAKPaginated<IAKAnime[] | []>>;
+    /**
+     * Fetches a paginated list of genre curated anime.
+     * @param {AKGenre} genre - The genre which to fetch anime (required)
+     * @param {number} page - Page number for pagination (default: 1)
+     * @returns  Promise resolving to an object with anime curated by genre and pagination details
+     */
+    fetchGenres(genre: string, page?: number): Promise<IAKPaginated<IAKAnime[] | []>>;
+    /**
+     * Fetches detailed information about a specific anime.
+     * @param {string} animeId - The unique identifier for the anime  (required).
+     * @returns  A promise that resolves to an object containing anime details, related seasons provider episodeslists ,recommendations, or an error message.
+     */
+    fetchAnimeInfo(animeId: string): Promise<IAKInfoResponse<IAKInfo | null>>;
+    /**
+     * Fetches server information for a specific episode using the token-based AJAX endpoint.
+     * @private
+     * @param {string} episodeId - The unique identifier for the episode containing the token.
+     * @returns {Promise<IResponse<IServerInfo | null>>} A promise resolving to server information or an error.
+     * @throws {Error} If the episodeId is missing or has invalid format.
+     */
+    fetchServers(episodeId: string): Promise<IResponse<IServerInfo | null>>;
+    /**
+     * **⚠️ . Very unstable
+     * Fetches streaming sources for a given anime episode from a specified server and category.
+     * @param {string} episodeId - The unique identifier for the episode (required).
+     * @param {HISubOrDub} category  - The audio category (Subtitled or Dubbed) (optional, defaults to SubOrDub.SUB).
+     * @param {string}  server - The streaming server to use (optional, defaults to server-1).
+     * @returns  A promise that resolves to an object containing streaming sources, headers, sync data (AniList/MAL IDs), or an error message.
+     */
+    fetchSources(episodeId: string, category?: ISubOrDub, server?: 'server-1' | 'server-2'): Promise<ISourceBaseResponse<IVideoSource | null>>;
+}
+
+type AnimeSearchResults = {
+    id: string | null;
+    name: string | null;
+    romaji?: string | null;
+    provider?: string | null;
+    type?: string | null;
+    native?: string | null;
+    season?: string | null;
+    totalEpisodes?: number | null;
+    releaseDate?: number | string | null;
+};
+declare abstract class BaseAnimeMeta {
+    protected client: FetchClient;
+    protected allanime: AllAnime;
+    protected animekai: Animekai;
+    protected anizone: Anizone;
+    protected hianime: HiAnime;
+    protected animepahe: Animepahe;
+    constructor(provider: 'jikan' | 'anilist');
+    /**
+     * Extract year from ISO date string (YYYY-MM-DD format)
+     * Handles both full dates and partial years
+     * @param dateString - Full date like "2018-10-16" or just "2018"
+     * @returns Year as number or null if invalid
+     */
+    private extractYear;
+    protected createTitleSlug(text: string): string;
+    protected createTitleSlugV2(text: string): string;
+    protected mapAnimeProviderId(metadata: IMetaDataMap | null, results: AnimeSearchResults[] | null, provider: Provider): {
+        id: string;
+        name: string | null;
+        romaji: string | null;
+        provider: Provider;
+        score: number;
+    } | null;
+    protected formatAnizipData(data: any): {
+        animeTitles: {};
+        mappings: {};
+        episodes: never[];
+        images?: undefined;
+        titles?: undefined;
+    } | {
+        images: any;
+        titles: {
+            english: any;
+            japanese: any;
+            german: any;
+            romanized: any;
+            traditionalChinese: any;
+            simplifiedChinese: any;
+        };
+        mappings: {
+            animePlanetId: any;
+            kitsuId: any;
+            malId: any;
+            anilistId: any;
+            anisearchId: any;
+            anidbId: any;
+            notifymoeId: any;
+            livechartId: any;
+            imdbId: any;
+            themoviedbId: any;
+        };
+        episodes: {
+            episodeAnizipNumber: number | null;
+            title: {
+                english: any;
+                japanese: any;
+                german: any;
+                romanizedJapanese: any;
+            };
+            airDate: any;
+            runtime: any;
+            overview: any;
+            image: any;
+            rating: any;
+            aired: boolean;
+        }[];
+        animeTitles?: undefined;
+    };
+    protected anilistAnizip(id: number): Promise<{
+        error: string;
+        data: null;
+        images?: undefined;
+        titles?: undefined;
+        episodes?: undefined;
+        mapping?: undefined;
+    } | {
+        images: any;
+        titles: {
+            english: any;
+            japanese: any;
+            german: any;
+            romanized: any;
+            traditionalChinese: any;
+            simplifiedChinese: any;
+        } | undefined;
+        episodes: never[] | {
+            episodeAnizipNumber: number | null;
+            title: {
+                english: any;
+                japanese: any;
+                german: any;
+                romanizedJapanese: any;
+            };
+            airDate: any;
+            runtime: any;
+            overview: any;
+            image: any;
+            rating: any;
+            aired: boolean;
+        }[];
+        mapping: {
+            animePlanetId: any;
+            kitsuId: any;
+            malId: any;
+            anilistId: any;
+            anisearchId: any;
+            anidbId: any;
+            notifymoeId: any;
+            livechartId: any;
+            imdbId: any;
+            themoviedbId: any;
+        } | {};
+        error?: undefined;
+        data?: undefined;
+    }>;
+    protected malAnizip(id: number): Promise<{
+        error: string;
+        data: null;
+        images?: undefined;
+        titles?: undefined;
+        episodes?: undefined;
+        mapping?: undefined;
+    } | {
+        images: any;
+        titles: {
+            english: any;
+            japanese: any;
+            german: any;
+            romanized: any;
+            traditionalChinese: any;
+            simplifiedChinese: any;
+        } | undefined;
+        episodes: never[] | {
+            episodeAnizipNumber: number | null;
+            title: {
+                english: any;
+                japanese: any;
+                german: any;
+                romanizedJapanese: any;
+            };
+            airDate: any;
+            runtime: any;
+            overview: any;
+            image: any;
+            rating: any;
+            aired: boolean;
+        }[];
+        mapping: {
+            animePlanetId: any;
+            kitsuId: any;
+            malId: any;
+            anilistId: any;
+            anisearchId: any;
+            anidbId: any;
+            notifymoeId: any;
+            livechartId: any;
+            imdbId: any;
+            themoviedbId: any;
+        } | {};
+        error?: undefined;
+        data?: undefined;
+    }>;
+    protected mergeEpisodeData(providerEp: any, aniZipEp: any, provider: string): {
+        episodeNumber: any;
+        episodeId: any;
+        title: any;
+        rating: any;
+        aired: any;
+        airDate: any;
+        overview: any;
+        thumbnail: any;
+        provider: string;
+        hasDub: any;
+        hasSub: any;
+    };
+    protected fetchAnizipByMapping(type: 'anilist_id' | 'mal_id', id: number): Promise<{
+        error: string;
+        data: null;
+        images?: undefined;
+        titles?: undefined;
+        episodes?: undefined;
+        mapping?: undefined;
+    } | {
+        images: any;
+        titles: {
+            english: any;
+            japanese: any;
+            german: any;
+            romanized: any;
+            traditionalChinese: any;
+            simplifiedChinese: any;
+        } | undefined;
+        episodes: never[] | {
+            episodeAnizipNumber: number | null;
+            title: {
+                english: any;
+                japanese: any;
+                german: any;
+                romanizedJapanese: any;
+            };
+            airDate: any;
+            runtime: any;
+            overview: any;
+            image: any;
+            rating: any;
+            aired: boolean;
+        }[];
+        mapping: {
+            animePlanetId: any;
+            kitsuId: any;
+            malId: any;
+            anilistId: any;
+            anisearchId: any;
+            anidbId: any;
+            notifymoeId: any;
+            livechartId: any;
+            imdbId: any;
+            themoviedbId: any;
+        } | {};
+        error?: undefined;
+        data?: undefined;
+    }>;
+}
+
+/**
+ * A class for interacting with the Anilist API to search for anime, fetch detailed information,
+ * retrieve various lists (trending, popular, top-rated, seasonal, upcoming), and get character
+ * and episode information from specific providers.
+ *
+ *
+ */
+declare class Anilist extends BaseAnimeMeta {
+    constructor();
+    private readonly baseUrl;
+    private readonly mappingUrl;
+    /**
+     * Maps Anilist anime data to HiAnime (Zoro) provider ID.
+     *
+     * @private
+     * @param anilistId - The Anilist ID of the anime
+     * @returns Promise resolving to provider mapping data
+     */
+    fetchZoroProviderId(anilistId: number): Promise<IMetaProviderIdResponse<IMetaAnime | null>>;
+    /**
+     * Maps Anilist anime data to Anizone provider ID.
+     *
+     * @private
+     * @param anilistId - The Anilist ID of the anime
+     * @returns Promise resolving to provider mapping data
+     */
+    fetchAnizoneProviderId(anilistId: number): Promise<IMetaProviderIdResponse<IMetaAnime | null>>;
+    /**
+     * Maps Anilist anime data to AllAnime provider ID.
+     *
+     * @private
+     * @param anilistId - The Anilist ID of the anime
+     * @returns Promise resolving to provider mapping data
+     */
+    fetchAllAnimeProviderId(anilistId: number): Promise<IMetaProviderIdResponse<IMetaAnime | null>>;
+    /**
+     * Maps Anilist anime data to AnimePahe provider ID.
+     *
+     * @private
+     * @param anilistId - The Anilist ID of the anime
+     * @returns Promise resolving to provider mapping data
+     */
+    fetchAnimepaheProviderId(anilistId: number): Promise<IMetaProviderIdResponse<IMetaAnime | null>>;
+    /**
+     * Maps Anilist anime data to AnimeKai provider ID.
+     *
+     * @private
+     * @param anilistId - The Anilist ID of the anime
+     * @returns Promise resolving to provider mapping data
+     */
+    fetchAnimeKaiProviderId(anilistId: number): Promise<IMetaProviderIdResponse<IMetaAnime | null>>;
+    /**
+     * Fetches episodes from AllAnime provider and enriches with Anizip data.
+     *
+     * @private
+     * @param anilistId - The Anilist ID of the anime
+     * @returns Promise resolving to episode data enriched with additional metadata
+     */
+    fetchAllAnimeProviderEpisodes(anilistId: number): Promise<IMetaProviderEpisodesResponse<IMetaAnime | null>>;
+    /**
+     * Fetches episodes from AllAnime provider and enriches with Anizip data.
+     *
+     * @private
+     * @param anilistId - The Anilist ID of the anime
+     * @returns Promise resolving to episode data enriched with additional metadata
+     */
+    fetchAnizoneProviderEpisodes(anilistId: number): Promise<IMetaProviderEpisodesResponse<IMetaAnime | null>>;
+    /**
+     * Fetches episodes from HiAnime (Zoro) provider and enriches with Anizip data.
+     *
+     * @private
+     * @param anilistId - The Anilist ID of the anime
+     * @returns Promise resolving to episode data enriched with additional metadata
+     */
+    fetchZoroProviderEpisodes(anilistId: number): Promise<IMetaProviderEpisodesResponse<IMetaAnime | null>>;
+    /**
+     * Fetches episodes from Animekai provider and enriches with Anizip data.
+     *
+     *
+     * @param anilistId - The Anilist ID of the anime
+     * @returns Promise resolving to episode data enriched with additional metadata
+     */
+    fetchAnimeKaiProviderEpisodes(anilistId: number): Promise<IMetaProviderEpisodesResponse<IMetaAnime | null>>;
+    /**
+     * Fetches episodes from AnimePahe provider and enriches with Anizip data.
+     *
+     *
+     * @param anilistId - The Anilist ID of the anime
+     * @returns Promise resolving to episode data enriched with additional metadata
+     */
+    fetchAnimePaheProviderEpisodes(anilistId: number): Promise<IMetaProviderEpisodesResponse<IMetaAnime | null>>;
+    /**
+     * Searches for anime based on the provided query string.
+     *
+     * @param search - The search query string (required)
+     * @param page - The page number for pagination (optional, defaults to 1)
+     * @param perPage - The number of results per page (optional, defaults to 20)
+     * @returns Promise that resolves to paginated search results containing anime data
+     */
+    search(search: string, page?: number, perPage?: number): Promise<IMetaAnimePaginated<IMetaAnime[] | []>>;
+    /**
+     * Fetches detailed information about a specific anime using its Anilist ID.
+     *
+     * @param id - The unique Anilist anime ID (required)
+     * @returns Promise that resolves to detailed anime information
+     */
+    fetchInfo(id: number): Promise<IResponse<IMetaAnime | null>>;
+    /**
+     * Fetches a list of the most anticipated upcoming anime.
+     *
+     * @param page - The page number for pagination (optional, defaults to 1)
+     * @param perPage - The number of results per page (optional, defaults to 20)
+     * @param sort - The sorting order for results (optional, defaults to POPULARITY_DESC)
+     * @returns Promise that resolves to paginated list of upcoming anime
+     */
+    fetchTopUpcoming(page?: number, perPage?: number, sort?: 'SCORE_DESC' | 'POPULARITY_DESC', status?: 'NOT_YET_RELEASED' | 'RELEASING'): Promise<IMetaAnimePaginated<IMetaAnime[] | []>>;
+    /**
+     * Fetches a list of the top airing anime.
+     *
+     * @param page - The page number for pagination (optional, defaults to 1)
+     * @param perPage - The number of results per page (optional, defaults to 20)
+     * @param sort - The sorting order for results (optional, defaults to POPULARITY_DESC)
+     * @returns Promise that resolves to paginated list of airing anime
+     */
+    fetchTopAiring(page?: number, perPage?: number, sort?: 'SCORE_DESC' | 'POPULARITY_DESC', status?: 'NOT_YET_RELEASED' | 'RELEASING'): Promise<IMetaAnimePaginated<IMetaAnime[] | []>>;
+    /**
+     * Fetches a list of the most popular anime.
+     *
+     * @param page - The page number for pagination (optional, defaults to 1)
+     * @param perPage - The number of results per page (optional, defaults to 20)
+     * @param format - The anime format to filter by (optional, defaults to TV)
+     * @returns Promise that resolves to paginated list of popular anime
+     */
+    fetchMostPopular(page?: number, perPage?: number, format?: IMetaFormat, sort?: 'SCORE_DESC' | 'POPULARITY_DESC'): Promise<IMetaAnimePaginated<IMetaAnime[] | []>>;
+    /**
+     * Fetches a list of the top-rated anime.
+     *
+     * @param page - The page number for pagination (optional, defaults to 1)
+     * @param perPage - The number of results per page (optional, defaults to 20)
+     * @param format - The anime format to filter by (optional, defaults to TV)
+  
+     * @returns Promise that resolves to paginated list of top-rated anime
+     */
+    fetchTopRatedAnime(page?: number, perPage?: number, format?: IMetaFormat, sort?: 'SCORE_DESC' | 'POPULARITY_DESC'): Promise<IMetaAnimePaginated<IMetaAnime[] | []>>;
+    /**
+     * Fetches seasonal anime for a given year and season.
+     *
+     * @param season - The target season (e.g., WINTER, SPRING, SUMMER, FALL) (required)
+     * @param seasonYear - The target year (e.g., 2023, 2024) (required)
+     * @param page - The page number for pagination (optional, defaults to 1)
+     * @param perPage - The number of results per page (optional, defaults to 20)
+     * @param format - The anime format to filter by (optional, defaults to TV)
+     * @returns Promise that resolves to paginated list of seasonal anime
+     */
+    fetchSeasonalAnime(season: Seasons, seasonYear: number, page?: number, perPage?: number, format?: IMetaFormat): Promise<IMetaAnimePaginated<IMetaAnime[] | []>>;
+    /**
+     * Fetches a list of currently trending anime.
+     *
+     * @param page - The page number for pagination (optional, defaults to 1)
+     * @param perPage - The number of results per page (optional, defaults to 20)
+     * @returns Promise that resolves to paginated list of trending anime
+     */
+    fetchTrending(page?: number, perPage?: number): Promise<IMetaAnimePaginated<IMetaAnime[] | []>>;
+    /**
+     * Fetches anime titles related to a specific anime ID, such as sequels, prequels, or spin-offs.
+     *
+     * @param mediaId - The unique Anilist anime ID (required)
+     * @returns Promise that resolves to related anime information
+     */
+    fetchRelatedAnime(mediaId: number): Promise<IResponse<IRelatedAnilistData[] | []>>;
+    /**
+     * Fetches characters associated with a specific anime.
+     *
+     * @param mediaId - The unique Anilist anime ID (required)
+     * @returns Promise that resolves to anime characters and their voice actors
+     */
+    fetchCharacters(mediaId: number): Promise<IResponse<IAnilistCharacters | null>>;
+    /**
+     * Fetches the airing schedule for a specific anime by its Anilist ID.
+     *
+     * @param {number} mediaId - The unique Anilist anime ID (required).
+     * @returns  A promise that resolves to an object containing the airing schedule data or an error.
+     * **/
+    fetchMediaSchedule(mediaId: number): Promise<IResponse<MediaSchedule | null>>;
+    /**
+     * Fetches a paginated list of airing schedules for anime with a minimum score.
+     *
+     * @param {number} page - The page number to fetch (deafault=1).
+     * @param {number} [score=60] - The minimum average or mean score for filtering anime (default: 60).If you have bad taste you can lower this
+     * **/
+    fetchAiringSchedule(page?: number, score?: number): Promise<IBasePaginated<AiringSchedule[] | []>>;
+}
+
+/**
+ * A class for interacting with the Jikan API (MyAnimeList unofficial API) to search for anime,
+ * fetch detailed information, retrieve various top lists (airing, movies, popular, upcoming),
+ * seasonal anime, character details, and episode information from MyAnimeList.
+ *
+ *
+ */
+declare class Jikan extends BaseAnimeMeta {
+    constructor();
+    /** Base URL for the Jikan API (MyAnimeList unofficial API) */
+    private readonly baseUrl;
+    /**
+     * Maps MyAnimeList anime data to Zoro provider ID.
+     *
+     * @private
+     * @param malId - The MyAnimeList ID of the anime
+     * @returns Promise resolving to provider mapping data
+     */
+    private fetchZoroProviderId;
+    /**
+     * Maps MyAnimeList anime data to Animekai provider ID.
+     *
+     * @private
+     * @param malId - The MyAnimeList ID of the anime
+     * @returns Promise resolving to provider mapping data
+     */
+    private fetchAnimekaiProviderId;
+    /**
+     * Maps MyAnimeList anime data to Anizone provider ID.
+     *
+     * @private
+     * @param malId - The MyAnimeList ID of the anime
+     * @returns Promise resolving to provider mapping data
+     */
+    private fetchAnizoneProviderId;
+    /**
+     * Maps MyAnimeList anime data to AllAnime provider ID.
+     *
+     * @private
+     * @param malId - The MyAnimeList ID of the anime
+     * @returns Promise resolving to provider mapping data
+     */
+    private fetchAllAnimeProviderId;
+    /**
+     * Maps MyAnimeList anime data to AnimePahe provider ID.
+     *
+     * @private
+     * @param malId - The MyAnimeList ID of the anime
+     * @returns Promise resolving to provider mapping data
+     */
+    private fetchAnimepaheProviderId;
+    /**
+     * Fetches episodes from AllAnime provider and enriches with Anizip data for a given MAL ID.
+     *
+     * @private
+     * @param malId - The MyAnimeList ID of the anime
+     * @returns Promise resolving to episode data enriched with additional metadata
+     */
+    private fetchAllAnimeProviderEpisodes;
+    /**
+     * Fetches episodes from AllAnime provider and enriches with Anizip data for a given MAL ID.
+     *
+     * @private
+     * @param malId - The MyAnimeList ID of the anime
+     * @returns Promise resolving to episode data enriched with additional metadata
+     */
+    private fetchAnizoneProviderEpisodes;
+    /**
+     * Fetches episodes from HiAnime (Zoro) provider and enriches with Anizip data for a given MAL ID.
+     *
+     * @private
+     * @param malId - The MyAnimeList ID of the anime
+     * @returns Promise resolving to episode data enriched with additional metadata
+     */
+    private fetchZoroProviderEpisodes;
+    /**
+     * Fetches episodes from Animekai provider and enriches with Anizip data for a given MAL ID.
+     *
+     * @private
+     * @param malId - The MyAnimeList ID of the anime
+     * @returns Promise resolving to episode data enriched with additional metadata
+     */
+    private fetchAnimekaiProviderEpisodes;
+    /**
+     * Fetches episodes from AnimePahe provider and enriches with Anizip data for a given MAL ID.
+     *
+     * @private
+     * @param malId - The MyAnimeList ID of the anime
+     * @returns Promise resolving to episode data enriched with additional metadata
+     */
+    private fetchPaheProviderEpisodes;
+    /**
+     * Searches for anime titles based on the provided query string using Jikan API.
+     *
+     * @param query - The search query string (required)
+     * @param page - The page number for pagination (optional, defaults to 1)
+     * @param perPage - The number of results per page (optional, defaults to 20, maximum 25)
+     * @returns Promise that resolves to paginated search results containing anime data
+     */
+    search(query: string, page?: number, perPage?: number): Promise<IMetaAnimePaginated<IMetaAnime[] | []>>;
+    /**
+     * Fetches detailed information about a specific anime using its MyAnimeList (MAL) ID.
+     *
+     * @param malId - The unique MyAnimeList (MAL) ID for the anime (required)
+     * @returns Promise that resolves to comprehensive detailed anime information
+     */
+    fetchInfo(malId: number): Promise<IResponse<IMetaAnime | null>>;
+    /**
+     * Fetches characters associated with a specific anime from MyAnimeList.
+     *
+     * @param malId - The unique MyAnimeList (MAL) ID for the anime (required)
+     * @returns Promise that resolves to anime characters with voice actor information
+     */
+    fetchAnimeCharacters(malId: number): Promise<IResponse<IMetaCharacters[] | []>>;
+    /**
+     * Fetches the anime list for the current season from MyAnimeList.
+     *
+     * @param page - The page number for pagination (required)
+     * @param perPage - The number of results per page (required, maximum 25)
+     * @param format - The format type to filter by (optional, defaults to TV)
+     * @returns Promise that resolves to paginated list of current seasonal anime
+     */
+    fetchCurrentSeason(page?: number, perPage?: number, format?: IMetaFormat): Promise<IMetaAnimePaginated<IMetaAnime[] | []>>;
+    /**
+     * Fetches the anime list for the upcoming season from MyAnimeList.
+     *
+     * @param page - The page number for pagination (optional, defaults to 1)
+     * @param perPage - The number of results per page (optional, defaults to 20, maximum 25)
+     * @param format - The format type to filter by (optional, defaults to TV)
+     * @returns Promise that resolves to paginated list of upcoming season's anime
+     */
+    fetchNextSeason(page?: number, perPage?: number, format?: IMetaFormat): Promise<IMetaAnimePaginated<IMetaAnime[] | []>>;
+    /**
+     * Fetches seasonal anime for a given year and season from MyAnimeList.
+     *
+     * @param season - The target season (e.g., WINTER, SPRING, SUMMER, FALL) (required)
+     * @param year - The target year (e.g., 2023, 2024) (required)
+     * @param format - The anime format to filter by (optional, defaults to TV)
+     * @param page - The page number for pagination (optional, defaults to 1)
+     * @param perPage - The number of results per page (optional, defaults to 20, maximum 25)
+     * @returns Promise that resolves to paginated list of seasonal anime
+     */
+    fetchSeasonalAnime(season: Seasons, year: number, format?: IMetaFormat, page?: number, perPage?: number): Promise<IMetaAnimePaginated<IMetaAnime[] | []>>;
+    /**
+     * Fetches a list of the top-rated anime from MyAnimeList.
+     *
+     * @param page - The page number for pagination (optional, defaults to 1)
+     * @param perPage - The number of results per page (optional, defaults to 20)
+     * @param format - The anime format to filter by (optional, defaults to TV)
+     * @param sort - The sorting criteria (optional, defaults to 'rating')
+     * @returns Promise that resolves to paginated list of top-rated anime
+     */
+    fetchTopAnime(page?: number, perPage?: number, format?: IMetaFormat, sort?: JSort): Promise<IMetaAnimePaginated<IMetaAnime[] | []>>;
+    /**
+     * Fetches a list of the top airing anime from MyAnimeList.
+     *
+     * @param page - The page number for pagination (optional, defaults to 1)
+     * @param perPage - The number of results per page (optional, defaults to 20, maximum 25)
+     * @param format - The format type to filter by (optional, defaults to TV)
+     * @returns Promise that resolves to paginated list of top airing anime
+     */
+    fetchTopAiring(page?: number, perPage?: number, format?: IMetaFormat, sort?: JSort): Promise<IMetaAnimePaginated<IMetaAnime[] | []>>;
+    /**
+     * Fetches a list of the most anticipated upcoming anime from MyAnimeList.
+     *
+     * @param page - The page number for pagination (optional, defaults to 1)
+     * @param perPage - The number of results per page (optional, defaults to 20, maximum 25)
+     * @param format - The format type to filter by (optional, defaults to TV)
+     * @returns Promise that resolves to paginated list of upcoming anime resources
+     */
+    fetchTopUpcoming(page?: number, perPage?: number, format?: IMetaFormat, sort?: JSort): Promise<IMetaAnimePaginated<IMetaAnime[] | []>>;
+    /**
+     * Fetches a list of the most popular anime from MyAnimeList.
+     *
+     * @param page - The page number for pagination (optional, defaults to 1)
+     * @param perPage - The number of results per page (optional, defaults to 20, maximum 25)
+     * @param format - The format type to filter by (optional, defaults to TV)
+     * @param sort - The sorting criteria (optional, defaults to 'bypopularity')
+     * @returns Promise that resolves to paginated list of most popular anime
+     */
+    fetchMostPopular(page?: number, perPage?: number, format?: IMetaFormat, sort?: JSort): Promise<IMetaAnimePaginated<IMetaAnime[] | []>>;
+    /**
+     * Fetches a list of the most favorite anime from MyAnimeList.
+     *
+     * @param page - The page number for pagination (optional, defaults to 1)
+     * @param perPage - The number of results per page (optional, defaults to 20, maximum 25)
+     * @param format - The format type to filter by (optional, defaults to TV)
+     * @param sort - The sorting criteria (optional, defaults to 'bypopularity')
+     * @returns Promise that resolves to paginated list of most favorite anime
+     */
+    fetchMostFavorite(page?: number, perPage?: number, format?: IMetaFormat, sort?: JSort): Promise<IMetaAnimePaginated<IMetaAnime[] | []>>;
+    /**
+     * Fetches anime information along with a provider-specific anime ID for MyAnimeList entries.
+     *
+     * @param malId - The unique MyAnimeList anime ID (required)
+     * @param provider - The anime provider to fetch data from (optional, defaults to HiAnime)
+     * @returns Promise that resolves to provider-specific anime ID and core anime info
+     */
+    fetchProviderId(malId: number, provider?: 'hianime' | 'allanime' | 'animepahe' | 'anizone' | 'animekai'): Promise<IMetaProviderIdResponse<IMetaAnime | null>>;
+    /**
+     * Fetches anime information along with provider-specific episode details using the MAL ID.
+     *
+     * @param malId - The unique MAL ID of the anime (required)
+     * @param provider - The anime provider to fetch episodes from (optional, defaults to HiAnime)
+     * @returns Promise that resolves to anime info and its episodes from the specified provider
+     */
+    fetchAnimeProviderEpisodes(malId: number, provider?: 'hianime' | 'allanime' | 'animepahe' | 'anizone' | 'animekai'): Promise<IMetaProviderEpisodesResponse<IMetaAnime | null>>;
+}
+
+/**
+ * A scraper and API wrapper for the unofficial FlixHQ website,
+ * providing methods to fetch and parse movies, TV shows, and related data.
+ *
+ *
+ */
+declare class FlixHQ extends BaseClass {
+    private readonly baseUrl;
+    constructor(baseUrl?: string);
+    /**
+     * Parses movie/TV show items from a Cheerio selection for standard item lists.
+     *
+     * @private
+     * @param $ - Cheerio API instance
+     * @param selector - CSS selector for the items to parse
+     * @returns Array of parsed movie or TV show objects
+     */
+    private parseItems;
+    /**
+     * Parses mixed movie/TV show items from a Cheerio selection for upcoming content sections.
+     *
+     * @private
+     * @param $ - Cheerio API instance
+     * @param selector - CSS selector for the mixed items to parse
+     * @returns Array of parsed movie or TV show objects with additional release date information
+     */
+    private parseMixedSection;
+    /**
+     * Parses the complete homepage structure from FlixHQ including featured slider, trending, recent releases, and upcoming content.
+     *
+     * @private
+     * @param $ - Cheerio API instance containing homepage HTML
+     * @returns Complete homepage data structure with all sections parsed
+     */
+    private parseHome;
+    /**
+     * Parses paginated results from FlixHQ search, category, or filter pages.
+     *
+     * @private
+     * @param $ - Cheerio API instance containing paginated HTML content
+     * @param selector - CSS selector for the media items in the paginated results
+     * @returns Paginated results object with media items and pagination metadata
+     */
+    private parsePaginatedResults;
+    /**
+     * Parses search suggestions from FlixHQ AJAX autocomplete response.
+     *
+     * @private
+     * @param $ - Cheerio API instance containing search suggestions HTML
+     * @returns Response object containing parsed search suggestion items
+     */
+    private parseSearchSuggestions;
+    /**
+     * Parses the recommended section from individual media info pages.
+     *
+     * @private
+     * @param $ - Cheerio API instance containing media info page HTML
+     * @returns Array of recommended movie or TV show items
+     */
+    private parseInfoRecommendedSection;
+    /**
+     * Parses detailed media information from FlixHQ media detail pages.
+     *
+     * @private
+     * @param $ - Cheerio API instance containing media info page HTML
+     * @returns Media information object with detailed metadata and recommendations
+     */
+    private parseInfo;
+    /**
+     * Parses available seasons from FlixHQ TV show season dropdown.
+     *
+     * @private
+     * @param $ - Cheerio API instance containing season dropdown HTML
+     * @returns Array of season objects with season IDs and numbers
+     */
+    private parseSeasons;
+    /**
+     * Constructs AJAX URLs for different FlixHQ endpoints for episode and server data.
+     *
+     * @private
+     * @param id - The media or season identifier
+     * @param kind - The type of AJAX request ('movie-server', 'tv-server', 'tv', 'season')
+     * @returns Complete AJAX URL for the specified endpoint type
+     */
+    private buildAjaxUrl;
+    /**
+     * Parses episode information from FlixHQ season episodes AJAX response.
+     *
+     * @private
+     * @param $ - Cheerio API instance containing season episodes HTML
+     * @param seasonNumber - The season number these episodes belong to
+     * @param tvInfo - Tv data used to construct episodeId
+     * @param media - The media identifier for constructing episode IDs
+     * @returns Array of parsed episode objects with titles and numbering
+     */
+    private parseEpisodes;
+    /**
+     * Parses available streaming servers from FlixHQ server list AJAX response.
+     *
+     * @private
+     * @param $ - Cheerio API instance containing server list HTML
+     * @returns Array of server objects with server IDs and names
+     */
+    private parseServers;
+    /**
+     * Finds the server ID for a specific server name from the available servers list.
+     *
+     * @private
+     * @param servers - Array of available server objects
+     * @param server - The target server name to find ('upcloud', 'vidcloud', or 'akcloud')
+     * @returns The server ID for the specified server
+     * @throws Error if the specified server is not available
+     */
+    private findServerId;
+    /**
+     * Fetches paginated content from FlixHQ for various categories, filters, and search endpoints.
+     *
+     * @private
+     * @param path - The URL path, filter string, or category identifier
+     * @param page - The page number for pagination
+     * @returns Promise resolving to paginated media results with error handling
+     */
+    private fetchPaginated;
+    /**
+     * Fetches curated lists from the FlixHQ homepage including featured slider, trending content, recent releases, and upcoming media.
+     *
+     * @returns Promise resolving to complete homepage data structure with all curated sections
+     */
+    fetchHome(): Promise<IHomeHIResponse<IMovieOrTv[] | []>>;
+    /**
+     * Searches for movies and TV shows based on the provided query string across FlixHQ catalog.
+     *
+     * @param query - The search query string (required)
+     * @param page - The page number for pagination (optional, defaults to 1)
+     * @returns Promise resolving to paginated search results containing matching media items
+     */
+    search(query: string, page?: number): Promise<IZPaginated<IMovieOrTv[] | []>>;
+    /**
+     * Performs an advanced search with multiple filter criteria including type, quality, genre, and country.
+     *
+     * Performs an advanced search with filters.
+     * @param {'all' | 'movie' | 'tv'} [type] - The media type filter (default=all).
+     * @param {'all' | 'HD' | 'SD' | 'CAM'} [quality] - The quality filter (default=all).
+     * @param genre - Genre filter using HIMoviesGenreID mapping (optional, defaults to 'all')
+     * @param country - Country filter using HIMoviesCountryID mapping (optional, defaults to 'all')
+     * @param page - Page number for pagination (optional, defaults to 1)
+     * @returns Promise resolving to paginated results filtered by all specified criteria
+     */
+    advancedSearch(type?: 'all' | 'movie' | 'tv', quality?: 'all' | 'HD' | 'SD' | 'CAM', genre?: string, country?: string, year?: string, page?: number): Promise<IZPaginated<IMovieOrTv[] | []>>;
+    /**
+     * Fetches search suggestions for autocomplete functionality based on partial query input.
+     *
+     * @param query - The partial search query string (required)
+     * @returns Promise resolving to search suggestions containing matching media items
+     */
+    searchSuggestions(query: string): Promise<IResponse<IMovieOrTv[] | []>>;
+    /**
+     * Fetches a paginated list of the most popular movies from FlixHQ catalog.
+     *
+     * @param page - Page number for pagination (optional, defaults to 1)
+     * @returns Promise resolving to paginated list of popular movies sorted by popularity
+     */
+    fetchPopularMovies(page?: number): Promise<IZPaginated<IMovieOrTv[] | []>>;
+    /**
+     * Fetches a paginated list of the most popular TV shows.
+     * @param {number} [page=1] - Page number for pagination (default: 1).
+     * @returns  Paginated popular TV shows
+     */
+    fetchPopularTv(page?: number): Promise<IZPaginated<IMovieOrTv[] | []>>;
+    /**
+     * Fetches a paginated list of top rated movies.
+     * @param {number} [page=1] - Page number for pagination (default: 1).
+     * @returns Paginated top-rated movies
+     */
+    fetchTopMovies(page?: number): Promise<IZPaginated<IMovieOrTv[] | []>>;
+    /**
+     * Fetches a paginated list of top rated TV shows.
+     * @param {number} [page=1] - Page number for pagination (default: 1).
+     * @returns Paginated top-rated TV shows
+     */
+    fetchTopTv(page?: number): Promise<IZPaginated<IMovieOrTv[] | []>>;
+    /**
+     * Fetches a paginated list of upcoming media to be added.
+     * @param {number} [page=1] - Page number for pagination (default: 1).
+     * @returns  Paginated media for upcoming
+     */
+    fetchUpcoming(page?: number): Promise<IZPaginated<IMovieOrTv[] | []>>;
+    /**
+     * Fetches media by genre.
+     * @param {string} genre - The genre to filter by.
+     * @param {number} [page=1] - Page number for pagination (default: 1).
+     * @returns  Paginated media by genre
+     */
+    fetchGenre(genre: string, page?: number): Promise<IZPaginated<IMovieOrTv[] | []>>;
+    /**
+     * Fetches media by country.
+     * @param {string} country - The country code to filter by.
+     * @param {number} [page=1] - Page number for pagination (default: 1).
+     * @returns Paginated media by country
+     */
+    fetchByCountry(country: string, page?: number): Promise<IZPaginated<IMovieOrTv[] | []>>;
+    /**
+     * Fetches detailed information about a specific movie or TV show.
+     * @param {string} mediaId - The unique identifier for the movie or TV show (required).
+     * @returns A promise that resolves to an object containing detailed media information, recommendations, including episodes for TV shows.
+     */
+    fetchMediaInfo(mediaId: string): Promise<IMovieInfoResponse<IMovieInfo | null>>;
+    /**
+     * Fetches available server information for a specific episodeId.
+     * @param {string} episodeId - The unique identifier for the episode/movie (required). Found in the episodes array.
+     * @returns  A promise that resolves to an object containing server information for the episode.
+     */
+    fetchServers(episodeId: string): Promise<IResponse<IMovieServers[] | []>>;
+    /**
+     * Fetches streaming sources for a selected media episode from a specified server.
+     * @param {string} episodeId - The unique identifier for the episode/movie (required). Found in the episodes array
+     * @param  [server] - The server to use (optional, defaults to Vidcloud). Note: Upcloud is CORS protected (Error 403). Use a proxy or switch to Vidcloud or Akcloud(🤷) .
+     * @returns  A promise that resolves to an object containing streaming sources for the media.
+     */
+    fetchSources(episodeId: string, server?: 'upcloud' | 'vidcloud' | 'akcloud'): Promise<ISourceBaseResponse<IVideoSource | null>>;
+}
+
+/**
+ * A scraper and API wrapper for the unofficial HiMovies website,
+ * providing methods to fetch and parse movies, TV shows, and related data.
+ *
+ *
+ */
+declare class HiMovies extends BaseClass {
+    private readonly baseUrl;
+    constructor(baseUrl?: string);
+    /**
+     * Parses movie/TV show items from a Cheerio selection for standard item lists.
+     *
+     * @private
+     * @param $ - Cheerio API instance
+     * @param selector - CSS selector for the items to parse
+     * @returns Array of parsed movie or TV show objects
+     */
+    private parseItems;
+    /**
+     * Parses mixed movie/TV show items from a Cheerio selection for upcoming content sections.
+     *
+     * @private
+     * @param $ - Cheerio API instance
+     * @param selector - CSS selector for the mixed items to parse
+     * @returns Array of parsed movie or TV show objects with additional release date information
+     */
+    private parseMixedSection;
+    /**
+     * Parses the complete homepage structure from HIMovies including, trending, recent releases, and upcoming content.
+     *
+     * @private
+     * @param $ - Cheerio API instance containing homepage HTML
+     * @returns Complete homepage data structure with all sections parsed
+     */
+    private parseHome;
+    /**
+     * Parses paginated results from  search, category, or filter pages.
+     *
+     * @private
+     * @param $ - Cheerio API instance containing paginated HTML content
+     * @param selector - CSS selector for the media items in the paginated results
+     * @returns Paginated results object with media items and pagination metadata
+     */
+    private parsePaginatedResults;
+    /**
+     * Parses search suggestions from AJAX autocomplete response.
+     *
+     * @private
+     * @param $ - Cheerio API instance containing search suggestions HTML
+     * @returns Response object containing parsed search suggestion items
+     */
+    private parseSearchSuggestions;
+    /**
+     * Parses the recommended section from individual media info pages.
+     *
+     * @private
+     * @param $ - Cheerio API instance containing media info page HTML
+     * @returns Array of recommended movie or TV show items
+     */
+    private parseInfoRecommendedSection;
+    /**
+     * Parses detailed media information from media detail pages.
+     *
+     * @private
+     * @param $ - Cheerio API instance containing media info page HTML
+     * @returns Media information object with detailed metadata and recommendations
+     */
+    private parseInfo;
+    /**
+     * Parses available seasons from TV show season dropdown.
+     *
+     * @private
+     * @param $ - Cheerio API instance containing season dropdown HTML
+     * @returns Array of season objects with season IDs and numbers
+     */
+    private parseSeasons;
+    /**
+     * Constructs AJAX URLs for different endpoints for episode and server data.
+     *
+     * @private
+     * @param id - The media or season identifier
+     * @param kind - The type of AJAX request ('movie-server', 'tv-server', 'tv', 'season')
+     * @returns Complete AJAX URL for the specified endpoint type
+     */
+    private buildAjaxUrl;
+    /**
+     * Parses episode information from season episodes AJAX response.
+     *
+     * @private
+     * @param $ - Cheerio API instance containing season episodes HTML
+     * @param seasonNumber - The season number these episodes belong to
+     * @param tvInfo - Tv data used to construct episodeId
+     * @param media - The media identifier for constructing episode IDs
+     * @returns Array of parsed episode objects with titles and numbering
+     */
+    private parseEpisodes;
+    /**
+     * Parses available streaming servers from  server list AJAX response.
+     *
+     * @private
+     * @param $ - Cheerio API instance containing server list HTML
+     * @returns Array of server objects with server IDs and names
+     */
+    private parseServers;
+    /**
+     * Finds the server ID for a specific server name from the available servers list.
+     *
+     * @private
+     * @param servers - Array of available server objects
+     * @param server - The target server name to find ('upcloud', 'megacloud', or 'akcloud')
+     * @returns The server ID for the specified server
+     * @throws Error if the specified server is not available
+     */
+    private findServerId;
+    /**
+     * Fetches paginated content for various categories, filters, and search endpoints.
+     *
+     * @private
+     * @param path - The URL path, filter string, or category identifier
+     * @param page - The page number for pagination
+     * @returns Promise resolving to paginated media results with error handling
+     */
+    private fetchPaginated;
+    /**
+     * Fetches curated lists from the HiMovies homepage including , trending content, recent releases, and upcoming media.
+     *
+     * @returns Promise resolving to complete homepage data structure with all curated sections
+     */
+    fetchHome(): Promise<IHomeHIResponse<IMovieOrTv[] | []>>;
+    /**
+     * Searches for media based on the provided query string.
+     * @param {string} query - The search query string (required).
+     * @param {number} [page=1] - The page number for pagination (optional, defaults to 1).
+     * @returns  A promise that resolves to an object containing an array of media titles, pagination details, or an error message.
+     */
+    search(query: string, page?: number): Promise<IZPaginated<IMovieOrTv[] | []>>;
+    /**
+     * Performs an advanced search with filters.
+     * @param {'all' | 'movie' | 'tv'} [type] - The media type filter (default=all).
+     * @param {'all' | 'HD' | 'SD' | 'CAM'} [quality] - The quality filter (default=all).
+     * @param {HIMoviesGenreID} [genre] - Genre filter (default ='all').
+     * @param {HIMoviesCountryID} [country] - Country filter (default ='all').
+     * @param {number} [page=1] - Page number for pagination (default ='all').
+     * @returns  Paginated filtered search results
+     */
+    advancedSearch(type?: 'all' | 'movie' | 'tv', quality?: 'all' | 'HD' | 'SD' | 'CAM', genre?: string, country?: string, year?: string, page?: number): Promise<IZPaginated<IMovieOrTv[] | []>>;
+    /**
+     * Fetches search suggestions for a query string.
+     * @param {string} query - The search query string (required).
+     * @returns {Promise<IResponse<IMovieOrTv[] | []>>} Search suggestions for autocomplete
+     */
+    searchSuggestions(query: string): Promise<IResponse<IMovieOrTv[] | []>>;
+    /**
+     * Fetches a paginated list of the most popular movies.
+     * @param {number} [page=1] - Page number for pagination (default: 1).
+     * @returns  Paginated popular movies
+     */
+    fetchPopularMovies(page?: number): Promise<IZPaginated<IMovieOrTv[] | []>>;
+    /**
+     * Fetches a paginated list of the most popular TV shows.
+     * @param {number} [page=1] - Page number for pagination (default: 1).
+     * @returns  Paginated popular TV shows
+     */
+    fetchPopularTv(page?: number): Promise<IZPaginated<IMovieOrTv[] | []>>;
+    /**
+     * Fetches a paginated list of top rated movies.
+     * @param {number} [page=1] - Page number for pagination (default: 1).
+     * @returns  Paginated top-rated movies
+     */
+    fetchTopMovies(page?: number): Promise<IZPaginated<IMovieOrTv[] | []>>;
+    /**
+     * Fetches a paginated list of top rated TV shows.
+     * @param {number} [page=1] - Page number for pagination (default: 1).
+     * @returns  Paginated top-rated TV shows
+     */
+    fetchTopTv(page?: number): Promise<IZPaginated<IMovieOrTv[] | []>>;
+    /**
+     * Fetches a paginated list of upcoming media to be added.
+     * @param {number} [page=1] - Page number for pagination (default: 1).
+     * @returns  Paginated media
+     */
+    fetchUpcoming(page?: number): Promise<IZPaginated<IMovieOrTv[] | []>>;
+    /**
+     * Fetches media by genre.
+     * @param {string} genre - The genre to filter by.
+     * @param {number} [page=1] - Page number for pagination (default: 1).
+     * @returns  Paginated media by genre
+     */
+    fetchGenre(genre: string, page?: number): Promise<IZPaginated<IMovieOrTv[] | []>>;
+    /**
+     * Fetches media by country.
+     * @param {string} country - The country code to filter by.
+     * @param {number} [page=1] - Page number for pagination (default: 1).
+     * @returns  Paginated media by country
+     */
+    fetchByCountry(country: string, page?: number): Promise<IZPaginated<IMovieOrTv[] | []>>;
+    /**
+     * Fetches detailed information about a specific movie or TV show.
+     * @param {string} mediaId - The unique identifier for the movie or TV show (required).
+     * @returns  A promise that resolves to an object containing detailed media information, recommendations, including episodes for TV shows.
+     */
+    fetchMediaInfo(mediaId: string): Promise<IMovieInfoResponse<IMovieInfo | null>>;
+    /**
+     * Fetches available server information for a specific episodeId.
+     * @param {string} episodeId - The unique identifier for the episode/movie (required). Found in the episodes array.
+     * @returns  A promise that resolves to an object containing server information for the episode.
+     */
+    fetchServers(episodeId: string): Promise<IResponse<IMovieServers[] | []>>;
+    /**
+     * Fetches streaming sources for a selected media episode from a specified server.
+     * @param {string} episodeId - The unique identifier for the episode/movie (required). Found in the episodes array
+     * @param  [server] - The server to use (optional, defaults to Megacloud). Note: Upcloud is CORS protected (Error 403). Use a proxy or switch to Megacloud or Akcloud(🤷) .
+     * @returns  A promise that resolves to an object containing streaming sources for the media.
+     */
+    fetchSources(episodeId: string, server?: 'upcloud' | 'megacloud' | 'akcloud'): Promise<ISourceBaseResponse<IVideoSource | null>>;
+}
+
+/**
+ * A class for interacting with the HiAnime platform (hianime.to) to search for anime, fetch detailed information,
+ * retrieve episode lists, get available streaming servers, and fetch curated anime lists.
+ */
+declare class Kaido extends BaseClass {
+    private readonly baseUrl;
+    constructor(baseUrl?: string);
+    /**
+     * Parses paginated anime search results from a Cheerio instance.
+     * Extracts anime details and pagination information from the provided HTML selector.
+     * @param $ CheerioAPI instance
+     * @param selector CSS selector for anime items
+     * @returns An object containing anime list and pagination details
+     */
+    private parsePaginatedResults;
+    /**
+     * Parses search suggestion results from a Cheerio instance.
+     * Extracts anime suggestion details from the provided HTML.
+     * @param $ CheerioAPI instance
+     * @returns An array containing an array of search suggestions
+     */
+    private parseSearchSuggestions;
+    /**
+     * Parses detailed anime information from a Cheerio instance.
+     * Extracts anime details, characters, recommendations, related anime, seasons, and promotion videos.
+     * @param $ CheerioAPI instance
+     * @returns Object containing anime details and related data
+     */
+    private parseAnimeInfo;
+    /**
+     * Parses the HiAnime homepage data from a Cheerio instance.
+     * Extracts spotlight, trending, top airing, most popular, favorites, recently completed, recently added, recently updated, and top anime rankings.
+     * @param $ CheerioAPI instance
+     * @returns An object containing various curated anime lists
+     */
+    private parseHome;
+    /**
+     * Parses paginated sections like top airing, most popular, etc., from a Cheerio instance.
+     * Extracts anime details, pagination information
+     * @param $ CheerioAPI instance
+     * @returns RepetitiveSections containing anime list, pagination details, and top anime rankings
+     */
+    private parsePaginatedSections;
+    /**
+     * Parses episode data for an anime from a Cheerio instance.
+     * Extracts episode IDs, titles, and numbers from the provided HTML.
+     * @param $ CheerioAPI instance
+     * @returns Response containing an array of episode information
+     */
+    private parseEpisodes;
+    /**
+     * Parses streaming server data for an episode from a Cheerio instance.
+     * Extracts sub, dub, and raw server details along with episode number.
+     * @param $ CheerioAPI instance
+     * @returns Response containing server information
+     */
+    private parseServerData;
+    /**
+     * Finds the server ID for a given category and server name from the server data.
+     * @param servers Server information containing sub, dub, and raw server lists
+     * @param category Sub or dub category
+     * @param server Server name to find
+     * @returns The media ID of the matching server
+     * @throws Error if the category or server is not found
+     */
+    private findServerId;
+    /**
+     * Searches for anime based on the provided query string.
+     * @param {string} query - The search query string (required).
+     * @param {number} [page=1] - The page number for pagination (optional, defaults to 1).
+     * @returns  A promise that resolves to an object containing an array of anime titles, pagination details, or an error message.
+     */
+    search(query: string, page?: number): Promise<IZPaginated$1<IZAnime[] | []>>;
+    /**
+     * Fetches search suggestions for a given query string from the HiAnime platform.
+     * @param {string} query - The search query string (required).
+     @returns A promise that resolves to an object containing an array of anime titles or an error message.
+     */
+    searchSuggestions(query: string): Promise<IResponse<IZSearchSuggestions[] | []>>;
+    /**
+     * Fetches curated lists from the HiAnime homepage.
+     * @returns Promise resolving to an object with various curated anime lists
+     */
+    fetchHome(): Promise<IZHomeResponse<IZSpotlight[] | []>>;
+    /**
+     * Fetches a paginated list of top airing anime.
+     * @param {number} page - Page number for pagination (default: 1)
+     * @returns  Promise resolving to an object with top airing anime and pagination details
+     */
+    fetchTopAiring(page?: number): Promise<IZPaginated$1<IZAnime[] | []>>;
+    /**
+     * Fetches a paginated list of the most favorited anime.
+     * @param {number} page - Page number for pagination (default: 1)
+     * @returns  Promise resolving to an object  with favorited anime and pagination details
+     */
+    fetchMostFavourites(page?: number): Promise<IZPaginated$1<IZAnime[] | []>>;
+    /**
+     * Fetches a paginated list of the most popular anime.
+     * @param {number} page - Page number for pagination (default: 1)
+     * @returns  Promise resolving to an object  with popular anime and pagination details
+     */
+    fetchMostPopular(page?: number): Promise<IZPaginated$1<IZAnime[] | []>>;
+    /**
+     * Fetches a paginated list of recently completed anime.
+     * @param {number} page - Page number for pagination (default: 1)
+     * @returns  Promise resolving to an object  with recently completed anime and pagination details
+     */
+    fetchRecentlyCompleted(page?: number): Promise<IZPaginated$1<IZAnime[] | []>>;
+    /**
+     * Fetches a paginated list of recently added anime.
+     * @param {number} page - Page number for pagination (default: 1)
+     * @returns  Promise resolving to an object with recently added anime and pagination details
+     */
+    fetchRecentlyAdded(page?: number): Promise<IZPaginated$1<IZAnime[] | []>>;
+    /**
+     * Fetches a paginated list of recently updated anime.
+     * @param {number} page - Page number for pagination (default: 1)
+     * @returns  Promise resolving to an object  with recently updated anime and pagination details
+     */
+    fetchRecentlyUpdated(page?: number): Promise<IZPaginated$1<IZAnime[] | []>>;
+    /**
+     * Fetches a list of anime titles sorted alphabetically, optionally filtered by a starting character.
+     * @param {any} sort Optional letter (A-Z) or "0-9" to filter anime
+     * @param {number} page - Page number for pagination (default: 1)
+     *@returns Promise resolving to an object  with alphabetically sorted anime and pagination details
+     */
+    fetchAtoZList(sort?: any, page?: number): Promise<IZPaginated$1<IZAnime[] | []>>;
+    /**
+     * Fetches a list of anime by genre.
+     * @param {string} genre -The genre to filter anime by
+     * @param {number} page - Page number for pagination (default: 1)
+     * @returns  Promise resolving to an object with genre-specific anime and pagination details
+     */
+    fetchGenre(genre: string, page?: number): Promise<IZPaginated$1<IZAnime[] | []>>;
+    /**
+     * Fetches a list of subbed anime.
+     * @param {number} page - Page number for pagination (default: 1)
+     * @returns  Promise resolving to an object with subbed anime and pagination details
+     */
+    fetchSubbedAnime(page?: number): Promise<IZPaginated$1<IZAnime[] | []>>;
+    /**
+     * Fetches a list of dubbed anime.
+     * @param {number} page - Page number for pagination (default: 1)
+     * @returns {  Promise<IAnimePaginated<IAnime[] | []>>} Promise resolving to an object with dubbed anime and pagination details
+     */
+    fetchDubbedAnime(page?: number): Promise<IZPaginated$1<IZAnime[] | []>>;
+    /**
+     * Fetches a list of anime by category.
+     * @param { IAnimeCategory} category - The category of anime to fetch (MOVIE, TV, ONA, OVA, SPECIALS).
+     * @param {number} [page=1] - The page number for pagination (default: 1).
+     * @returns - Promise resolving to paginated anime results.
+     */
+    fetchAnimeCategory(category: IAnimeCategory, page?: number): Promise<IZPaginated$1<IZAnime[] | []>>;
+    /**
+     * Fetches detailed information about a specific anime including episodes.
+     * @param {string} animeId - The unique identifier for the anime (e.g., "bleach-806") (required).
+     * @returns  A promise that resolves to an object containing anime details,provider episodes, related seasons, characters, recommendations, or an error message.
+     */
+    fetchAnimeInfo(animeId: string): Promise<IZoroInfoResponse<IZAnimeInfo | null>>;
+    /**
+     * Fetches episode data for a specific anime.
+     * @param {string} animeId - The unique identifier for the anime (e.g., "bleach-806") (required).
+     * @returns  A promise that resolves to an object containing an array of episode information or an error message.
+     */
+    fetchEpisodes(animeId: string): Promise<IResponse<IZEpisodes[] | []>>;
+    /**
+     * Fetches available streaming servers for a specific anime episode.
+     * @param {string} episodeId - The unique identifier for the episode  (required).
+     * @returns  A promise that resolves to an object containing available streaming server details (sub, dub, raw) or an error message.
+     */
+    fetchServers(episodeId: string): Promise<IResponse<IServerInfo | null>>;
+    /**
+     * Fetches streaming sources for a given anime episode from a specified server and category.
+     * @param {string} episodeId - The unique identifier for the episode (required).
+     * @param   server - The streaming server to use (optional, defaults to vidcloud). Note: vidstreaming may return a 403 error due to CORS restrictions; use a proxy.
+     * @param {ISubOrDub} category  - The audio category (Subtitled or Dubbed) (optional, defaults to SubOrDub.SUB).
+     * @returns  A promise that resolves to an object containing streaming sources, headers, sync data (AniList/MAL IDs), or an error message.
+     */
+    fetchSources(episodeId: string, server?: 'vidstreaming' | 'vidcloud', category?: ISubOrDub): Promise<IZSourceResponse<IVideoSource | null>>;
+}
+
+export { AllAnime, Anilist, Animekai, Animepahe, Anizone, FlixHQ, type HIGenre, HiAnime, HiMovies, type IAnimeCategory, type IMetaFormat, type IMovieCountry, type IMovieGenre, Jikan, Kaido, Seasons };