import { AxiosRequestConfig } from 'axios';
import { Collection as Collection$1 } from '@freearhey/core';

type ModelData =
  | BlocklistRecordData
  | CategoryData
  | ChannelData
  | CityData
  | CountryData
  | FeedData
  | GuideData
  | LanguageData
  | LogoData
  | RegionData
  | StreamData
  | SubdivisionData
  | TimezoneData

type RawData = Record<string, ModelData[]>

type ProcessedData = {
  blocklist: Collection<BlocklistRecord>
  categories: Collection<Category>
  channels: Collection<Channel>
  cities: Collection<City>
  countries: Collection<Country>
  feeds: Collection<Feed>
  guides: Collection<Guide>
  languages: Collection<Language>
  logos: Collection<Logo>
  regions: Collection<Region>
  streams: Collection<Stream>
  subdivisions: Collection<Subdivision>
  timezones: Collection<Timezone>
}

declare class DataManager {
    #private;
    constructor(config?: {
        dataDir?: string;
    });
    downloadToDisk(config?: {
        request?: AxiosRequestConfig;
    }): Promise<void>;
    downloadFileToDisk(basename: string, requestConfig?: AxiosRequestConfig): Promise<unknown>;
    loadFromDisk(): Promise<void>;
    loadFileFromDisk(basename: string): Promise<object[]>;
    downloadToMemory(config?: {
        request?: AxiosRequestConfig;
    }): Promise<void>;
    loadFromMemory(): void;
    processData(): void;
    getProcessedData(): ProcessedData;
    getRawData(): RawData;
    setRawData(rawData: RawData): void;
}

declare class SearchEngine {
    static createIndex<Type>(items: Type[], searchable?: string[]): any;
}

type BlocklistRecordData$1 = {
  channel: string
  reason: string
  ref: string
}

type BroadcastAreaData = {
  codes: string[]
}

type BroadcastAreaLocationData = {
  code: string
}

type CategoryData$1 = {
  id: string
  name: string
  description: string
}

type ChannelSearchableData = {
  id: string
  name: string
  alt_names: string[]
  alt_name: string[]
  network: string
  owner: string[]
  owners: string[]
  country: string
  category: string[]
  categories: string[]
  launched: string
  closed: string
  replaced_by: string
  website: string
  is_nsfw: boolean
  is_closed: boolean
  is_blocked: boolean
  languages: string[]
  language: string[]
  broadcast_area: string[]
  streams: number
  guides: number
  feeds: number
  logos: number
  format: string[]
  formats: string[]
  timezone: string[]
  timezones: string[]
  _languageNames: string[]
  _broadcastAreaNames: string[]
  _countryName: string
  _guideSites: string[]
  _guideSiteNames: string[]
  _streamTitles: string[]
  _streamUrls: string[]
  _feedNames: string[]
  _feedAltNames: string[]
  _streamIds: string[]
  _logoUrls: string[]
}

type ChannelData$1 = {
  id: string
  name: string
  country: string
  alt_names: string[]
  network: string | null
  owners: string[]
  categories: string[]
  is_nsfw: boolean
  launched: string | null
  closed: string | null
  replaced_by: string | null
  website: string | null
}

type CityData$1 = {
  code: string
  name: string
  country: string
  subdivision?: string | null
  wikidata_id: string
}

type CountryData$1 = {
  code: string
  name: string
  languages: string[]
  flag: string
}

type FeedData$1 = {
  channel: string
  id: string
  name: string
  alt_names: string[]
  is_main: boolean
  broadcast_area: string[]
  languages: string[]
  timezones: string[]
  format: string
}

type GuideSource = {
  host: string
  url: string
  format: string
}

type GuideData$1 = {
  channel: string | null
  feed: string | null
  site: string
  site_id: string
  site_name: string
  lang: string
  sources: GuideSource[]
}

type LanguageData$1 = {
  code: string
  name: string
}

type LogoData$1 = {
  channel: string
  feed: string | null
  in_use: boolean
  tags: string[]
  width: number
  height: number
  format: string | null
  url: string
}

type RegionData$1 = {
  code: string
  name: string
  countries: string[]
}

type StreamData$1 = {
  channel: string | null
  feed: string | null
  title: string
  url: string
  referrer: string | null
  user_agent: string | null
  quality: string | null
  label: string | null
}

type SubdivisionData$1 = {
  code: string
  name: string
  country: string
  parent: string | null
}

type TimezoneData$1 = {
  id: string
  utc_offset: string
  countries: string[]
}

type index_d_BroadcastAreaData = BroadcastAreaData;
type index_d_BroadcastAreaLocationData = BroadcastAreaLocationData;
type index_d_ChannelSearchableData = ChannelSearchableData;
type index_d_GuideSource = GuideSource;
type index_d_ModelData = ModelData;
type index_d_ProcessedData = ProcessedData;
type index_d_RawData = RawData;
declare namespace index_d {
  export type { BlocklistRecordData$1 as BlocklistRecordData, index_d_BroadcastAreaData as BroadcastAreaData, index_d_BroadcastAreaLocationData as BroadcastAreaLocationData, CategoryData$1 as CategoryData, ChannelData$1 as ChannelData, index_d_ChannelSearchableData as ChannelSearchableData, CityData$1 as CityData, CountryData$1 as CountryData, FeedData$1 as FeedData, GuideData$1 as GuideData, index_d_GuideSource as GuideSource, LanguageData$1 as LanguageData, LogoData$1 as LogoData, index_d_ModelData as ModelData, index_d_ProcessedData as ProcessedData, index_d_RawData as RawData, RegionData$1 as RegionData, StreamData$1 as StreamData, SubdivisionData$1 as SubdivisionData, TimezoneData$1 as TimezoneData };
}

declare class BroadcastAreaLocation {
    /** Raw code of the location **/
    rawCode: string;
    /** Code of the location */
    code: string;
    /** Type of the location */
    type: string;
    constructor(data: BroadcastAreaLocationData);
    /** @returns Name of the location */
    getName(): string | undefined;
    /** @returns JSON version of all data */
    toJSON(): string;
    /** @returns JS object with all data */
    toObject(): BroadcastAreaLocationData;
}

declare class Category$1 {
    /** Category ID */
    id: string;
    /** Name of the category */
    name: string;
    /** Short description of the category */
    description: string;
    constructor(data: CategoryData$1);
    /** @returns JSON version of all data */
    toJSON(): string;
    /** @returns JS object with all data */
    toObject(): CategoryData$1;
}

declare class Language$1 {
    /** Language name */
    name: string;
    /** [ISO 639-3](https://en.wikipedia.org/wiki/ISO_639-3) code of the language */
    code: string;
    constructor(data: LanguageData$1);
    /** @returns JSON version of all data */
    toJSON(): string;
    /** @returns JS object with all data */
    toObject(): LanguageData$1;
}

declare class Subdivision$1 {
    /** [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) code of the country */
    country: string;
    /** Subdivision name */
    name: string;
    /** [ISO 3166-2](https://en.wikipedia.org/wiki/ISO_3166-2) code of the subdivision */
    code: string;
    /** [ISO 3166-2](https://en.wikipedia.org/wiki/ISO_3166-2) code of the parent subdivision */
    parent: string | null;
    constructor(data: SubdivisionData$1);
    /** @returns Country in which the subdivision is located */
    getCountry(): Country$1 | undefined;
    /** @returns Parent subdivision */
    getParent(): Subdivision$1 | undefined;
    /** @returns List of cities in which the subdivision is located */
    getCities(): Collection$1<City$1>;
    /** @returns List of regions in which the city is located */
    getRegions(): Collection$1<Region$1>;
    /** @returns JSON version of all data */
    toJSON(): string;
    /** @returns JS object with all data */
    toObject(): SubdivisionData$1;
}

declare class Region$1 {
    /** Code of the region */
    code: string;
    /** Full name of the region */
    name: string;
    /** List of countries in the region */
    countries: string[];
    constructor(data: RegionData$1);
    /** @returns List of regions related to the region */
    getRegions(): Collection$1<Region$1>;
    /** @returns List of country of the region */
    getCountries(): Collection$1<Country$1>;
    /** @returns List of subdivisions of the region */
    getSubdivisions(): Collection$1<Subdivision$1>;
    /** @returns List of cities of the region */
    getCities(): Collection$1<City$1>;
    /** @returns JSON version of all data */
    toJSON(): string;
    /** @returns JS object with all data */
    toObject(): RegionData$1;
}

declare class Country$1 {
    /** Name of the country */
    name: string;
    /** [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) code of the country */
    code: string;
    /** List of official language [ISO 639-3](https://en.wikipedia.org/wiki/ISO_639-3) codes of the country */
    languages: string[];
    /** Country flag emoji */
    flag: string;
    constructor(data: CountryData$1);
    /** @returns List of official languages of the country */
    getLanguages(): Collection$1<Language$1>;
    /** @returns List of channels broadcast from the country */
    getChannels(): Collection$1<Channel$1>;
    /** @returns List of regions that include the country */
    getRegions(): Collection$1<Region$1>;
    /** @returns List of subdivisions of the country */
    getSubdivisions(): Collection$1<Subdivision$1>;
    /** @returns List of cities of the country */
    getCities(): Collection$1<City$1>;
    /** @returns JSON version of all data */
    toJSON(): string;
    /** @returns JS object with all data */
    toObject(): CountryData$1;
}

declare class Timezone$1 {
    /** Timezone ID from [tz database](https://en.wikipedia.org/wiki/Tz_database) */
    id: string;
    /** [UTC offset](https://en.wikipedia.org/wiki/UTC_offset) for this time zone */
    utc_offset: string;
    /** List of country codes included in the time zone */
    countries: string[];
    constructor(data: TimezoneData$1);
    /** @returns List of countries included in the time zone */
    getCountries(): Collection$1<Country$1>;
    /** @returns JSON version of all data */
    toJSON(): string;
    /** @returns JS object with all data */
    toObject(): TimezoneData$1;
}

declare class Stream$1 {
    /** Channel ID */
    channel: string | null;
    /** Feed ID */
    feed: string | null;
    /** Stream title */
    title: string;
    /** Stream URL */
    url: string;
    /** The [Referer](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referer) request header for the stream */
    referrer: string | null;
    /** The [User-Agent](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/User-Agent) request header for the stream */
    user_agent: string | null;
    /** Maximum stream quality */
    quality: string | null;
    /** Specified in cases where the broadcast for some reason may not be available to some users */
    label: string | null;
    constructor(data: StreamData$1);
    /** @returns Stream ID */
    getId(): string;
    /** @returns Channel associated with the stream */
    getChannel(): Channel$1 | undefined;
    /** @returns Feed associated with the stream */
    getFeed(): Feed$1 | undefined;
    /** @returns List of codes describing the broadcasting area (`r/<region_code>`, `c/<country_code>`, `s/<subdivision_code>`, `ct/<city_code>`) */
    getBroadcastAreaCodes(): Collection$1<string>;
    /** @returns List of all categories of the stream */
    getCategories(): Collection$1<Category$1>;
    /** @returns List of all languages in which the stream is broadcast */
    getLanguages(): Collection$1<Language$1>;
    /** @returns List of logos for the stream */
    getLogos(): Collection$1<Logo$1>;
    /** @returns JSON version of all data */
    toJSON(): string;
    /** @returns JS object with all data */
    toObject(): StreamData$1;
}

declare class BroadcastArea {
    /** List of codes describing the broadcasting area (`r/<region_code>`, `c/<country_code>`, `s/<subdivision_code>`, `ct/<city_code>`) */
    codes: string[];
    constructor(data: BroadcastAreaData);
    /** @returns List of locations describing the broadcasting area */
    getLocations(): Collection$1<BroadcastAreaLocation>;
    /** @returns JSON version of all data */
    toJSON(): string;
    /** @returns JS object with all data */
    toObject(): BroadcastAreaData;
}

declare class Feed$1 {
    /** Channel ID */
    channel: string;
    /** Unique feed ID */
    id: string;
    /** Name of the feed */
    name: string;
    /** List of alternative feed names */
    alt_names: string[];
    /** Indicates if this feed is the main for the channel */
    is_main: boolean;
    /** List of codes describing the broadcasting area (`r/<region_code>`, `c/<country_code>`, `s/<subdivision_code>`, `ct/<city_code>`) */
    broadcast_area: string[];
    /** List of language codes in which the feed is broadcast */
    languages: string[];
    /** List of timezone IDs in which the feed is broadcast */
    timezones: string[];
    /** Video format of the feed */
    format: string;
    constructor(data: FeedData$1);
    /** @returns Stream ID for the feed */
    getStreamId(): string;
    /** @returns Full name of the feed */
    getFullName(): string;
    /** @returns Channel associated with the feed */
    getChannel(): Channel$1 | undefined;
    /** @returns List of streams for the feed */
    getStreams(): Collection$1<Stream$1>;
    /** @returns List of guides for the feed */
    getGuides(): Collection$1<Guide$1>;
    /** @returns List of languages in which the feed is broadcast */
    getLanguages(): Collection$1<Language$1>;
    /** @returns List of timezones in which the feed is broadcast */
    getTimezones(): Collection$1<Timezone$1>;
    /** @returns Broadcast area of the feed */
    getBroadcastArea(): BroadcastArea;
    /** @returns List of broadcast area codes of the feed */
    getBroadcastAreaCodes(): Collection$1<string>;
    /** @returns List of broadcast area locations of the feed */
    getBroadcastAreaLocations(): Collection$1<BroadcastAreaLocation>;
    /** @returns List of logos for the feed */
    getLogos(): Collection$1<Logo$1>;
    /** @returns JSON version of all data */
    toJSON(): string;
    /** @returns JS object with all data */
    toObject(): FeedData$1;
}

declare class Guide$1 {
    /** Channel ID */
    channel: string | null;
    /** Feed ID */
    feed: string | null;
    /** Site domain name */
    site: string;
    /** Unique channel ID used on the site */
    site_id: string;
    /** Channel name used on the site */
    site_name: string;
    /** Language of the guide ([ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) code) */
    lang: string;
    /** List of available sources of the guide */
    sources: GuideSource[];
    constructor(data: GuideData$1);
    /** @returns Channel associated with the guide */
    getChannel(): Channel$1 | undefined;
    /** @returns Feed associated with the guide */
    getFeed(): Feed$1 | undefined;
    /** @returns Stream ID for the guide */
    getStreamId(): string;
    /** @returns JSON version of all data */
    toJSON(): string;
    /** @returns JS object with all data */
    toObject(): GuideData$1;
}

declare class Logo$1 {
    /** Channel ID */
    channel: string;
    /** Feed ID */
    feed: string | null;
    /** Indicates whether the broadcaster is currently using this logo **/
    in_use: boolean;
    /** List of keywords describing this version of the logo */
    tags: string[];
    /** The width of the image in pixels */
    width: number;
    /** The height of the image in pixels */
    height: number;
    /** Image format (one of: `PNG`, `JPEG`, `SVG`, `GIF`, `WebP`, `AVIF`, `APNG`) */
    format: string | null;
    /** Logo URL */
    url: string;
    constructor(data: LogoData$1);
    /** @returns Channel associated with the logo */
    getChannel(): Channel$1 | undefined;
    /** @returns Feed associated with the logo */
    getFeed(): Feed$1 | undefined;
    /** @returns Stream ID for the logo */
    getStreamId(): string;
    /** @returns JSON version of all data */
    toJSON(): string;
    /** @returns JS object with all data */
    toObject(): LogoData$1;
}

declare class Channel$1 {
    /** Unique channel ID */
    id: string;
    /** Full name of the channel */
    name: string;
    /** List of alternative channel names */
    alt_names: string[];
    /** Name of the network operating the channel */
    network: string | null;
    /** List of channel owners */
    owners: string[];
    /** Country code from which the broadcast is transmitted ([ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2)) */
    country: string;
    /** List of categories to which this channel belongs */
    categories: string[];
    /** Indicates whether the channel broadcasts adult content */
    is_nsfw: boolean;
    /** Launch date of the channel (`YYYY-MM-DD`) */
    launched: string | null;
    /** Date on which the channel closed (`YYYY-MM-DD`) */
    closed: string | null;
    /** The ID of the channel that this channel was replaced by */
    replaced_by: string | null;
    /** Official website URL */
    website: string | null;
    constructor(data: ChannelData$1);
    /** @returns `true` if the channel is marked as "closed" */
    isClosed(): boolean;
    /** @returns `true` if the channel is on the blocklist */
    isBlocked(): boolean;
    /** @returns Country from which the channel is broadcasting */
    getCountry(): Country$1 | undefined;
    /** @returns List of all categories of the channel */
    getCategories(): Collection$1<Category$1>;
    /** @returns List of all feeds of the channel */
    getFeeds(): Collection$1<Feed$1>;
    /** @returns Main feed of the channel */
    getMainFeed(): Feed$1 | undefined;
    /** @returns List of broadcast area codes of the channel */
    getBroadcastAreaCodes(): Collection$1<string>;
    /** @returns List of broadcast area locations of the channel */
    getBroadcastAreaLocations(): Collection$1<BroadcastAreaLocation>;
    /** @returns List of all languages in which the channel is broadcast */
    getLanguages(): Collection$1<Language$1>;
    /** @returns List of all timezones in which the channel is broadcast */
    getTimezones(): Collection$1<Timezone$1>;
    /** @returns List of all video formats in which the channel is broadcast */
    getVideoFormats(): Collection$1<string>;
    /** @returns List of all available logos for the channel */
    getLogos(): Collection$1<Logo$1>;
    /** @returns List of all available streams for the channel */
    getStreams(): Collection$1<Stream$1>;
    /** @returns List of all available guides for the channel */
    getGuides(): Collection$1<Guide$1>;
    /** @returns List of records in the blocklist associated with the channel */
    getBlocklistRecords(): Collection$1<BlocklistRecord$1>;
    /** @returns Data used to search for the channel */
    getSearchable(): ChannelSearchableData;
    /** @returns JSON version of all data */
    toJSON(): string;
    /** @returns JS object with all data */
    toObject(): ChannelData$1;
}

declare class BlocklistRecord$1 {
    /** Channel ID */
    channel: string;
    /** Reason for blocking (`dmca` or `nsfw`) */
    reason: string;
    /** Link to removal request or DMCA takedown notice */
    ref: string;
    constructor(data: BlocklistRecordData$1);
    /** @returns Channel associated with this record in the blocklist */
    getChannel(): Channel$1 | undefined;
    /** @returns JSON version of all data */
    toJSON(): string;
    /** @returns JS object with all data */
    toObject(): BlocklistRecordData$1;
}

declare class City$1 {
    /** [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) code of the country where the city is located */
    country: string;
    /** [ISO 3166-2](https://en.wikipedia.org/wiki/ISO_3166-2) code of the subdivision where the city is located */
    subdivision: string | null;
    /** City name */
    name: string;
    /** [UN/LOCODE](https://en.wikipedia.org/wiki/UN/LOCODE) of the city */
    code: string;
    /** ID of this city in [Wikidata](https://www.wikidata.org/wiki/Wikidata:Main_Page) */
    wikidata_id: string;
    constructor(data: CityData$1);
    /** @returns Country in which the city is located */
    getCountry(): Country$1 | undefined;
    /** @returns Subdivision in which the city is located */
    getSubdivision(): Subdivision$1 | undefined;
    /** @returns List of regions in which the city is located */
    getRegions(): Collection$1<Region$1>;
    /** @returns JSON version of all data */
    toJSON(): string;
    /** @returns JS object with all data */
    toObject(): CityData$1;
}

type index_BroadcastArea = BroadcastArea;
declare const index_BroadcastArea: typeof BroadcastArea;
type index_BroadcastAreaLocation = BroadcastAreaLocation;
declare const index_BroadcastAreaLocation: typeof BroadcastAreaLocation;
declare namespace index {
  export {
    BlocklistRecord$1 as BlocklistRecord,
    index_BroadcastArea as BroadcastArea,
    index_BroadcastAreaLocation as BroadcastAreaLocation,
    Category$1 as Category,
    Channel$1 as Channel,
    City$1 as City,
    Country$1 as Country,
    Feed$1 as Feed,
    Guide$1 as Guide,
    Language$1 as Language,
    Logo$1 as Logo,
    Region$1 as Region,
    Stream$1 as Stream,
    Subdivision$1 as Subdivision,
    Timezone$1 as Timezone,
  };
}

declare class Client {
    #private;
    constructor(options?: {
        dataDir?: string;
    });
    load(): Promise<void>;
    getData(): ProcessedData;
    searchChannels(query: string): Collection$1<Channel$1>;
}

declare const _default: {
    Client: typeof Client;
};

export { Client, DataManager, index as Models, SearchEngine, index_d as Types, _default as default };