/**
 * Base options for API calls.
 */
interface BaseOptions extends hostOptions, debugOptions {
}
interface hostOptions {
    /**
     * The host to use for the API call (e.g., HostWs.streamlike).
     */
    host?: string;
}
interface debugOptions {
    /**
     * Enable debug logging in the console.
     */
    debug?: boolean;
}
/**
 * Represents a standardized response from a web service.
 * @template T The typePlayerId of the `data` property.
 */
interface WebserviceResponse<T = any> {
    status: number;
    info: string;
    data: T | null;
}
/**
 * Represents the structure of the response in a callback.
 * @template T The typePlayerId of the data being returned in the response.
 */
interface CallbackResponse<T = any> {
    res: boolean;
    data: T | null;
    errors: string | null;
}
/**
 * Represents the root response from the /ws/playlist endpoint.
 */
interface PlaylistResponse {
    playlist: Playlist;
}
/**
 * Represents the root response from the /ws/playlists endpoint.
 */
interface PlaylistsResponse {
    playlists: PlaylistItem[];
}
/**
 * Interface representing the response structure for a media callback.
 *
 * This interface is used to define the shape of the response returned from operations involving media callbacks.
 *
 * @property {boolean} res Indicates the success status of the media callback operation.
 * @property {Media | null} data Contains the media data if the operation is successful. If the operation fails, this will be null.
 * @property {string | null} errors Provides error details if the operation fails. If the operation is successful, this will be null.
 */
interface MediaCallbackResponse {
    res: boolean;
    data: Media | null;
    errors: string | null;
}
/**
 * Represents a playlist item in a structured format.
 *
 * Each playlist item contains details pertaining to a specific playlist,
 * including its metadata and associated attributes such as the playlist name,
 * description, language, total duration, and the viewing position.
 *
 * Properties:
 * - `playlist`: An object containing information about a playlist.
 *   - `playlist_id`: The unique identifier of the playlist.
 *   - `name`: The name of the playlist.
 *   - `description`: A brief description of the playlist.
 *   - `language`: The language of the playlist's content.
 *   - `total_duration`: The total duration of the playlist, typically in seconds.
 *   - `view_position`: A property indicating the viewing position or progress within the playlist.
 */
interface PlaylistItem {
    playlist: {
        [key: string]: string | number;
        playlist_id: string;
        name: string;
        description: string;
        language: string;
        total_duration: number;
        view_position: string;
    };
}
/**
 * Represents the main playlist object.
 */
interface Playlist {
    metadata: PlaylistMetadata;
    medias: MediaContainer[];
}
/**
 * Metadata for the playlist itself (e.g., total size).
 */
interface PlaylistMetadata {
    [key: string]: string | number | boolean | null | undefined;
    size: number;
    /**
     * Present, and `true`, only when the full-text backend was unavailable and the `query`
     * was not applied: the result is then wider than asked, never shorter. Absent otherwise.
     */
    degraded?: true;
    playlist_id?: string;
    name?: string;
    description?: string;
    total_duration?: number;
    view_position?: string;
}
/**
 * Wrapper object for a single media item within the 'medias' array.
 */
interface MediaContainer {
    media: Media;
}
/**
 * Represents a single media.
 */
interface Media {
    metadata: MediaMetadata;
    statistics: Statistics;
    /**
     * Absent on every media of an account that hides its file URLs — not a sign of a failed encoding.
     */
    html5_sources?: Html5SourceContainer[];
}
/**
 * Detailed metadata for a mediaParams item.
 */
interface MediaMetadata {
    global: GlobalMetadata;
    share: Share;
    keywords?: Keywords;
    customization: Customization;
    chapters?: ChapterContainer[];
    subtitles?: SubtitleContainer[];
    language_ids: Language[];
    playlists?: MediaPlaylistContainer[];
    /**
     * Search excerpts, on the medias of a `/ws/playlist?query=` result where the search matched, and on those alone.
     * Keys are the matched fields, e.g. `name.stemmed` or `description` (a list of strings, matches wrapped in `<em>`)
     * and `subtitle.<language>` (a list of `{timecode, text}`). Read it as a map, do not hard-code the keys.
     */
    highlight?: Highlight;
    /**
     * `/ws/related` only: number of keywords shared with the source media, which the results are ranked on.
     */
    relation_weight?: number;
}
/**
 * Search excerpts of a media matched by a `query`.
 */
interface Highlight {
    [field: string]: string[] | HighlightSubtitle[];
}
/**
 * A subtitle line matched by a `query`.
 */
interface HighlightSubtitle {
    timecode: number;
    text: string;
}
/**
 * Global metadata properties for a mediaParams item.
 */
interface GlobalMetadata {
    [key: string]: string | number | boolean | null | undefined;
    media_id: string;
    name: string;
    type: "video" | "audio" | string;
    permalink: string;
    status: "online" | string;
    description?: string;
    /**
     * Encoder that produced the files served today: `2` for the current encoding pipeline, `1` for the legacy encoder.
     * **Absent** — not `0`, not `null` — when the media publishes nothing (never encoded, a live, a first encoding
     * still running): never file an absent value under "legacy".
     */
    encoding_version?: 1 | 2;
    transcript?: string;
    duration: number;
    ratio: number;
    fps: number;
    creation_date: string;
    release_date: string;
    lastupdated_date: string;
    lastupdatedfile_date: string;
    lastplayback_date?: string;
    is_360: boolean;
    is_multiple_audio: boolean;
    is_tokenized: boolean;
    has_password: boolean;
    sourceExtension?: string;
    sourceWidth?: string;
    sourceFrameRate?: string;
    sourceHeight?: string;
    is_downloadable: boolean;
    is_secured: boolean;
    has_sound?: boolean;
    saMedIAnalyst?: string;
    PIN?: string;
}
/**
 * Sharing information for the mediaParams.
 */
interface Share {
    universal_url: string;
}
/**
 * Keyword container.
 */
interface Keywords {
    standard_keywords: StandardKeyword[];
}
/**
 * A single standard keyword.
 */
interface StandardKeyword {
    standard_keyword: string;
}
/**
 * Customization options (cover, mosaic, etc.).
 * An empty value is an absent key: the four cover sizes appear or disappear together.
 */
interface Customization {
    cover?: Cover;
    mosaic?: string;
    board?: Board;
}
/**
 * Cover image URLs.
 */
interface Cover {
    url: string;
    thumbnail_url: string;
    thumbnaillarge_url: string;
    thumbnailextralarge_url: string;
}
/**
 * Board URLs (often empty).
 */
interface Board {
    small_url: string;
    large_url: string;
}
/**
 * Wrapper for a chapter item.
 */
interface ChapterContainer {
    chapter: Chapter;
}
/**
 * Chapter details.
 */
interface Chapter {
    language_id: string;
    url: string;
}
/**
 * Wrapper for a subtitle item.
 */
interface SubtitleContainer {
    subtitle: Subtitle;
}
/**
 * Subtitle details.
 */
interface Subtitle {
    language_id: string;
    url: SubtitleUrls;
}
/**
 * URLs for different subtitle formats.
 */
interface SubtitleUrls {
    dfxp: string;
    vtt: string;
    srt: string;
    m3u8: string;
    words?: string;
}
/**
 * Wrapper for a language ID.
 */
interface Language {
    language_id: string;
}
/**
 * Wrapper for a playlist reference within a mediaParams item.
 */
interface MediaPlaylistContainer {
    playlist: MediaPlaylist;
}
/**
 * Details of a playlist that the mediaParams belongs to.
 */
interface MediaPlaylist {
    name: string;
    playlist_id: string;
    type: "public" | string;
    position: number;
}
/**
 * Statistics for the mediaParams item.
 */
interface Statistics {
    media_access: number;
    rating_hits: number;
    rating_totalvalue: number;
}
/**
 * Wrapper for an HTML5 source.
 */
interface Html5SourceContainer {
    html5_source: Html5Source;
}
/**
 * HTML5 source details.
 */
interface Html5Source {
    type: string;
    manifest: string;
}
/**
 * Represents the response from the /ws/resume endpoint.
 */
interface ResumeResponse {
    resume: Resume;
}
/**
 * Contains the resume timecode.
 * Always present, an integer number of seconds. It is the furthest second reached during the most
 * recent session of the `user_token` on the media — not where playback stopped — looked up over the
 * last month only. `0` covers three situations you cannot tell apart: the token was never seen, the
 * viewer watched more than a month ago, or they really are at the beginning.
 */
interface Resume {
    timecode: number;
}

/**
 * Fetches data from the specified web service URL and returns a structured response object.
 *
 * @param {string} url - The URL of the web service to fetch data from.
 * @param {boolean} [debug=false] - A flag to enable error logging in case of network request failure.
 * @return {Promise<WebserviceResponse>} A promise that resolves with the web service response including status, info, and data.
 */
declare function getWs<T>(url: string, debug?: boolean): Promise<WebserviceResponse<T>>;

/**
 * Defines the query parameters for company-related endpoints.
 */
interface MandatoryCompanyParams {
    /**
     * The ID of the company to filter by.
     */
    company_id: string;
}
/**
 * Defines the query parameters for company-related endpoints.
 */
interface MandatoryMediaParams {
    /**
     * The ID of the company to filter by.
     */
    media_id: string;
}
/**
 * Base options for API calls.
 */
interface ViewParams {
    /**
     * View filter.
     */
    view_id?: string;
}
/**
 * Base options for API calls.
 */
interface FormatParam {
    /**
     * Webservice output format.
     */
    f?: 'json' | 'xml';
}
/**
 * Defines common pagination parameters for API requests.
 */
interface PaginationParams {
    /**
     * The page number to retrieve.
     * {range min: 0}
     */
    page?: number;
    /**
     * The number of items per page.
     * {range min: 1}
     */
    pagesize?: number;
}
/**
 * Defines possible sort orders.
 */
declare enum SortOrder {
    Up = "up",
    Down = "down"
}
declare enum OrderByPlaylist {
    ID = "id",
    NAME = "name",
    DURATION = "duration",
    VOTE = "vote",
    HIT = "hit",
    LAST_PLAYBACK_DATE = "lastplaybackdate",
    CREATION_DATE = "creationdate",
    LAST_UPDATE_DATE = "lastupdateddate",
    LAST_UPDATED_FILE_DATE = "lastupdatedfiledate",
    RELEASE_DATE = "releasedate",
    POSITION = "position"
}
declare enum OrderByPlaylists {
    ID = "id",
    NAME = "name",
    CREATION_DATE = "creationdate",
    POSITION = "position"
}
/**
 * Defines common sorting parameters for API requests.
 */
interface SortingParams {
    /**
     * The field to order by (e.g., 'releasedate').
     */
    orderby?: OrderByPlaylist | OrderByPlaylists | string;
    /**
     * The sort direction.
     */
    sortorder?: SortOrder;
}

interface MediaParams extends FormatParam {
    media_id?: string;
    permalink?: string;
}

/**
 * Fetches media content from the specified web service (WS) endpoint using
 * the provided parameters and options. This method requires either a `media_id`
 * or a `permalink` in the `params` to identify the media.
 *
 * @param {MediaParams} [params={}] The parameters object that must include either
 * a `media_id` or a `permalink` to identify the media resource.
 * @param {BaseOptions} [options={}] Additional options which can include a debug flag.
 * @return {Promise<CallbackResponse<MediaContainer | null>>} A promise that resolves
 * to the media content wrapped in a callback response or `null` if not found.
 */
declare function getWsMedia(params?: MediaParams, options?: BaseOptions): Promise<CallbackResponse<MediaContainer | null>>;
/**
 * Retrieves media information based on the provided media ID.
 *
 * @param {string} id - The unique identifier for the media to retrieve.
 * @param {MediaParams} [params={}] - Optional parameters for the media query.
 * @param {BaseOptions} [options={}] - Optional configuration options, such as debug mode.
 * @return {Promise<MediaContainer | null>} Returns a promise that resolves to the media container object if found, or null if not found.
 */
declare function getMediaFromId(id: string, params?: MediaParams, options?: BaseOptions): Promise<MediaContainer | null>;
/**
 * Retrieves media information from a given permalink.
 *
 * @param {string} permalink - The permalink of the media to be retrieved.
 * @param {MediaParams} [params] - Optional parameters for the media request.
 * @param {BaseOptions} [options] - Optional base options including debug settings.
 * @return {Promise<MediaContainer | null>} A promise that resolves with the media container if found, or null if no media is found.
 */
declare function getMediaFromPermalink(permalink: string, params?: MediaParams, options?: BaseOptions): Promise<MediaContainer | null>;
/**
 * Fetches and retrieves media metadata based on provided parameters and options.
 *
 * @param {MediaParams} [params={}] - The parameters to filter or specify the media query.
 * @param {BaseOptions} [options={}] - Additional options for the request, such as debug mode.
 * @return {Promise<MediaMetadata|null>} A Promise resolving to the media metadata or null if no metadata is found.
 */
declare function getMediaMetadata(params?: MediaParams, options?: BaseOptions): Promise<MediaMetadata | null>;
/**
 * Fetches media statistics based on the provided parameters and configuration options.
 *
 * @param {MediaParams} [params={}] - The parameters used to filter or identify the media for which statistics are required.
 * @param {BaseOptions} [options={}] - Additional options including debug configuration.
 * @return {Promise<Statistics | null>} - A promise that resolves to media statistics or null if not available.
 */
declare function getMediaStatistics(params?: MediaParams, options?: BaseOptions): Promise<Statistics | null>;

/**
 * Defines the query parameters for the /ws/countries endpoint.
 */
interface CountriesParams extends ViewParams, MandatoryCompanyParams, FormatParam {
}
/**
 * Represents a single country object as returned by the /ws/countries endpoint.
 */
interface Country {
    country_id: string;
}
/**
 * Represents the structure of the data object
 * in the successful response from /ws/countries.
 */
interface CountriesResponse {
    country_ids: Country[];
}
/**
 * Defines the query parameters for the /ws/countries endpoint.
 */
interface LanguagesParams extends ViewParams, MandatoryCompanyParams, FormatParam {
}
/**
 * Represents the structure of the data object
 * in the successful response from /ws/languages.
 */
interface LanguagesResponse {
    language_ids: Language[];
}
interface NowPlayingParams extends MandatoryMediaParams, FormatParam {
}
interface ResumeParams extends MandatoryMediaParams, FormatParam {
    /**
     * Your own identifier for the viewer, the same value passed to the player as `user_token=`
     * for positions to be recorded at all. It is the only identity checked: keep it unguessable.
     */
    user_token: string;
}
/**
 * Represents the response from the /ws/nowplaying endpoint.
 */
interface NowPlayingResponse {
    nowplaying: NowPlaying;
}
/**
 * Represents the count of viewers.
 */
interface NowPlaying {
    count: number;
}

/**
 * Retrieves a list of countries based on the provided parameters and options.
 *
 * @param {CountriesParams} params - The parameters used to filter the list of countries.
 * @param {BaseOptions} [options] - Optional settings such as debug mode or additional configurations.
 * @return {Promise<CallbackResponse<CountriesResponse | null>>} A promise that resolves to the response containing country data or null.
 */
declare function getWsCountries(params: CountriesParams, options?: BaseOptions): Promise<CallbackResponse<CountriesResponse | null>>;
/**
 * Fetches the list of available languages from the given endpoint.
 *
 * @param {LanguagesParams} params - Parameters required to fetch the languages.
 * @param {BaseOptions} [options] - Optional settings such as debug mode or additional configurations.
 * @return {Promise<CallbackResponse<LanguagesResponse | null>>} A promise that resolves to the response containing
 *         the list of languages or null if no languages are returned.
 */
declare function getWsLanguages(params: LanguagesParams, options?: BaseOptions): Promise<CallbackResponse<LanguagesResponse | null>>;
/**
 * Fetches the currently playing track information from the `/ws/nowplaying` endpoint.
 *
 * @param {NowPlayingParams} params - The parameters required to fetch the now playing data.
 * @param {BaseOptions} [options] - Optional configuration options for the request, such as debug mode.
 * @return {Promise<CallbackResponse<NowPlayingResponse | null>>} A promise that resolves to the now playing data wrapped in a callback response, or null if no data is available.
 */
declare function getWsNowPlaying(params: NowPlayingParams, options?: BaseOptions): Promise<CallbackResponse<NowPlayingResponse | null>>;
/**
 * Fetches the resume data from the specified endpoint with given parameters and options.
 *
 * @param {ResumeParams} params - The parameters required for building the resume request.
 * @param {BaseOptions} [options] - Optional configuration options, such as debug settings.
 * @return {Promise<CallbackResponse<ResumeResponse | null>>} A promise that resolves to the resume response, or null if no data is available.
 */
declare function getWsResume(params: ResumeParams, options?: BaseOptions): Promise<CallbackResponse<ResumeResponse | null>>;

/**
 * Defines the query parameters for the /ws/playlist endpoint
 * based on the OpenAPI specification.
 * Extends common pagination and sorting parameters.
 * orderby choice values  : ["id","name","duration","vote","hit","lastplaybackdate","creationdate","lastupdateddate","lastupdatedfiledate","releasedate","position"]
 */
interface PlaylistParams extends PaginationParams, SortingParams, ViewParams {
    /**
     * Filter by country code.
     */
    country?: string;
    /**
     * Filter mediaParams encoded or not.
     */
    encoded?: boolean;
    /**
     * Keep only the medias filed in at least one playlist (`true` / `1`), dropping those filed nowhere.
     * Redundant with `playlist_id`, which already implies it.
     * Webservices 5.20 and later: before that, `0` and `1` were read inverted — send `true` / `false`
     * if the target server may be older.
     */
    forceplaylist?: boolean | 0 | 1 | 'true' | 'false';
    /**
     * Filter on the encoder that published the media's files: `2` keeps only the medias published by
     * the current encoding pipeline, `1` only those published by the legacy encoder, absent does not filter.
     * A media publishing nothing (never encoded, live, first encoding running) is returned by neither value.
     * Webservices 5.20 and later.
     */
    encoding_version?: 1 | 2;
    /**
     * `1` keeps only the medias carrying several audio tracks, `0` only single-track ones, absent does not filter.
     * Webservices 5.20 and later — earlier servers accept it and ignore it.
     */
    multiple_audio?: 0 | 1;
    /**
     * Filter by language code (e.g., 'en', 'fr').
     */
    lng?: string;
    /**
     * Exclude mediaParams associated with these country codes.
     */
    not_countries?: string[];
    /**
     * Exclude mediaParams associated with these language codes.
     */
    not_languages?: string[];
    /**
     * Exclude these mediaParams IDs from the result.
     */
    not_media_ids?: string[];
    /**
     * Exclude mediaParams belonging to these playlist IDs.
     */
    not_playlist_ids?: string[];
    /**
     * Exclude mediaParams belonging to these view IDs.
     */
    not_view_ids?: string[];
    /**
     * A search query string.
     */
    query?: string;
    /**
     * Fields to include in the search (e.g., 'name', 'description').
     */
    search_fields?: string[];
    /**
     * Filter by company ID.
     */
    company_id?: string;
    /**
     * Filter by view ID.
     */
    view_id?: string;
    /**
     * Filter by playlist ID.
     * Note: getWsPlaylist() also accepts string[] for the main `id` argument,
     * but the query parameter in the spec is listed as string.
     */
    playlist_id?: string;
}

/**
 * Fetches the playlist data using the provided parameters.
 *
 * @param {PlaylistParams} params - The parameters required for fetching the playlist. Must include at least one of: company_id, view_id, or playlist_id.
 * @param {BaseOptions} [options={}] - Optional configuration for the request, including debug mode.
 * @return {Promise<CallbackResponse<PlaylistResponse | null>>} - A promise that resolves to the response containing the playlist data or null.
 * @throws {Error} - Throws an error when none of the identifier parameters are provided in `params`.
 */
declare function getWsPlaylist(params: PlaylistParams, options?: BaseOptions): Promise<CallbackResponse<PlaylistResponse | null>>;
/**
 * Retrieves the size of a playlist based on the provided parameters.
 *
 * @param {PlaylistParams} params - The parameters to identify the playlist, which can include `company_id`, `view_id`, or `playlist_id`.
 * @param {BaseOptions} options - Additional options for the function execution, such as debug settings.
 * @return {Promise<number>} A promise that resolves to the size of the playlist.
 * @throws {Error} Throws an error if no identifier parameter is provided or if the response is invalid.
 */
declare function getPlaylistSize(params?: PlaylistParams, options?: BaseOptions): Promise<number>;
/**
 * Retrieves a list of media items from a specified playlist.
 *
 * @param {string} id - The unique identifier of the playlist to retrieve media from.
 * @param {PlaylistParams} [params={}] - Optional parameters to customize the playlist retrieval query.
 * @param {BaseOptions} [options={}] - Optional configurations for the request, such as debug settings.
 * @return {Promise<MediaContainer[]>} A promise that resolves to an array of media items contained in the specified playlist.
 * @throws Will throw an error if the response is invalid or an unexpected error occurs.
 */
declare function getMediasFromPlaylist(id: string, params?: PlaylistParams, options?: BaseOptions): Promise<MediaContainer[]>;
/**
 * Fetches medias belonging to a specific company by its ID using the provided parameters and options.
 *
 * @param {string} id - The unique identifier of the company whose medias are to be fetched.
 * @param {PlaylistParams} [params={}] - The parameters to refine or customize the media retrieving query.
 * @param {BaseOptions} [options={}] - Additional options such as debug settings for the request.
 * @return {Promise<MediaContainer[]>} A promise that resolves to a list of media containers associated with the specified company.
 */
declare function getMediasFromCompany(id: string, params?: PlaylistParams, options?: BaseOptions): Promise<MediaContainer[]>;
/**
 * Fetches the media items from a specific view based on the provided identifier and parameters.
 *
 * @param {string} id - The identifier of the view from which to retrieve media items.
 * @param {PlaylistParams} [params={}] - Optional parameters to customize the playlist request.
 * @param {BaseOptions} [options={}] - Optional base options, such as debug flag, for additional configurations.
 * @return {Promise<MediaContainer[]>} A promise that resolves to an array of MediaContainer objects.
 */
declare function getMediasFromView(id: string, params?: PlaylistParams, options?: BaseOptions): Promise<MediaContainer[]>;

interface PlaylistsParams extends MandatoryCompanyParams, PaginationParams, SortingParams, ViewParams, FormatParam {
}

/**
 * Fetches playlists for a specific company based on provided parameters.
 *
 * @param {PlaylistsParams} params - The parameters required to fetch playlists, including the company identifier.
 * @param {BaseOptions} [options={}] - Optional configurations for the request, such as debug mode.
 * @return {Promise<CallbackResponse<PlaylistsResponse | null>>} A promise resolving to the list if playlists or null.
 */
declare function getWsPlaylists(params: PlaylistsParams, options?: BaseOptions): Promise<CallbackResponse<PlaylistsResponse | null>>;
/**
 * Retrieves a list of playlists based on the given parameters.
 *
 * @param {PlaylistsParams} params - The parameters for fetching playlists.
 * @param {BaseOptions} [options={}] - Optional configuration options. Includes a debug flag for console debugging.
 * @return {Promise<PlaylistItem[]>} A promise that resolves to an array of PlaylistItem objects.
 */
declare function getPlaylists(params: PlaylistsParams, options?: BaseOptions): Promise<PlaylistItem[]>;

interface RelatedParams extends PaginationParams, ViewParams, FormatParam {
    media_id: string;
}

/**
 * Fetches related media data from the /ws/related endpoint.
 *
 * @param {RelatedParams} params - Parameters required to fetch related media. Must include the media_id.
 * @param {BaseOptions} [options={}] - Optional configuration options such as debug mode.
 * @return {Promise<CallbackResponse<MediaContainer[] | null>>} - A promise that resolves with the response data, which includes an array of media containers or null if none are found.
 * @throws {Error} - Throws an error if the media_id parameter is missing.
 */
declare function getWsRelated(params: RelatedParams, options?: BaseOptions): Promise<CallbackResponse<MediaContainer[] | null>>;

declare enum MosaicSize {
    Small = "small",
    Large = "large"
}
declare enum PreviewMode {
    Scrubbing = "scrubbing",
    Animation = "animation",
    Fixed = "fixed"
}
declare enum FitMode {
    Cover = "cover",
    Contain = "contain"
}
/**
 * Where the timing of a word, or of a whole words file, comes from.
 * - `asr`: timed by the speech engine,
 * - `aligned` (file level only): the subtitles were corrected, the untouched words keep their engine timing,
 * - `estimated`: interpolated, no engine timing at all (e.g. an imported SRT).
 */
type WordsSource = 'asr' | 'aligned' | 'estimated';
/**
 * One word of a transcript, with its timing in seconds.
 */
interface Word {
    start: number;
    end: number;
    word: string;
    /**
     * Legacy flag of the words files written before September 2026.
     */
    punctuation?: string | boolean | number;
    /**
     * Trailing punctuation mark of the word, `""` when none. Files written from September 2026.
     */
    mark?: string;
    /**
     * Where the timing of this word comes from. Files written from September 2026.
     */
    source?: WordsSource;
}
/**
 * The words file of a subtitle track as served since September 2026.
 * Older files are a bare `Word[]`; `generateWords` accepts both.
 */
interface WordsFile {
    source: WordsSource;
    language: string;
    words: Word[];
}
/**
 * Data returned by `generateWords` on success.
 */
interface WordsResult {
    wordsCount: number;
    /**
     * File-level source, `undefined` on a legacy list-shaped file.
     */
    source?: WordsSource;
    /**
     * Language of the track, `undefined` on a legacy list-shaped file.
     */
    language?: string;
}
interface TranscriptOptions {
    wordsContainer: string | HTMLElement;
    iframePlayer: string | HTMLIFrameElement;
    debug?: boolean;
    autoScroll?: boolean;
    messages: {
        loading: string;
        error: string;
    };
}
interface MosaicFrame {
    url: string;
    x: number;
    y: number;
    width: number;
    height: number;
}
interface InteractivePreviewOptions extends debugOptions {
    mode?: PreviewMode;
    duration?: number;
    fps?: number;
    mosaicSize?: MosaicSize;
    fitMode?: {
        cover?: FitMode;
        animation?: FitMode;
    };
}
/**
 * Represents the URLs for different cover image sizes.
 */
interface CoverUrls {
    url: string;
    thumbnail_url: string;
    thumbnaillarge_url: string;
    thumbnailextralarge_url: string;
}
/**
 * Represents the URLs for different board sizes.
 */
interface BoardUrls {
    small_url: string;
    large_url: string;
}
/**
 * Represents mediaParams customization options including cover images and mosaic/board configurations.
 */
interface MediaCustomization {
    /**
     * Absent when the media has no cover: the four sizes appear or disappear together.
     */
    cover?: CoverUrls;
    mosaic?: string;
    board?: BoardUrls;
}
interface TrimmerOptions {
    duration: number;
    startInput: string | HTMLInputElement;
    endInput: string | HTMLInputElement;
    currentTimeInput: string | HTMLInputElement;
    mediaUrl?: string;
    mediaId?: string;
    mediaCustomization?: MediaCustomization;
    aspectRatio?: number;
    initialStart?: number;
    initialEnd?: number;
    playButton?: string | HTMLElement;
    stopButton?: string | HTMLElement;
    debug?: boolean;
    baseOptions?: BaseOptions;
}

/**
 * Generates an interactive thumbnail preview for a given target element. Depending on the mode,
 * it allows for either scrubbing through frames or playing an animated preview. The frames are
 * fetched and displayed based on the provided media customization and options.
 *
 * @param {string | HTMLElement} target - The target element or its ID where the thumbnail will be displayed.
 * @param {MediaCustomization} mediaCustomization - Configuration object containing media details such as cover image and board URL.
 * @param {InteractivePreviewOptions} options - Options for customizing the preview behavior such as mode, duration, frames per second, and debugging.
 * @return {Promise<CallbackResponse>} Returns a promise that resolves with a response object containing whether the operation was successful, data details, or errors if any.
 */
declare function generateThumbnail(target: string | HTMLElement, mediaCustomization: MediaCustomization, options: InteractivePreviewOptions): Promise<CallbackResponse>;

/**
 * Fetches transcript data and generates clickable/highlightable word spans in a container.
 * This function also sets up event listeners to sync with playerParams progress.
 *
 * @param url The URL of the 'words' JSON file.
 * @param options Configuration options including target containers and the playerParams iframeParams.
 * @returns A promise that resolves with a cleanup function to remove event listeners.
 */
declare function generateWords(url: string, options: TranscriptOptions): Promise<{
    cleanup: () => void;
} & CallbackResponse<WordsResult>>;

/**
 * Generates an interactive trimmer inside a target element.
 */
declare function generateTrimmer(target: string | HTMLElement, options: TrimmerOptions): Promise<CallbackResponse>;

/**
 * Represents types of identifiers used for mediaParams.
 */
declare enum TypePlayerId {
    media = "media",
    permalink = "permalink",
    live = "live",
    streamout = "str_id"
}
/**
 * Represents the options for configuring an iframe.
 *
 * This interface is used to specify various configurable parameters
 * for an iframe, including player-related options, permissions, and
 * additional iframe settings.
 *
 * Properties:
 * - `typePlayerId` (optional): Specifies the type of player identifier to be used.
 * - `playerParams` (optional): Provides configuration options for the player.
 * - `iframeParams` (optional): Allows defining specific iframe settings, such as:
 *    - `allowfullscreen`: Determines whether fullscreen mode is allowed.
 *    - `allowautoplay`: Indicates whether autoplay of content is permitted.
 *    - `onLoad`: A callback function to handle iframe load events.
 * - `baseOptions` (optional): Includes additional base configuration options applicable to the iframe.
 */
interface IframeOptions {
    typePlayerId?: TypePlayerId;
    playerParams?: PlayerParams;
    iframeParams?: IframeParams;
    baseOptions?: BaseOptions;
}
/**
 * Settings applied to the generated `<iframe>` element itself.
 *
 * Properties:
 * - `allowfullscreen` (optional): Determines whether fullscreen mode is allowed.
 * - `allowautoplay` (optional): Indicates whether autoplay of content is permitted.
 * - `onLoad` (optional): A callback function to handle iframe load events.
 */
interface IframeParams {
    allowfullscreen?: boolean;
    allowautoplay?: boolean;
    onLoad?: () => void;
}
/**
 * Interface representing the parameters for a player configuration.
 * This interface defines a wide range of optional properties that can be
 * used to customize the behavior and appearance of a media player.
 */
interface PlayerParams {
    /**
     * Encrypted media ID
     * @default -
     * @streamlive no
     * @streamout no
     */
    med_id?: string;
    /**
     * Permalink
     * @default -
     * @streamlive no
     * @streamout no
     */
    permalink?: string;
    /**
     * Live ID or "stream name"
     * @default -
     * @streamlive yes
     * @streamout no
     */
    live_id?: string;
    /**
     * Encrypted streamout ID
     * @default -
     * @streamlive no
     * @streamout yes
     */
    str_id?: string;
    /**
     * Changes the color of all "active" elements of the player (progress bar, active buttons...).
     * Sets an HTML color, without the #. Ex: FF01F8
     * @default -
     * @streamlive yes
     * @streamout no
     */
    active_color?: string;
    /**
     * Automatic media start
     * @default false
     * @streamlive yes
     * @streamout no
     */
    autostart?: boolean;
    /**
     * Switches to the lowest available quality if a video is playing but is not visible
     * @default false
     * @streamlive yes
     * @streamout yes
     */
    background_audio?: boolean;
    /**
     * Change the background color behind the video and post it.
     * Sets an HTML color, without the #. Ex: FF01F8
     * @default -
     * @streamlive yes
     * @streamout yes
     */
    background_color?: string;
    /**
     * Only in combination with a background_color. Override of the opacity parameter of the background color.
     * 0: transparent, 100: opaque
     * @default 100
     * @streamlive yes
     * @streamout yes
     */
    background_opacity?: number;
    /**
     * Change the color of overlaid buttons.
     * Set an HTML color, without the #. Ex: FF01F8
     * @default FFFFFF
     * @streamlive yes
     * @streamout yes
     */
    buttons_color?: string;
    /**
     * Force language or disable the display of chapters.
     * Ex: chapter=en or chapter=0
     * @default 1
     * @streamlive no
     * @streamout no
     */
    chapter?: string;
    /**
     * Show or disable chapter thumbnails
     * @default true
     * @streamlive no
     * @streamout no
     */
    chapters_usethumb?: boolean;
    /**
     * Display or not the player controls
     * @default true
     * @streamlive yes
     * @streamout no
     */
    controls?: boolean;
    /**
     * URL of the image to use for the cover, or boolean to enable / disable
     * @default 1
     * @streamlive yes
     * @streamout no
     */
    cover?: string;
    /**
     * Displays a download button for the highest quality transcoding /
     * displays a download button while setting the maximum bitrate for the transcoding that can be downloaded
     * @default 0
     * @streamlive no
     * @streamout no
     */
    download?: number | string;
    /**
     * Enables or disables the ability to control the player from outside the iframe
     * @default false
     * @streamlive yes
     * @streamout no
     */
    events?: boolean;
    /**
     * Enables or disables the playback mode that fills the entire browser window.
     * In this mode, parts of the video may become hidden but it is not distorted.
     * @default false
     * @streamlive yes
     * @streamout yes
     */
    fill_browser?: boolean;
    /**
     * Selects only the best quality stream (MP4 only)
     * @default false
     * @streamlive no
     * @streamout no
     */
    forcehd?: boolean;
    /**
     * Enable or disable fullscreen
     * @default true
     * @streamlive yes
     * @streamout yes
     */
    fs?: boolean;
    /**
     * Enable or disable Fullscreen
     * @default true
     * @streamlive yes
     * @streamout yes
     */
    fullscreen?: boolean;
    /**
     * Positions the icons panel to the right or left or completely hides the icons panel
     * @default right
     * @streamlive yes
     * @streamout no
     */
    icons_position?: "right" | "left" | "none";
    /**
     * Displays the title / description / credits block.
     * A "nometa" value of 1 disables this option
     * @default false
     * @streamlive yes
     * @streamout no
     */
    infos?: boolean | string;
    /**
     * Limits the quality of available videos for inline playback only (not in full screen mode),
     * by specifying a maximum bitrate (in Kbps). Both engines honour it; in Safari for macOS a capped
     * media is served by `hlsjs` whatever `player` says.
     * @default -
     * @streamlive yes
     * @streamout yes
     */
    inline_throttling?: number;
    /**
     * Force language or disable the display of interactions.
     * Ex: interaction=en or interaction=0
     * @default 1
     * @streamlive no
     * @streamout no
     */
    interaction?: string;
    /**
     * Disables all interface elements (buttons, controls, panel ...)
     * @default true
     * @streamlive yes
     * @streamout no
     */
    interface?: boolean;
    /**
     * Displays the cover image and a clickable logo instead of the player.
     * The player is loaded after clicking on the image.
     * @default false
     * @streamlive no
     * @streamout no
     */
    landing?: boolean;
    /**
     * Accepted for compatibility; the current player does not read it. The rewind window comes from
     * the live itself: about 45 minutes when it was created with `live[dvr]=true` through the API,
     * about 100 seconds otherwise (the API default is `false` since API 5.30).
     * @default true
     * @streamlive yes
     * @streamout no
     */
    live_dvr?: boolean | string;
    /**
     * Shows or hides the logo
     * @default true
     * @streamlive yes
     * @streamout yes
     */
    logo?: boolean;
    /**
     * Overriding the transparency parameter, only if the logo is set from a logo_url parameter
     * Value between 0 and 100
     * @default 100
     * @streamlive yes
     * @streamout yes
     */
    logo_alpha?: number;
    /**
     * Applies the logo referenced by its ID
     * @default -
     * @streamlive yes
     * @streamout yes
     */
    logo_id?: number | string;
    /**
     * Makes the logo clickable and opens the url in a new window
     * @default -
     * @streamlive yes
     * @streamout yes
     */
    logo_link?: string;
    /**
     * Position parameter override (r: right, t: top, b: bottom, l: left),
     * only if the logo is set from a logo_url parameter
     * @default rt
     * @streamlive yes
     * @streamout yes
     */
    logo_position?: "lb" | "lt" | "rt" | "rb";
    /**
     * Overrides the URL of the logo image
     * @default -
     * @streamlive yes
     * @streamout yes
     */
    logo_url?: string;
    /**
     * Looping the media
     * @default false
     * @streamlive no
     * @streamout no
     */
    loop?: boolean;
    /**
     * Sets a width limit on the transcodes that are made available for adaptative streaming.
     * When combined with inline_throttling, the most stringent rule prevails
     * @default -
     * @streamlive yes
     * @streamout yes
     */
    max_width?: number;
    /**
     * Sets a height limit on the transcodes that are made available for adaptative streaming.
     * When combined with inline_throttling, the most stringent rule prevails
     * @default -
     * @streamlive yes
     * @streamout yes
     */
    max_height?: number;
    /**
     * Shows or disables mosaic
     * @default true
     * @streamlive no
     * @streamout no
     */
    mosaic?: boolean;
    /**
     * Mutes the media
     * @default false
     * @streamlive yes
     * @streamout yes
     */
    muted?: boolean;
    /**
     * Removes meta tags in the head (title, descriptions, keywords, og ...)
     * @default false
     * @streamlive yes
     * @streamout yes
     */
    nometa?: boolean;
    /**
     * Disables sharing meta tags on social networks (included in nometa)
     * @default false
     * @streamlive yes
     * @streamout yes
     */
    nosharemeta?: boolean;
    /**
     * Adds a clickable button to display the current number of playbacks
     * @default false
     * @streamlive yes
     * @streamout no
     */
    nowplaying?: boolean;
    /**
     * Encrypted ID of the player setting to apply to the media
     * @default company default
     * @streamlive yes
     * @streamout yes
     */
    pid?: string | boolean;
    /**
     * Shows or hides the central "play" button.
     * @default true
     * @streamlive yes
     * @streamout no
     */
    play_button?: boolean;
    /**
     * Displays the button to change the playback speed of the media
     * @default false
     * @streamlive no
     * @streamout no
     */
    playback_speed?: boolean;
    /**
     * Forces the playback engine. `videojs` is accepted as an alias of `hlsjs`.
     * Ignored in three cases, where only one engine can do the job: a live always plays on `theo`
     * (a streamout whose schedule holds a live too), `background_audio=1` always plays on `hlsjs`,
     * and a quality-capped media (`throttling`, `inline_throttling`, `max_width`, `max_height`)
     * always plays on `hlsjs` in Safari for macOS. Without the parameter, Safari (macOS, iOS, iPadOS)
     * gets `theo` and other browsers follow the player settings, `hlsjs` by default.
     * @default hlsjs
     * @streamlive yes
     * @streamout yes
     */
    player?: "hlsjs" | "theo" | "videojs";
    /**
     * Preloads the media
     * @default false
     * @streamlive no
     * @streamout no
     */
    preload?: boolean;
    /**
     * Blocks the click on the player
     * @default false
     * @streamlive yes
     * @streamout no
     */
    prevent_click?: boolean;
    /**
     * Displays a grid of media sharing common keywords and belonging to the same view
     * @default false
     * @streamlive no
     * @streamout no
     */
    related?: string;
    /**
     * Displays the button to report inappropriate content
     * @default false
     * @streamlive yes
     * @streamout no
     */
    report?: boolean;
    /**
     * Shows or hides the share block
     * @default false
     * @streamlive yes
     * @streamout no
     */
    share?: boolean;
    /**
     * Uncrypted ID of the skin to use
     * @default -
     * @streamlive yes
     * @streamout no
     */
    skin?: string;
    /**
     * Shows or hides the slider
     * @default true
     * @streamlive no
     * @streamout no
     */
    slider?: boolean;
    /**
     * When token security is enabled, must contain the access token created by the API
     * String (32 characters)
     * @default -
     * @streamlive yes
     * @streamout yes
     */
    sltoken?: string;
    /**
     * List of IDs of authorized IP groups, separated by commas
     * String (32 characters)
     * @default -
     * @streamlive yes
     * @streamout yes
     */
    sltoken_ip_ids?: string;
    /**
     * List of IDs of authorized referrers, separated by commas
     * String (32 characters)
     * @default -
     * @streamlive yes
     * @streamout yes
     */
    sltoken_referrer_ids?: string;
    /**
     * Validity duration of the token, in seconds
     * @default -
     * @streamlive yes
     * @streamout yes
     */
    sltoken_duration?: string;
    /**
     * Position (in seconds) where to start the video
     * @default 0
     * @streamlive no
     * @streamout no
     */
    streamlike_mp_starttc?: number;
    /**
     * Forces language or disables subtitle display.
     * Ex: subtitle=fr or subtitle=0
     * @default 1
     * @streamlive no
     * @streamout yes
     */
    subtitle?: string;
    /**
     * Forces the language or disables the search in the subtitles.
     * Ex: subtitle_deep_links=en or subtitle_deep_links=0
     * @default 1
     * @streamlive no
     * @streamout no
     */
    subtitle_deep_links?: string;
    /**
     * Height of the font in em
     * @default -
     * @streamlive no
     * @streamout yes
     */
    subtitles_size?: number | string;
    /**
     * Uncrypted ID of the skin to use
     * @default -
     * @streamlive no
     * @streamout no
     */
    swfskin?: string;
    /**
     * Position where to start the video.
     * Formats accepted: hh:mm:ss.000 or shorter
     * @default 0
     * @streamlive no
     * @streamout no
     */
    t?: string | number;
    /**
     * Position where to start the video.
     * Formats accepted: hh:mm:ss.000 or shorter
     * @default 0
     * @streamlive no
     * @streamout no
     */
    tc?: string | number;
    /**
     * Limits the quality of available videos by specifying a maximum bitrate (in Kbps);
     * Sets a minimum quality threshold if the value is negative
     * @default -
     * @streamlive yes
     * @streamout yes
     */
    throttling?: number;
    /**
     * Position where to start the video.
     * Formats accepted: hh:mm:ss.000 or shorter
     * @default 0
     * @streamlive no
     * @streamout no
     */
    timecode?: string | number;
    /**
     * Removes the controls and the play button and forces autoplay.
     * Interactions remain visible but not clickable.
     * Default setting that cannot be modified for a streamout
     * @default false
     * @streamlive yes
     * @streamout no
     */
    tv?: boolean;
    /**
     * Transcript
     */
    transcript?: boolean;
    /**
     * Identify a particular user by permanently assigning him/her the same token
     * String (64 characters)
     * @default -
     * @streamlive yes
     * @streamout yes
     */
    user_token?: string;
    /**
     * Volume adjustment from 0.0 to 1.0
     * @default 1.0
     * @streamlive yes
     * @streamout yes
     */
    volume?: number | boolean;
    /**
     * Audio medias: shows the interactive waveform skin drawn from the media's sound. `false` restores
     * the cover display, `true` forces the skin on a media that carries an uploaded cover.
     * No effect when the media has no peaks file.
     * @default true
     * @streamlive no
     * @streamout no
     */
    waveform?: boolean;
    /**
     * Accent color of the waveform skin, an HTML color without the `#` (e.g. `FF01F8`); the background
     * shade is derived from it. Left unset, the account's `waveform_color` preference applies, then
     * the platform teal.
     * @default 44B0A7
     * @streamlive no
     * @streamout no
     */
    waveform_color?: string;
}

/**
 * Placement of the playlist navigation list relative to the player.
 */
declare enum PlaylistListPosition {
    Right = "right",
    Left = "left",
    Bottom = "bottom",
    Top = "top"
}
/**
 * Toggles for the information displayed next to the player while a media is playing.
 * Every entry maps to an element with a dedicated CSS class (see `classPrefix`),
 * so the final integrator can restyle or hide any of them.
 */
interface PlaylistPlayerInfoOptions {
    /**
     * Media name. Class: `{prefix}-info-title`
     * @default true
     */
    title?: boolean;
    /**
     * Media description. Class: `{prefix}-info-description`
     * @default false
     */
    description?: boolean;
    /**
     * Playlist name. Class: `{prefix}-info-playlist`
     * @default false
     */
    playlistName?: boolean;
    /**
     * Rank of the media in the playlist (e.g. "3 / 12"). Class: `{prefix}-info-position`
     * @default true
     */
    position?: boolean;
    /**
     * Total duration of the current media. Class: `{prefix}-info-duration`
     * @default true
     */
    duration?: boolean;
    /**
     * Live playback position, updated while playing. Class: `{prefix}-info-currenttime`
     * @default false
     */
    currentTime?: boolean;
    /**
     * Release date of the media. Class: `{prefix}-info-date`
     * @default false
     */
    releaseDate?: boolean;
    /**
     * Time of day (hours and minutes) of the release date. Class: `{prefix}-info-time`
     * @default false
     */
    releaseTime?: boolean;
    /**
     * Playback count of the media. Class: `{prefix}-info-views`
     * @default false
     */
    views?: boolean;
    /**
     * Standard keywords. Classes: `{prefix}-info-keywords` / `{prefix}-info-keyword`
     * @default false
     */
    keywords?: boolean;
}
/**
 * Toggles for the information displayed on each entry of the playlist list.
 * `duration`, `releaseDate`, `releaseTime` and `views` are gathered, in that
 * order, in a `{prefix}-item-meta` row displayed under the title.
 */
interface PlaylistPlayerListItemOptions {
    /**
     * Cover image of the media. Class: `{prefix}-item-thumbnail`
     * @default true
     */
    thumbnail?: boolean;
    /**
     * Replaces the static cover by an interactive preview (see `generateThumbnail`).
     * Pass the preview options to enable it.
     * @default undefined
     */
    interactiveThumbnail?: InteractivePreviewOptions;
    /**
     * Rank of the media in the playlist. Class: `{prefix}-item-index`
     * @default true
     */
    index?: boolean;
    /**
     * Media name. Class: `{prefix}-item-title`
     * @default true
     */
    title?: boolean;
    /**
     * Media duration. Class: `{prefix}-item-duration`
     * @default true
     */
    duration?: boolean;
    /**
     * Release date of the media. Class: `{prefix}-item-date`
     * @default false
     */
    releaseDate?: boolean;
    /**
     * Time of day (hours and minutes) of the release date. Class: `{prefix}-item-time`
     * @default false
     */
    releaseTime?: boolean;
    /**
     * Playback count of the media. Class: `{prefix}-item-views`
     * @default false
     */
    views?: boolean;
    /**
     * Media description. Class: `{prefix}-item-description`
     * @default false
     */
    description?: boolean;
}
/**
 * Texts used by the playlist player, for localization purposes.
 */
interface PlaylistPlayerLabels {
    /** @default "Previous" */
    previous?: string;
    /** @default "Next" */
    next?: string;
    /** @default "Loading…" */
    loading?: string;
    /** @default "This playlist is empty." */
    empty?: string;
    /** @default "Unable to load the playlist." */
    error?: string;
    /** @default "views" */
    views?: string;
    /** @default "medias" */
    medias?: string;
    /** Label of the button loading the next medias. @default "Load more" */
    more?: string;
    /** Label of the fullscreen button. @default "Fullscreen" */
    fullscreen?: string;
    /** Label of the fullscreen button while in fullscreen. @default "Exit fullscreen" */
    exitFullscreen?: string;
    /** Label of the floating button while the information is shown. @default "Hide information" */
    hideInfo?: string;
    /** Label of the floating button while the video is alone. @default "Show information" */
    showInfo?: string;
    /**
     * Message shown when a media cannot be played: missing token, or an IP /
     * referrer restriction that does not pass.
     * @default "Secured media"
     */
    secured?: string;
}
/**
 * Query parameter names used to build and read a "share at timecode" URL.
 */
interface PlaylistPlayerShareParams {
    /**
     * Reads `media` and `timecode` from the current page URL to select the
     * starting media and position. Values given through `startMediaId` /
     * `startTimecode` take precedence.
     * @default false
     */
    enabled?: boolean;
    /**
     * Name of the query parameter holding the media id.
     * @default "media"
     */
    media?: string;
    /**
     * Name of the query parameter holding the start position (in seconds).
     * @default "t"
     */
    timecode?: string;
}
/**
 * Configuration of {@link generatePlaylistPlayer}.
 *
 * One source of medias is required: `playlistId`, `viewId`, `companyId` or a
 * pre-fetched `medias` array.
 */
interface PlaylistPlayerOptions {
    /**
     * Playlist ID to read the medias from.
     */
    playlistId?: string;
    /**
     * View ID to read the medias from.
     */
    viewId?: string;
    /**
     * Company ID to read the medias from.
     */
    companyId?: string;
    /**
     * Already fetched medias. When provided, no API call is made.
     */
    medias?: MediaContainer[];
    /**
     * Extra parameters (ordering, filters) forwarded to `/ws/playlist`.
     * @default { orderby: OrderByPlaylist.POSITION, sortorder: SortOrder.Up }
     */
    playlistParams?: PlaylistParams;
    /**
     * Number of medias fetched per request. The list starts with one page, then
     * grows: the next page is fetched when playback approaches the end of the
     * loaded medias, and a "load more" button appears while some remain.
     * Defaults to `playlistParams.pagesize` when set.
     * @default 10
     */
    pageSize?: number;
    /**
     * Number of loaded medias still ahead below which the next page is fetched.
     * With the default page size, reaching the 9th media loads the next ten.
     * @default 2
     */
    prefetchThreshold?: number;
    /**
     * ID of the media to start with. Falls back to the first media of the playlist.
     */
    startMediaId?: string;
    /**
     * Position where the first media starts. Accepts seconds or `hh:mm:ss.mmm`.
     */
    startTimecode?: number | string;
    /**
     * Starts playing as soon as the player is ready.
     * @default false
     */
    autostart?: boolean;
    /**
     * Starts playing automatically when navigating to another media.
     * @default true
     */
    autoplayOnChange?: boolean;
    /**
     * Plays the next media when the current one ends.
     * @default true
     */
    autoNext?: boolean;
    /**
     * Goes back to the first media after the last one.
     * @default false
     */
    loop?: boolean;
    /**
     * Hides the medias that cannot be played, that is the tokenized ones with
     * no password: they are removed from the list and from the counts.
     *
     * Set it to `false` to keep them visible: their cover is displayed in the
     * list and in place of the player, along with the `labels.secured` message
     * and a button to jump to the next media.
     *
     * Two cases are never hidden, since they remain playable: a tokenized media
     * protected by a password (the player prompts for it), and a media secured
     * by IP or referrer.
     *
     * For those restricted medias the player URL is probed (a HEAD request,
     * `/play` answers a 404 when the access does not pass), so the message and
     * the button appear only when playback really fails.
     * @default true
     */
    hideTokenized?: boolean;
    /**
     * Displays the navigable list of the playlist medias.
     * @default true
     */
    showList?: boolean;
    /**
     * Displays the previous / next controls.
     * @default true
     */
    showControls?: boolean;
    /**
     * Adds a fullscreen button that puts the whole player — media, information,
     * controls and list — in fullscreen, and **keeps it there when the media
     * changes**.
     *
     * That is the point of the option. The player's own fullscreen button acts
     * inside the iframe, whose document is destroyed each time another media is
     * loaded, so the browser leaves fullscreen at every change. Here the element
     * put in fullscreen is the container, which survives the swap.
     *
     * Enabling it therefore hides the fullscreen button of the embedded player
     * (`playerParams.fs` and `playerParams.fullscreen` are forced to `false`),
     * so the only path offered is the one that holds.
     *
     * Not supported on iPhone, where Safari only knows how to put a native video
     * element in fullscreen: the button is left out there.
     * @default false
     */
    fullscreen?: boolean;
    /**
     * Key toggling the information while in fullscreen, so the media can be left
     * alone on screen. Set to `false` to bind nothing.
     *
     * The shortcut only answers while the player holds the fullscreen, and only
     * when the focus is in the page: a click inside the player sends the
     * keystrokes to its iframe, out of reach of any page.
     * @default "i"
     */
    toggleInfoKey?: string | false;
    /**
     * Where the list is rendered relative to the player.
     * @default PlaylistListPosition.Right
     */
    listPosition?: PlaylistListPosition;
    /**
     * Information displayed while a media is playing.
     */
    info?: PlaylistPlayerInfoOptions;
    /**
     * Information displayed on each entry of the list.
     */
    listItem?: PlaylistPlayerListItemOptions;
    /**
     * Texts used by the player.
     */
    labels?: PlaylistPlayerLabels;
    /**
     * Locale used to format dates and numbers.
     * @default browser locale
     */
    locale?: string;
    /**
     * Prefix of every generated CSS class, allowing full restyling.
     * @default "sl-playlist"
     */
    classPrefix?: string;
    /**
     * Injects the default stylesheet. Set to `false` to style everything yourself.
     * @default true
     */
    injectStyles?: boolean;
    /**
     * Parameters of the embedded player. `events` is always forced to `true`.
     */
    playerParams?: PlayerParams;
    /**
     * Settings of the generated iframe.
     */
    iframeParams?: IframeParams;
    /**
     * Query parameter names used by `getShareUrl()`.
     */
    shareParams?: PlaylistPlayerShareParams;
    /**
     * Called each time the played media changes.
     */
    onMediaChange?: (media: Media, index: number) => void;
    /**
     * Called when the last media of the playlist ends (and `loop` is disabled).
     */
    onPlaylistEnd?: () => void;
    /**
     * Enables debug logging.
     * @default false
     */
    debug?: boolean;
    /**
     * Global options (host, debug) used for the API calls and the player URL.
     */
    baseOptions?: BaseOptions;
}
/**
 * Data returned once the playlist player is ready.
 */
interface PlaylistPlayerData {
    /**
     * Medias handled by the player, in playing order.
     */
    medias: MediaContainer[];
    /**
     * Metadata of the playlist, when it was fetched from the API.
     */
    playlist: PlaylistMetadata | null;
    /**
     * Index of the media the player started on.
     */
    index: number;
}
/**
 * Playback controller returned by {@link generatePlaylistPlayer}.
 */
interface PlaylistPlayerController extends CallbackResponse<PlaylistPlayerData> {
    /**
     * Resumes playback of the current media.
     */
    play: () => void;
    /**
     * Pauses the current media.
     */
    pause: () => void;
    /**
     * Seeks the current media to the given position (in seconds).
     */
    seek: (timecode: number) => void;
    /**
     * Plays the next media. Returns false when there is none.
     */
    next: () => boolean;
    /**
     * Plays the previous media. Returns false when there is none.
     */
    previous: () => boolean;
    /**
     * Plays the media at the given index, optionally at a given position.
     */
    playIndex: (index: number, timecode?: number | string) => boolean;
    /**
     * Plays the media matching the given id, optionally at a given position.
     */
    playMedia: (mediaId: string, timecode?: number | string) => boolean;
    /**
     * Index of the media currently loaded.
     */
    getCurrentIndex: () => number;
    /**
     * Media currently loaded.
     */
    getCurrentMedia: () => Media | null;
    /**
     * Medias currently loaded, in playing order. The array grows as further
     * pages are fetched.
     */
    getMedias: () => MediaContainer[];
    /**
     * Total number of medias in the playlist, loaded or not.
     */
    getTotal: () => number;
    /**
     * Fetches the next page of medias and appends it to the list. Resolves to
     * false when nothing was added (everything is loaded, or the request failed).
     */
    loadMore: () => Promise<boolean>;
    /**
     * Last playback position reported by the player, in seconds.
     */
    getCurrentTime: () => number;
    /**
     * Tells whether the player currently holds the fullscreen.
     */
    isFullscreen: () => boolean;
    /**
     * Enters or leaves fullscreen, or forces one of the two when `force` is
     * given. Works whatever `options.fullscreen`, which only governs the button.
     *
     * Entering must be called from a user gesture (a click handler), otherwise
     * the browser refuses it. Resolves to the state actually reached, so a
     * refusal — an unsupported browser, a missing gesture — reads as `false`.
     */
    toggleFullscreen: (force?: boolean) => Promise<boolean>;
    /**
     * Tells whether the media is currently alone on screen.
     */
    isVideoOnly: () => boolean;
    /**
     * Hides everything but the media — information, controls and list — or
     * brings it all back, and returns the state reached. Only shows in
     * fullscreen, where the rules apply; leaving fullscreen resets it.
     */
    toggleVideoOnly: (force?: boolean) => boolean;
    /**
     * Builds a shareable URL pointing to the current media, at the current
     * position by default.
     */
    getShareUrl: (options?: {
        timecode?: number | boolean;
        url?: string;
    }) => string;
    /**
     * Removes the listeners and empties the container.
     */
    destroy: () => void;
}

/**
 * Generates a playlist player: an embedded player that plays every media of an
 * ordered playlist, with previous / next controls, a clickable list of the
 * medias, and a configurable information panel.
 *
 * The medias can be fetched from a playlist, a view or a company id, or passed
 * directly through `options.medias`. A media id and a timecode can be provided
 * (`startMediaId` / `startTimecode`, or the share query parameters) so a shared
 * link starts on the right media at the right position.
 *
 * Every generated element carries a class built from `options.classPrefix`
 * (`sl-playlist` by default), so the final integrator can fully restyle the UI.
 *
 * @param {string | HTMLElement} target - The container element or its id.
 * @param {PlaylistPlayerOptions} options - Playlist source, playback and display options.
 * @return {Promise<PlaylistPlayerController>} A promise resolving to a playback controller.
 */
declare function generatePlaylistPlayer(target: string | HTMLElement, options: PlaylistPlayerOptions): Promise<PlaylistPlayerController>;

/**
 * Creates a responsive player iframe and injects it into the given container.
 * The container is emptied first and gets the requested aspect ratio.
 *
 * @param {HTMLElement} container - The element that will host the iframe.
 * @param {string} src - The player URL to load.
 * @param {number} ratio - The aspect ratio (width / height) applied to the container.
 * @param {IframeParams & {id?: string}} [params] - Iframe settings (permissions, load callback, element id).
 * @param {boolean} [debug=false] - Enables debug logging.
 * @return {HTMLIFrameElement} The created iframe element.
 */
declare function embedPlayerIframe(container: HTMLElement, src: string, ratio: number, params?: IframeParams & {
    id?: string;
}, debug?: boolean): HTMLIFrameElement;
/**
 * Configures and embeds a responsive iframe into the specified target element.
 * The iframe adapts its dimensions based on a specified or default aspect ratio.
 *
 * @param {string} id - The identifier of the media or content to be displayed in the iframe.
 * @param {string|HTMLElement} target - The target container where the iframe will be embedded.
 * It can be a DOM element or the ID of an element as a string.
 * @param {IframeOptions} [options] - Optional configuration for the iframe, including player parameters, iframe settings, and base options.
 * @return {Promise<Media>} A promise that resolves to a MediaCallbackResponse object, indicating success, data, or errors encountered during the process.
 */
declare function setResponsiveIframe(id: string, target: string | HTMLElement, options?: IframeOptions): Promise<MediaCallbackResponse>;

declare const SDK_VERSION = "3.9.0";

export { type BaseOptions, type Board, type CallbackResponse, type Chapter, type ChapterContainer, type CountriesParams, type CountriesResponse, type Country, type Cover, type Customization, FitMode, type FormatParam, type GlobalMetadata, type Highlight, type HighlightSubtitle, type Html5Source, type Html5SourceContainer, type IframeOptions, type IframeParams, type InteractivePreviewOptions, type Keywords, type Language, type LanguagesParams, type LanguagesResponse, type MandatoryCompanyParams, type MandatoryMediaParams, type Media, type MediaCallbackResponse, type MediaContainer, type MediaCustomization, type MediaMetadata, type MediaParams, type MediaPlaylist, type MediaPlaylistContainer, type MosaicFrame, MosaicSize, type NowPlaying, type NowPlayingParams, type NowPlayingResponse, OrderByPlaylist, OrderByPlaylists, type PaginationParams, type PlayerParams, type Playlist, type PlaylistItem, PlaylistListPosition, type PlaylistMetadata, type PlaylistParams, type PlaylistPlayerController, type PlaylistPlayerData, type PlaylistPlayerInfoOptions, type PlaylistPlayerLabels, type PlaylistPlayerListItemOptions, type PlaylistPlayerOptions, type PlaylistPlayerShareParams, type PlaylistResponse, type PlaylistsParams, type PlaylistsResponse, PreviewMode, type RelatedParams, type Resume, type ResumeParams, type ResumeResponse, SDK_VERSION, type Share, SortOrder, type SortingParams, type StandardKeyword, type Statistics, type Subtitle, type SubtitleContainer, type SubtitleUrls, type TranscriptOptions, type TrimmerOptions, TypePlayerId, type ViewParams, type WebserviceResponse, type Word, type WordsFile, type WordsResult, type WordsSource, type debugOptions, embedPlayerIframe, generatePlaylistPlayer, generateThumbnail, generateTrimmer, generateWords, getMediaFromId, getMediaFromPermalink, getMediaMetadata, getMediaStatistics, getMediasFromCompany, getMediasFromPlaylist, getMediasFromView, getPlaylistSize, getPlaylists, getWs, getWsCountries, getWsLanguages, getWsMedia, getWsNowPlaying, getWsPlaylist, getWsPlaylists, getWsRelated, getWsResume, type hostOptions, setResponsiveIframe };