import { Handler } from 'mitt';

export declare type AdBlockCompletePlayerEvent = IAdBlock | undefined;

export declare type AdBlockStartPlayerEvent = IAdBlock;

declare interface AdClip {
    category?: AdClipCategory;
    duration?: number;
    impressionUrlTemplates?: string[];
    title?: string;
    titleId?: string;
    trackingEvents?: AdTrackingEvents;
    videoClicks?: AdVideoClicks;
}

declare const AdClipCategory: {
    readonly AD: "ad";
    readonly VOD: "vod";
};

declare type AdClipCategory = (typeof AdClipCategory)[keyof typeof AdClipCategory];

declare interface AdMarker {
    duration?: string;
    id?: string;
    offset?: number;
    type?: string;
}

export declare type AdPlayerEvent = IAdDataRepresentation;

declare interface Ads {
    adMarkers?: AdMarker[];
    clips?: AdClip[];
    insertionDuration?: number;
    insertionMaxCount?: number;
    stitcher: AdStitcher;
    stitcherSession?: string;
    tenantId?: string;
}

declare const AdStitcher: {
    readonly GENERIC: "GENERIC";
    readonly INTERNAL: "INTERNAL";
    readonly NOWTILUS: "NOWTILUS";
};

declare type AdStitcher = (typeof AdStitcher)[keyof typeof AdStitcher];

declare type AdTrackingEvents = Record<"complete" | "firstQuartile" | "midpoint" | "thirdQuartile", string[]>;

declare interface AdVideoClicks {
    clickThroughUrl?: string;
    clickTrackingUrls?: string[];
}

export declare type AllEvent<T> = EventHelper<T>[keyof EventHelper<T>];

declare type AllEventHandler<T> = (event: AllEvent<T>) => void;

declare interface Analytics {
    baseUrl?: string;
    bucket?: number;
    percentage?: number;
    postInterval?: number;
    tag?: string;
}

declare interface AnonymousSessionResponse {
    /** The ISO 8601 time when the session expires. */
    expirationDateTime: string;
    /** The (bearer) session token to use in subsequent requests. */
    sessionToken: string;
}

declare interface Asset {
    assetFeatures?: SystemTag[];
    assetId: string;
    audioTracks: string[];
    changed: string;
    channelFeatures?: ("VIRTUAL" | "VC_CURATED" | "VC_PERSONALIZED" | "VC_SCHEDULED" | "EPG")[];
    collections: CollectionReference[];
    created: string;
    cuePoints: MarkerPoint[];
    customData: JsonNode;
    defaultAudioTrack?: string;
    duration: number;
    episode?: string;
    event?: Event_2;
    expires?: string;
    externalReferences: ExternalReference[];
    linkedEntities: LinkedEntity[];
    live: boolean;
    localized: LocalizedData[];
    markerPoints: MarkerPoint[];
    markers: Marker[];
    materialType?: AssetMaterialType;
    medias?: Media[];
    originalTitle?: string;
    overlayWidgets?: OverlayWidget[];
    parentalRatings: ParentalRating[];
    participants: Person[];
    popularityScores?: Record<string, string>;
    productionCountries: string[];
    productionYear?: number;
    program?: Program;
    programs?: Program[];
    publications: Publication[];
    rating?: number;
    releaseDate?: string;
    runtime?: number;
    season?: string;
    seasonId?: string;
    seasons?: Season[];
    seoData?: LocalizedSeoData[];
    slugs: string[];
    spokenLanguages: string[];
    studio?: string;
    subtitles: string[];
    tags: Tag[];
    trackSizes?: TrackSizes;
    tvShow?: TvShowInfo;
    tvShowId?: string;
    type: AssetType;
}

declare const AssetMaterialType: {
    readonly LOW_LATENCY_CHANNEL: "LOW_LATENCY_CHANNEL";
};

declare type AssetMaterialType = (typeof AssetMaterialType)[keyof typeof AssetMaterialType];

declare interface AssetRights {
    activation?: string;
    airplayBlocked?: boolean;
    amcDebugLogEnabled?: boolean;
    analyticsEnabled?: boolean;
    downloadBlocked?: boolean;
    downloadMaxSecondsAfterDownload?: number;
    downloadMaxSecondsAfterPlay?: number;
    expiration?: string;
    ffEnabled?: boolean;
    fourGBlocked?: boolean;
    hdmiblocked?: boolean;
    jailbrokenBlocked?: boolean;
    locationEnabled?: boolean;
    maxAds?: number;
    maxBitrate?: number;
    maxDownloadCount?: number;
    maxFileSize?: number;
    maxPlayPosition?: number;
    maxResHeight?: number;
    maxResWidth?: number;
    minBitrate?: number;
    minPlayPosition?: number;
    playCount?: number;
    rwEnabled?: boolean;
    sessionShiftEnabled?: boolean;
    streamingBlocked?: boolean;
    threeGBlocked?: boolean;
    wifiBlocked?: boolean;
}

declare const AssetType: {
    readonly AD: "AD";
    readonly CLIP: "CLIP";
    readonly COLLECTION: "COLLECTION";
    readonly EPISODE: "EPISODE";
    readonly EVENT: "EVENT";
    readonly LIVE_EVENT: "LIVE_EVENT";
    readonly MOVIE: "MOVIE";
    readonly OTHER: "OTHER";
    readonly PODCAST: "PODCAST";
    readonly PODCAST_EPISODE: "PODCAST_EPISODE";
    readonly TV_CHANNEL: "TV_CHANNEL";
    readonly TV_SHOW: "TV_SHOW";
};

declare type AssetType = (typeof AssetType)[keyof typeof AssetType];

declare interface AudioTrackInfo {
    language?: string;
    trackInfoList?: TrackInfo[];
}

declare type AuthLoginOptions = {
    username: string;
    password: string;
};

declare interface BasePlayerState {
    playbackState: PlaybackState;
    contentType?: ContentType | null;
    mediaType?: MediaType;
    currentTime: number;
    duration: number;
    seekable: Seekable;
    utcCurrentTime: number;
    utcDuration: number;
    utcSeekable: Seekable;
    currentAd?: IAdDataRepresentation | null;
    adMarkers?: IAdBlockMarker[];
    contentMarkers?: MarkerPoint[];
    volume: number;
    subtitleTrack: Track | null;
    subtitleTracks: Track[];
    audioTrack: Track | null;
    audioTracks: Track[];
    qualityLevel: QualityLevel;
    qualityLevels: QualityLevel[];
    droppedFrames: number;
    bufferingEvents: number;
    hasStarted: boolean;
    isMuted: boolean;
    isLive: boolean;
    isSeekable: boolean;
    isAtLiveEdge: boolean;
}

export declare type BitrateChangedPlayerEvent = {
    bitrate: number;
    width: number;
    height: number;
};

declare type Bookmarks = Record<"lastViewedOffset" | "liveTime", number>;

export declare type CastPlayerEvent = {
    currentTime?: number;
};

declare type CDN = Record<"host" | "profile" | "provider", string>;

declare interface ChannelAsset {
    asset: Asset;
    endTime: string;
    startTime: string;
}

declare interface CollectionReference {
    collectionId?: string;
}

export declare const ContentType: {
    readonly VOD: "vod";
    readonly LIVE: "live";
    readonly AD: "ad";
    readonly PODCAST: "podcast";
};

export declare type ContentType = (typeof ContentType)[keyof typeof ContentType];

declare interface ContractRestrictions {
    airplayEnabled?: boolean;
    ffEnabled?: boolean;
    maxBitrate?: number;
    maxResHeight?: number;
    minBitrate?: number;
    rwEnabled?: boolean;
    timeshiftEnabled?: boolean;
}

declare type CorePlayerEventsMap = {
    [PlayerEvents.PLAY]: DefaultPlayerEvent;
    [PlayerEvents.PAUSE]: DefaultPlayerEvent;
    [PlayerEvents.STOP]: DefaultPlayerEvent;
    [PlayerEvents.START]: StartPlayerEvent;
    [PlayerEvents.RESUME]: DefaultPlayerEvent;
    [PlayerEvents.PLAYING]: DefaultPlayerEvent;
    [PlayerEvents.SEEKING]: DefaultPlayerEvent;
    [PlayerEvents.SEEK_TIME_CHANGE]: DefaultPlayerEvent;
    [PlayerEvents.SEEKED]: DefaultPlayerEvent;
    [PlayerEvents.TIME_UPDATE]: DefaultPlayerEvent;
    [PlayerEvents.ENDED]: DefaultPlayerEvent;
    [PlayerEvents.VOLUME_CHANGE]: VolumeChangePlayerEvent;
    [PlayerEvents.ERROR]: ErrorPlayerEvent;
    [PlayerEvents.CAST_ERROR]: ErrorPlayerEvent;
    [PlayerEvents.LOADING]: LoadingPlayerEvent;
    [PlayerEvents.LOADED]: LoadedPlayerEvent;
    [PlayerEvents.LOAD_START]: undefined;
    [PlayerEvents.BUFFERING]: DefaultPlayerEvent;
    [PlayerEvents.BUFFERED]: DefaultPlayerEvent;
    [PlayerEvents.ID3]: DefaultPlayerEvent;
    [PlayerEvents.BITRATE_CHANGED]: BitrateChangedPlayerEvent;
    [PlayerEvents.CDN_CHANGED]: DefaultPlayerEvent;
    [PlayerEvents.AUDIO_CHANGED]: TrackChangedPlayerEvent;
    [PlayerEvents.SUBTITLE_CHANGED]: TrackChangedPlayerEvent;
    [PlayerEvents.LICENSE_EXPIRED]: DefaultPlayerEvent;
    [PlayerEvents.DROPPED_FRAMES]: DroppedFramesPlayerEvent;
    [PlayerEvents.DRM_UPDATE]: DrmUpdatePlayerEvent;
    [PlayerEvents.STATE_CHANGED]: CoreStateChangedPlayerEvent;
    [PlayerEvents.PROGRAM_CHANGED]: ProgramChangedPlayerEvent;
    [PlayerEvents.NOT_ENTITLED]: LiveAsset;
    [PlayerEvents.BLACKOUT]: LiveAsset;
    [PlayerEvents.EMPTY_SLOT]: undefined;
    [PlayerEvents.CAST_START]: CastPlayerEvent;
    [PlayerEvents.CAST_STOP]: CastPlayerEvent;
    [PlayerEvents.AIRPLAY_START]: undefined;
    [PlayerEvents.AIRPLAY_STOP]: undefined;
    [PlayerEvents.AD_START]: AdPlayerEvent;
    [PlayerEvents.AD_COMPLETE]: AdPlayerEvent;
    [PlayerEvents.ADBLOCK_START]: AdBlockStartPlayerEvent;
    [PlayerEvents.ADBLOCK_COMPLETE]: AdBlockCompletePlayerEvent;
    [PlayerEvents.INTRO_START]: MarkerPlayerEvent;
    [PlayerEvents.INTRO_END]: MarkerPlayerEvent;
    [PlayerEvents.CHAPTER_START]: MarkerPlayerEvent;
    [PlayerEvents.CHAPTER_END]: MarkerPlayerEvent;
    [PlayerEvents.MARKER]: MarkerPlayerEvent;
    [PlayerEvents.METADATA_EVENT]: DefaultPlayerEvent;
    [PlayerEvents.SESSION_ACQUIRED]: undefined;
    [PlayerEvents.PLAYER_SETUP_COMPLETED]: undefined;
    [PlayerEvents.ENTITLEMENT_GRANTED]: undefined;
};

declare interface CorePlayerState extends BasePlayerState {
    isAirPlaying: boolean;
    isAirPlayAvailable: boolean;
    contractRestrictions?: ContractRestrictions;
}

export declare type CoreStateChangedPlayerEvent = CorePlayerState;

export declare type DefaultPlayerEvent = {
    currentTime: number;
    duration: number;
    utcCurrentTime: number;
    utcDuration: number;
    seekable: Seekable;
    utcSeekable: Seekable;
};

declare interface DeviceRights {
    manufacturer?: string;
    model?: string;
    os?: string;
    osVersion?: string;
    rights?: AssetRights;
}

declare interface DRMLicense {
    "com.apple.fps"?: DrmUrls;
    "com.microsoft.playready"?: DrmUrls;
    "com.widevine.alpha"?: DrmUrls;
    licenseActivation?: number;
    licenseExpiration?: number;
    licenseExpirationReason?: LicenseExpirationReason;
}

declare const DRMType: {
    readonly PLAYREADY: "com.microsoft.playready";
    readonly WIDEVINE: "com.widevine.alpha";
    readonly FAIRPLAY: "com.apple.fps";
};

declare type DRMType = (typeof DRMType)[keyof typeof DRMType];

declare type DrmUpdate = "FAIRPLAY_LICENSE_REQUEST" | "FAIRPLAY_LICENSE_RESPONSE" | "FAIRPLAY_CERTIFICATE_REQUEST" | "FAIRPLAY_LICENSE_ERROR" | "FAIRPLAY_CERTIFICATE_ERROR" | "WIDEVINE_LICENSE_REQUEST" | "WIDEVINE_LICENSE_RESPONSE" | "WIDEVINE_LICENSE_ERROR" | "PLAYREADY_LICENSE_REQUEST" | "PLAYREADY_LICENSE_RESPONSE" | "PLAYREADY_LICENSE_ERROR";

export declare type DrmUpdatePlayerEvent = DefaultPlayerEvent & {
    type: DrmUpdate;
};

declare interface DrmUrls {
    certificateUrl: string;
    licenseServerUrl: string;
}

export declare type DroppedFramesPlayerEvent = DefaultPlayerEvent & {
    droppedFrames: number;
};

declare class EmitterBaseClass<Events extends Record<string, unknown>> {
    private emitter?;
    private allHandlers;
    constructor();
    protected emit<Key extends keyof Events>(event: Key, data: Events[Key]): void;
    once<Key extends keyof Events>(event: Key, handler: Handler<Events[Key]>): void;
    on<Key extends keyof Events>(event: Key, handler: Handler<Events[Key]>): void;
    onAll(handler: AllEventHandler<Events>): void;
    off<Key extends keyof Events>(event: Key, handler?: Handler<Events[Key]>): void;
    offAll(handler: AllEventHandler<Events>): void;
    addEventListener<Key extends keyof Events>(event: Key, handler: Handler<Events[Key]>): void;
    removeEventListener<Key extends keyof Events>(event: Key, handler?: Handler<Events[Key]>): void;
    destroy(_?: any): void;
}

declare type EpgInfo = Record<"enabled" | "entitlementCheck", boolean>;

declare type errorMetadata = {
    type: ErrorTypes;
    code?: number;
    rawError?: any;
    [name: string]: any;
};

export declare type ErrorPlayerEvent = PlayerError;

export declare const ErrorTypes: {
    readonly GENERIC: "GENERIC";
    readonly OPTIONS: "INIT_OPTIONS";
    readonly ABORTED: "ABORTED";
    readonly API_AUTH: "AUTH_FAILED";
    readonly API_AUTH_ANON: "AUTH_ANON_FAILED";
    readonly API_PLAY_REQUEST: "PLAY_REQUEST_FAILED";
    readonly API_ASSET: "ASSET_REQUEST_FAILED";
    readonly DECODE: "DECODE_ERROR";
    readonly DRM: "DRM_ERROR";
    readonly NETWORK: "NETWORK_ERROR";
    readonly STREAM_NOT_AVAILABLE: "STREAM_NOT_AVAILABLE";
    readonly STREAM_LIMIT: "STREAM_LIMIT_REACHED";
    readonly NOT_AUTHENTICATED: "SESSION_NOT_AUTHENTICATED";
    readonly NOT_AUTHORIZED: "UNAUTHORIZED";
    readonly GEO_LOCATION: "GEOLOCATION";
    readonly MANIFEST: "MANIFEST_ERROR";
    readonly SEGMENT: "SEGMENT_ERROR";
    readonly MEDIA: "MEDIA_ERROR";
    readonly CODEC: "CODEC";
    readonly CAST: "CAST";
    readonly PLAYER_ENGINE: "GENERIC_PLAYERENGINE_ERROR";
    readonly UNSUPPORTED_DEVICE: "UNSUPPORTED_DEVICE";
    readonly UNSUPPORTED_SCREEN: "UNSUPPORTED_SCREEN";
    readonly OTHER: "OTHER_ERROR";
    readonly DESTROYED: "DESTROYED";
    readonly SRC_NOT_SUPPORTED: "SOURCE_NOT_SUPPORTED";
};

export declare type ErrorTypes = (typeof ErrorTypes)[keyof typeof ErrorTypes];

declare interface Event_2 {
    asset: Asset;
    assetId: string;
    endTime: string;
    startTime: string;
}

declare type EventHelper<T> = {
    [K in keyof T]: {
        event: K;
        data: T[K];
    };
};

export declare class ExposureService {
    private context;
    private sessionToken?;
    constructor({ customer, businessUnit, baseUrl }: IExposureServiceOptions);
    assetMetadata(assetId: string): Promise<Asset>;
    authenticate<AuthOptions extends AuthLoginOptions | undefined>(authOptions?: AuthOptions): Promise<AuthOptions extends AuthLoginOptions ? LoginResponse : AnonymousSessionResponse>;
    playRequest({ assetId, sessionToken, adsOptions, audioOnly, adobePrimetimeToken, maxResolution, supportedFormatTypes, supportedKeySystem, materialProfile, start, end, }: IPlayRequestOptions): Promise<PlayResponse>;
    private parsePlayResponse;
}

declare type ExternalReference = Record<"locator" | "type" | "value", string>;

declare interface IAdBlock {
    startTime: number;
    relativeStartTime: number;
    endTime: number;
    duration: number;
    ads: IAdDataRepresentation[];
}

declare interface IAdBlockMarker {
    startTime: number;
    duration: number;
    watched: boolean;
}

declare interface IAdDataRepresentation {
    id: string;
    title: string;
    system: string;
    duration: number;
    trackingEvents: {
        [key in TrackingEvent]?: string[];
    };
    clickThrough?: string;
    adIndex?: number;
    adsTotal?: number;
}

declare interface IAdsOptions {
    latitude?: number;
    longitude?: number;
    mute?: boolean;
    autoplay?: boolean;
    consent?: string;
    width?: number;
    height?: number;
    pageUrl?: string;
    domain?: string;
    ifa?: string;
    ifaType?: TIFAType;
    limitAdTracking?: boolean;
    /**
     * These custom parameters will be added to the querystring of the play request.
     * e.g. ?customParam1=value1&customParam2=value2 etc
     */
    [key: string]: any;
}

declare interface IDevice {
    /**
     * UUID of the device, does not have to be a DUID can be generated but should be persistent between sessions.
     */
    id: string;
    type: TDeviceType;
    /**
     * Human-readble name of the device, used for device management.
     * @type {string}
     */
    name: string;
    /**
     * Model descriptor, used for filtering & analytics - eg. browser-chrome-111 OR samsung-tv-5.0 etc.
     */
    model: TDeviceModel;
    /**
     * Device specific Model number eg. SM-G950F, A2651
     */
    modelNumber?: string;
    /**
     * Device manufacturer eg. Apple, Samsung, Microsoft, Google
     */
    manufacturer: string;
    /**
     * Device OS, eg. OS X, Windows, Linux, WebOS, Tizen
     */
    os: string;
    /**
     * Version of the OS
     */
    osVersion: string;
}

declare interface IDimensions {
    x: number;
    y: number;
    width: number;
    height: number;
}

declare interface IExposureServiceOptions {
    customer: string;
    businessUnit: string;
    baseUrl: string;
}

declare interface ILoadOptions {
    source: string;
    startTime?: number;
    poster?: string;
    audioOnly?: boolean;
    ads?: IAdsOptions;
    materialProfile?: string;
    manifest?: IManifestOptions;
}

declare interface Image_2 {
    height: number;
    orientation: ImageOrientation_2;
    priority?: number;
    type?: string;
    url: string;
    width: number;
}

declare const ImageOrientation_2: {
    readonly LANDSCAPE: "LANDSCAPE";
    readonly PORTRAIT: "PORTRAIT";
    readonly SQUARE: "SQUARE";
    readonly UNKNOWN: "UNKNOWN";
};

declare type ImageOrientation_2 = (typeof ImageOrientation_2)[keyof typeof ImageOrientation_2];

declare interface IManifestOptions {
    start?: number;
    end?: number;
}

declare interface IPlayerCoreOptions {
    customer?: string;
    businessUnit?: string;
    exposureBaseUrl?: string;
    sessionToken?: string;
    wrapperElement: HTMLElement;
    fullscreenElement?: string;
    playToken?: string;
    autoplay?: boolean;
    muted?: boolean;
    nativeSkin?: boolean;
    preferredFormats?: string[];
    keysystem?: DRMType;
    adobePrimetimeToken?: string;
    castAppId?: string;
    disableCast?: boolean;
    disableAirPlay?: boolean;
    maxResolution?: string;
    logLevel?: LogLevel;
    appName?: string;
    customShakaConfiguration?: Record<string, any>;
    customHlsJsConfiguration?: Record<string, any>;
    customDashJSConfiguration?: Record<string, any>;
    locale?: string;
    metadataURIs?: string[];
    deviceAdapter?: TDeviceAdapter;
    mediaContainer?: HTMLDivElement;
}

declare interface IPlayerEngine {
    name: string;
    version: string;
}

declare interface IPlayerSession {
    assetId?: string;
    initOptions?: IPlayerCoreOptions;
    loadOptions?: ILoadOptions;
    sessionToken?: string;
    playSessionId?: string;
    requestId?: string;
    playbackFormat?: MediaFormatType;
    playerEngine?: IPlayerEngine;
    autoplay?: boolean;
    locale: string;
    cdnProvider?: string;
    analyticsPostInterval?: number;
    analyticsBucket?: number;
    analyticsTag?: string;
    analyticsBaseUrl?: string;
    analyticsPercentage?: number;
    exposureBaseUrl?: string;
}

declare type IPlayerSkinOptions = Partial<ISkinOptions>;

declare interface IPlayerStreamInfo {
    mediaLocator: string;
    format: MediaFormatType;
    hasDrm: boolean;
}

declare interface IPlayRequestOptions {
    assetId: string;
    sessionToken: string;
    adsOptions?: IAdsOptions;
    audioOnly?: boolean;
    adobePrimetimeToken?: string;
    maxResolution?: string;
    supportedFormatTypes?: MediaFormatType[];
    supportedKeySystem?: DRMType;
    materialProfile?: string;
    start?: number;
    end?: number;
}

export declare interface IRedBeePlayerAnalyticsOptions {
    disabled?: boolean;
    baseUrl?: string;
    appName?: string;
}

export declare interface IRedBeePlayerOptions extends IPlayerCoreOptions {
    customer: string;
    businessUnit: string;
    exposureBaseUrl: string;
    username?: string;
    password?: string;
    debug?: boolean;
    castAppId?: string;
    disableCast?: boolean;
}

export declare interface IRedBeePlayerSkinOptions extends IPlayerSkinOptions {
    disabled?: boolean;
    onSkinHidden?: () => void;
    onSkinVisible?: () => void;
}

declare type ISkinOptions = {
    hideControlsTimer: number;
    showMetadata: boolean;
    showWallClock: boolean;
    showQualitySelector: boolean;
    showSubtitlesToggleButton: boolean;
    showJumpButtons: boolean;
    allowPictureInPicture: boolean;
    keyboardShortcuts: boolean;
    timeZone?: string;
    locale?: string;
    translations?: any;
};

declare interface ISpriteCue {
    image: string;
    start: number;
    end: number;
    dimensions: IDimensions;
}

declare type JsonNode = object;

declare const LicenseExpirationReason: {
    readonly ANONYMOUS_IP_BLOCKED: "ANONYMOUS_IP_BLOCKED";
    readonly CONCURRENT_STREAMS_LIMIT_REACHED: "CONCURRENT_STREAMS_LIMIT_REACHED";
    readonly DEVICE_BLOCKED: "DEVICE_BLOCKED";
    readonly DOWNLOAD_BLOCKED: "DOWNLOAD_BLOCKED";
    readonly EPG_PLAY_MAX_HOURS: "EPG_PLAY_MAX_HOURS";
    readonly GAP_IN_EPG: "GAP_IN_EPG";
    readonly GEO_BLOCKED: "GEO_BLOCKED";
    readonly LICENSE_EXPIRED: "LICENSE_EXPIRED";
    readonly NOT_AVAILABLE_IN_FORMAT: "NOT_AVAILABLE_IN_FORMAT";
    readonly NOT_ENABLED: "NOT_ENABLED";
    readonly NOT_ENTITLED: "NOT_ENTITLED";
    readonly SUCCESS: "SUCCESS";
    readonly VPN_BLOCKED: "VPN_BLOCKED";
};

declare type LicenseExpirationReason = (typeof LicenseExpirationReason)[keyof typeof LicenseExpirationReason];

declare type LinkedEntity = Record<"entityId" | "entityType" | "linkType", string>;

declare type LiveAsset = ChannelAsset | ProgramResponse;

export declare type LoadedPlayerEvent = DefaultPlayerEvent & {
    startTime?: number;
    playSessionId?: string;
};

export declare type LoadingPlayerEvent = {
    playSessionId?: string;
};

declare interface LocalizedData {
    article?: string;
    description?: string;
    extendedDescription?: string;
    images?: Image_2[];
    locale: string;
    longDescription?: string;
    shortDescription?: string;
    sortingTitle?: string;
    tinyDescription?: string;
    title?: string;
}

declare type LocalizedPersonData = Record<"bio" | "locale", string>;

declare type LocalizedSeoData = Record<"locale" | "seoDescription" | "seoTitle", string>;

declare interface LoginResponse {
    /** The user's accountId. */
    accountId?: string;
    /**
     * Historical artifact. Always "OK"
     * @deprecated
     */
    accountStatus?: string;
    /**
     * use data in userProfile.
     * @deprecated
     */
    child?: boolean;
    /** The token of the underlying CRM to use if talking directly to the CRM. */
    crmToken?: string;
    /** When the session expires. */
    expirationDateTime: string;
    informationCollectionConsentGiven?: string;
    informationCollectionConsentRequiredDate?: string;
    /** If true to many devices are logged in and this session can not be used to play. Normally this will not happen. */
    isOverDeviceLimit?: boolean;
    /**
     * use data in userProfile.
     * @deprecated
     */
    language?: string;
    /**
     * use data in userProfile.
     * @deprecated
     */
    profileType?: string;
    /** The (bearer) session token to use in subsequent requests. */
    sessionToken: string;
    /** The user's userId. */
    userId?: string;
    userProfile?: UserProfile;
}

declare const LogLevel: {
    readonly DEBUG: 0;
    readonly INFO: 1;
    readonly WARN: 2;
    readonly ERROR: 3;
    readonly NONE: 4;
};

declare type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];

declare interface Marker {
    adMarkerType?: string;
    offset?: number;
    url?: string;
}

export declare type MarkerPlayerEvent = DefaultPlayerEvent & {
    contentMarker: MarkerPoint;
};

declare interface MarkerPoint {
    endOffset?: number;
    localized?: SimpleLocalizedData[];
    offset: number;
    thumbnail?: string;
    type?: MarkerType;
}

declare const MarkerType: {
    readonly CHAPTER: "CHAPTER";
    readonly CREDITS: "CREDITS";
    readonly INTRO: "INTRO";
    readonly POINT: "POINT";
};

declare type MarkerType = (typeof MarkerType)[keyof typeof MarkerType];

declare interface Media {
    drm?: string;
    durationMillis?: number;
    format?: string;
    height?: number;
    mediaId?: string;
    name?: string;
    programId?: string;
    status?: string;
    width?: number;
}

declare interface MediaFormat {
    drm?: DRMLicense;
    format: MediaFormatType;
    liveDelay?: number;
    mediaLocator?: string;
    orgMediaLocator?: string;
    vastUrl?: string;
}

declare const MediaFormatType: {
    readonly AAC: "AAC";
    readonly DASH: "DASH";
    readonly HLS: "HLS";
    readonly MP3: "MP3";
    readonly MP4: "MP4";
    readonly SMOOTHSTREAMING: "SMOOTHSTREAMING";
    readonly SYNDICATED: "SYNDICATED";
};

declare type MediaFormatType = (typeof MediaFormatType)[keyof typeof MediaFormatType];

declare type MediaType = "audio" | "video";

export declare type MetadataPlayerEvent = DefaultPlayerEvent & {
    engineName: PlayerEngineName;
    event: any;
    engineVersion?: string;
};

declare interface OverlayWidget {
    url?: string;
}

declare type ParentalRating = Record<"country" | "rating" | "scheme", string>;

declare interface Person {
    dateOfBirth?: string;
    dateOfDeath?: string;
    function?: string;
    localized?: LocalizedPersonData[];
    name?: string;
    personId?: string;
    role?: string;
}

export declare const PlaybackState: {
    readonly IDLE: "idle";
    readonly LOADING: "loading";
    readonly PLAYING: "playing";
    readonly PAUSED: "paused";
    readonly BUFFERING: "buffering";
    readonly SEEKING: "seeking";
    readonly ENDED: "ended";
    readonly ERROR: "error";
};

export declare type PlaybackState = (typeof PlaybackState)[keyof typeof PlaybackState];

declare type PlayerEngineName = "Shaka Player" | "Hls.js" | "Native HTML Video" | "Dashjs" | "Bitmovin";

declare class PlayerError extends Error {
    category: string;
    metadata: errorMetadata;
    constructor(message: string, { type, code, rawError }: errorMetadata);
    toString(): string;
}

export declare const PlayerEvents: {
    readonly PLAY: "player:play";
    readonly PAUSE: "player:pause";
    readonly STOP: "player:stopped";
    readonly START: "player:start";
    readonly RESUME: "player:resume";
    readonly PLAYING: "player:playing";
    readonly SEEKING: "player:seeking";
    readonly SEEK_TIME_CHANGE: "player:seek_time_change";
    readonly SEEKED: "player:seeked";
    readonly TIME_UPDATE: "player:timeupdate";
    readonly ENDED: "player:ended";
    readonly VOLUME_CHANGE: "player:volumechange";
    readonly ERROR: "player:error";
    readonly CAST_ERROR: "player:cast_error";
    readonly LOADING: "player:loading";
    readonly LOADED: "player:loaded";
    readonly LOAD_START: "player:load_start";
    readonly BUFFERING: "player:buffering";
    readonly BUFFERED: "player:buffered";
    readonly ID3: "player:id3";
    readonly BITRATE_CHANGED: "player:bitrate_changed";
    readonly CDN_CHANGED: "player:cdn_changed";
    readonly AUDIO_CHANGED: "player:audio_changed";
    readonly SUBTITLE_CHANGED: "player:subtitle_changed";
    readonly LICENSE_EXPIRED: "player:license_expired";
    readonly DROPPED_FRAMES: "player:dropped_frames";
    readonly DRM_UPDATE: "player:drm:update";
    readonly STATE_CHANGED: "player:state_changed";
    readonly PROGRAM_CHANGED: "player:program_changed";
    readonly NOT_ENTITLED: "player:not_entitled";
    readonly BLACKOUT: "player:blackout";
    readonly EMPTY_SLOT: "player:empty_slot";
    readonly CAST_START: "player:cast:start";
    readonly CAST_STOP: "player:cast:stop";
    readonly AIRPLAY_START: "player:airplay:start";
    readonly AIRPLAY_STOP: "player:airplay:stop";
    readonly AD_START: "player:ad:start";
    readonly AD_COMPLETE: "player:ad:complete";
    readonly ADBLOCK_START: "player:adblock:start";
    readonly ADBLOCK_COMPLETE: "player:adblock:complete";
    readonly INTRO_START: "player:intro:start";
    readonly INTRO_END: "player:intro:end";
    readonly CHAPTER_START: "player:chapter:start";
    readonly CHAPTER_END: "player:chapter:end";
    readonly MARKER: "player:marker";
    readonly METADATA_EVENT: "player:metadata_event";
    readonly SESSION_ACQUIRED: "player:session_acquired";
    readonly PLAYER_SETUP_COMPLETED: "player:setup_completed";
    readonly ENTITLEMENT_GRANTED: "player:entitlement_granted";
};

export declare type PlayerEvents = (typeof PlayerEvents)[keyof typeof PlayerEvents];

export declare type PlayerEventsMap = CorePlayerEventsMap & {
    [PlayerEvents.STATE_CHANGED]: PlayerState;
};

export declare interface PlayerState extends CorePlayerState {
    isCasting: boolean;
    isCastAvailable: boolean;
}

declare interface PlayResponse {
    accountId?: string;
    ads?: Ads;
    analytics?: Analytics;
    assetId?: string;
    audioOnly?: boolean;
    bookmarks?: Bookmarks;
    cdn?: CDN;
    concurrentSessionsCount?: number;
    contractRestrictions?: ContractRestrictions;
    deviceId?: string;
    deviceType?: string;
    durationInMilliseconds?: number;
    durationInMs?: number;
    entitleExposure?: boolean;
    entitlementType?: "AVOD" | "FVOD" | "SVOD" | "TVOD";
    epg?: EpgInfo;
    formats?: MediaFormat[];
    materialId?: string;
    materialProfile?: string;
    materialVersion?: number;
    playSessionId?: string;
    playToken?: string;
    playTokenExpiration?: number;
    playTokenExpirationReason?: string;
    productId?: string;
    publicationId?: string;
    publishingType?: string;
    requestId?: string;
    sprites?: Sprites[];
    streamInfo?: StreamInfo;
    subtitles?: Subtitle[];
    userId?: string;
}

declare interface Program {
    channelId?: string;
    endTime: string;
    programId?: string;
    startTime: string;
}

export declare type ProgramChangedPlayerEvent = {
    channel: Asset;
    program?: LiveAsset;
    upnext?: LiveAsset;
};

declare interface ProgramResponse {
    asset: Asset;
    assetId: string;
    blackout?: boolean;
    catchup?: boolean;
    catchupBlocked?: boolean;
    changed?: string;
    channelId?: string;
    created?: string;
    endTime: string;
    programId: string;
    startTime: string;
    vodAvailable?: boolean;
}

declare interface Publication {
    availabilityKeys?: string[];
    countries: string[];
    customData?: JsonNode;
    devices?: DeviceRights[];
    fromDate: string;
    products: string[];
    publicationDate: string;
    publicationId: string;
    rights?: AssetRights;
    services?: string[];
    toDate: string;
}

export declare type QualityLevel = {
    id: number;
    name?: string;
    bandwidth: number;
    width: number;
    height: number;
    framerate?: number;
};

export declare class RedBeePlayer extends EmitterBaseClass<PlayerEventsMap> {
    private destroyed;
    private readonly playerOptions;
    private readonly analyticsOptions?;
    private sessionToken?;
    private preloadPromise;
    private playlist;
    private loadedItem?;
    private skin?;
    private core?;
    private castSender?;
    private modules;
    constructor({ player, analytics, skin, }: {
        player: IRedBeePlayerOptions;
        skin?: IRedBeePlayerSkinOptions;
        analytics?: IRedBeePlayerAnalyticsOptions;
    });
    private setupEventListeners;
    private setupPlayer;
    private setupPlayerCore;
    private setupPlayerAnalytics;
    private setupCastSender;
    private _loadCastSender;
    private _loadPlayerCore;
    load(source: ILoadOptions | string | ILoadOptions[] | string[]): void;
    isBrowserSupported(): boolean;
    private destroyPlayer;
    destroy({ retainCastSession }?: {
        retainCastSession?: boolean;
    }): void;
    private getController;
    getPlayerInfo(): {
        playerVersion: string | undefined;
        playerEngine: {
            name: PlayerEngineName | undefined;
            version: string | undefined;
        };
    } | undefined;
    getSession(): IPlayerSession | undefined;
    getAssetInfo(): Asset | undefined;
    getProgramInfo(): {
        current?: LiveAsset | undefined;
        next?: LiveAsset | undefined;
    } | undefined;
    getContractRestrictions(): ContractRestrictions | undefined;
    getContainerElement(): HTMLDivElement | undefined;
    getVideoElement(): HTMLVideoElement | undefined;
    getTimelineSpriteCues(width?: number): Promise<ISpriteCue[]>;
    isFullscreen(): boolean | undefined;
    toggleFullscreen(): void | undefined;
    /**
     * returns true if the browser supports PictureInPicture
     */
    isPictureInPictureSupported(): boolean;
    /**
     * returns true if the currently playing content supports PictureInPicture
     */
    isPictureInPictureAvailable(): boolean;
    /**
     * returns true if the player is currently in PictureInPicture mode
     */
    isPictureInPicture(): boolean;
    togglePictureInPicture(): void;
    isAirplaySupported(): boolean | undefined;
    isAirplaying(): boolean;
    toggleAirPlay(): void | undefined;
    getStreamInfo(): IPlayerStreamInfo | undefined;
    setPlaybackRate(rate: number): void;
    seekToUTC(utcTime: number): void | undefined;
    getAssetId(): string | undefined;
    getState(): PlayerState | undefined;
    getCurrentTime(): number | undefined;
    getVolume(): number | undefined;
    play(): Promise<void> | undefined;
    getSeekable(): Seekable | undefined;
    pause(): void | undefined;
    setMuted(muted: boolean): void | undefined;
    toggleMuted(): void | undefined;
    seekTo({ time, change }: {
        time?: number;
        change?: number;
    }): void;
    seekToOffset(offset: number): void | undefined;
    seekToLive(): void | undefined;
    setQualityLevel(level: QualityLevel): void | undefined;
    getQualityLevels(): QualityLevel[] | undefined;
    setAudioTrack(track: Track): void | undefined;
    setSubtitleTrack(track?: Track): void | undefined;
    setVolume({ percentage }: {
        percentage: number;
    }): void | undefined;
    getAudioTrack(): Track | undefined;
    getAudioTracks(): Track[] | undefined;
    getSubtitleTrack(): Track | undefined;
    getSubtitleTracks(): Track[] | undefined;
    isLive(): boolean | undefined;
    isPlaying(): boolean | undefined;
    isVolumeReadOnly(): Promise<boolean> | undefined;
}

declare interface Season {
    availableDate?: string;
    changed?: string;
    created?: string;
    customData?: JsonNode;
    endYear?: number;
    episodeCount?: number;
    episodes: Asset[];
    externalReferences?: ExternalReference[];
    linkedEntities?: LinkedEntity[];
    localized: LocalizedData[];
    publishedDate?: string;
    season: string;
    seasonId: string;
    startYear?: number;
    tags?: Tag[];
    tvShowId?: string;
}

declare type Seekable = {
    start: number;
    end: number;
};

declare interface SimpleLocalizedData {
    image?: Image_2;
    locale: string;
    title?: string;
}

declare interface Sprites {
    offsetInMs?: number;
    vtt?: string;
    width: number;
}

export declare type StartPlayerEvent = DefaultPlayerEvent & {
    playSessionId?: string;
    startTime?: number;
    source: string;
    bitrate: number;
    qualityLevel: QualityLevel;
    qualityLevels: QualityLevel[];
};

export declare type StateChangedPlayerEvent = CorePlayerState;

declare interface StreamInfo {
    channelId?: string;
    end?: number;
    endPadding?: number;
    event?: boolean;
    live?: boolean;
    maxResolution?: string;
    nextAssetId?: string;
    nextProgramId?: string;
    persistent?: boolean;
    programId?: string;
    ssai?: boolean;
    start?: number;
    startPadding?: number;
    static?: boolean;
    timeShift?: boolean;
}

declare type Subtitle = Record<"label" | "language" | "url", string>;

declare interface SubtitleTrackInfo {
    fileSize?: number;
    language?: string;
}

declare interface SystemTag {
    id?: string;
    images?: SystemTagImage[];
}

declare interface SystemTagImage {
    selectors?: string[];
    url?: string;
}

declare interface Tag {
    changed?: string;
    created?: string;
    tagValues: TagValues[];
    type: string;
}

declare interface TagValues {
    tagId: string;
}

export declare type TAppType = "samsung_tv" | "lg_tv" | "chromecast" | "browser";

declare type TBrowser = "chrome" | "firefox" | "safari" | "edge" | "unknown";

declare type TBrowserModel = `browser-${TBrowser}-${number}`;

declare type TCastModel = "cc-googletv-hd" | "cc-googletv" | "cc-builtin" | "cc-ultra" | "cc-3" | "cc-2" | "cc-1" | "cc-unknown";

declare type TDeviceAdapter = (() => Promise<IDevice>) | undefined;

declare type TDeviceModel = TBrowserModel | TSamsungTVModel | TLGTVModel | TCastModel | string;

declare type TDeviceType = "desktop" | "tablet" | "mobile" | "ctv" | "airplay" | "chromecast";

export declare type TIFAType = "idfa" | "rida" | "aaid" | "tifa" | "ppid" | "sspid" | "sessionid";

declare type TLGTVModel = `lg-${TWebOSVersion}`;

export declare interface Track {
    id: string | number;
    language: string;
    label: string;
    kind?: string;
    raw?: any;
}

export declare type TrackChangedPlayerEvent = DefaultPlayerEvent & {
    track?: Track;
};

declare interface TrackInfo {
    fileSize?: number;
    targetBitrate?: string;
}

declare const TrackingEvent: {
    readonly LOADED: "loaded";
    readonly START: "start";
    readonly IMPRESSION: "impression";
    readonly COMPLETE: "complete";
    readonly FIRST_QUARTILE: "firstQuartile";
    readonly MIDPOINT: "midpoint";
    readonly THIRD_QUARTILE: "thirdQuartile";
    readonly CLICK_THROUGH: "clickThrough";
};

declare type TrackingEvent = (typeof TrackingEvent)[keyof typeof TrackingEvent];

declare interface TrackSizes {
    audioTracks?: AudioTrackInfo[];
    subtitleTracks?: SubtitleTrackInfo[];
    videoTracks?: VideoTrackInfo[];
}

declare type TSamsungTVModel = `samsung-${TTizenVersion}`;

declare type TTizenVersion = `${number}.${number}`;

declare interface TvShowInfo {
    localizedData?: LocalizedData[];
}

declare type TWebOSVersion = `${number}.${number}.${number}`;

declare interface UserAttributeResponse {
    /** attributeId */
    attributeId: string;
    /** The attributes default value. */
    defaultValue?: object;
    /** If type = "enum™": The enums value set. */
    enums?: UserAttributesEnumValue[];
    /** Localized metadata. */
    localized: UserAttributesLocalizedMetadata[];
    /** if type = "integer" or "real" and any range is specified: min and max values. */
    range?: UserAttributesRange;
    /** If true the user must provide a value, whicgh mayt be the default value. */
    requiredAtSignup: boolean;
    /** boolean:  value range null/undefined, false, true, email: valid email address, string: any string, integer: integer number e.g 1, real: Real/decimal number e.g 1.1, enum: a value defined by enums. */
    type: string;
    /** The value set by the user. */
    value?: object;
    /** If true the attribute has been set, potentially with a null/undefined value, in which case the default value is used. */
    valueSet: boolean;
}

/** If type = "enum™": The enums value set. */
declare interface UserAttributesEnumValue {
    /** Used as value of the enum. */
    id?: string;
    /** Localized metadata. */
    localized?: UserAttributesLocalizedMetadata[];
}

/** Localized metadata. */
declare type UserAttributesLocalizedMetadata = Record<"description" | "locale" | "title", string>;

/** if type = "integer" or "real" and any range is specified: min and max values. */
declare type UserAttributesRange = Record<"max" | "min", object>;

declare interface UserCapabilities {
    canChangeEmail: boolean;
    canChangePassword: boolean;
    canChangeUserNameAndEmail: boolean;
    canManageAccount: boolean;
    canManageDevices: boolean;
    canManagePayments: boolean;
    canManagePurchases: boolean;
}

declare interface UserProfile {
    /** True if this user profile is the active user (the user fetching this info. */
    active?: boolean;
    attributes?: UserAttributeResponse[];
    capabilities?: UserCapabilities;
    /** Created at. */
    created?: string;
    /** Display name (full name). */
    displayName?: string;
    /** Email address. */
    emailAddress?: string;
    /**
     * True if the user must have an email address. Check User attribute primary-email-address instead.
     * @deprecated
     */
    emailAddressRequired?: boolean;
    /** Language code of the user's preferred language */
    language?: string;
    /** Application defined map String->String. Can be used for arbitrary application specific data */
    metadata?: Record<string, string>;
    /** True if user is owner of the account. */
    owner?: boolean;
    /** Application defined value. Can be used e.g. to carry mapping to parental rating configuration. */
    profileType?: string;
    /** User Id. */
    userId?: string;
    /** User's (login) name. */
    username?: string;
}

declare interface VideoTrackInfo {
    fileSize?: number;
    height?: number;
    targetBitrate?: string;
}

export declare type VolumeChangePlayerEvent = DefaultPlayerEvent & {
    volume: number;
    muted: boolean;
};

export { }