@tivio/sdk-js 2.3.2 → 2.4.0

package/dist/sdk-js.d.ts

@@ -0,0 +1,2784 @@
+import { DocumentReference } from '@firebase/firestore-types';
+import firebase from '@firebase/app-types';
+
+/**
+ * @public
+ */
+declare type AdMetadata = {
+    type: 'ad';
+    subType: 'inserted' | 'original';
+    secondsToEnd: number;
+    /**
+     * null when ad is not skippable
+     */
+    secondsToSkippable: number | null;
+    canTriggerSkip: boolean;
+    isSkippable: boolean;
+    order: number | null;
+    totalCount: number | null;
+    skip: () => void;
+} | null;
+
+declare interface AdSegment {
+    id: string;
+    /**
+     * @deprecated alias to secondsToEnd * 1000
+     */
+    remainingMs: number;
+    secondsToEnd: number;
+    secondsToSkippable: number | null;
+    canSeek: boolean;
+    /**
+     * true if is skippable and skip countdown has passed
+     */
+    canSkip: boolean;
+    /**
+     * true ad if is skippable after some skipDelayMs (if it is skippable, skipDelayMs is defined)
+     */
+    isSkippable: boolean;
+    skip: () => any;
+}
+
+/**
+ * @public
+ */
+declare type AdSource = SourceBase & {
+    type: 'ad';
+};
+
+/**
+ * @public
+ */
+declare interface AdSourceInterface extends CommonSourceInterface<SourceType.ADVERTISEMENT> {
+    adType: AdType;
+    durationMs: number;
+    skipDelayMs: number | null;
+    /**
+     * true if is skippable and skip countdown has passed
+     */
+    canSkip: boolean;
+    /**
+     * true ad if is skippable after some skipDelayMs (if it is skippable, skipDelayMs is defined)
+     */
+    isSkippable: boolean;
+    isSkipped: boolean;
+    isPaused: boolean;
+    isMuted: boolean;
+    setIsPaused(isPaused: boolean): void;
+    /**
+     * Skip ad. Only works when canSkip is true
+     */
+    skip: () => void;
+    /**
+     * Order in ad break (ad break is a group of ads played right after each other)
+     */
+    order: number | null;
+    /**
+     * Total number of ads in ad break (ad break is a group of ads played right after each other)
+     */
+    totalCount: number | null;
+    secondsToEnd: number;
+    secondsToSkippable: number | null;
+    provider?: VastProvider;
+    apiFramework: VastApiFramework | null;
+    parent: PlayerSourceInterface | null;
+    trackingContext: any | null;
+    resumeAd(): void;
+    pauseAd(): void;
+    muteAd(): void;
+    unmuteAd(): void;
+    skipAll(): void;
+    onRemainingTimeChanged(ms: number): void;
+    click(): void;
+}
+
+/**
+ * @public
+ */
+declare type AdType = 'playable' | 'metadata-only';
+
+/**
+ * @public
+ */
+declare interface Advertisement extends RowItem {
+    id: string;
+    itemType: ROW_ITEM_TYPES.ADVERTISEMENT;
+    type?: string | null;
+}
+
+export declare type Api = RemoteBundleState;
+
+/**
+ * @public
+ */
+declare interface Application extends RowItem {
+    id: string;
+    organizationId?: string;
+    itemType: ROW_ITEM_TYPES.APPLICATION;
+    name: string;
+    type: ApplicationType;
+    urlHandle: string;
+    applicationScreens: ApplicationScreenConfig[] | null;
+    screenConfigs: ScreenConfig[] | null;
+    logo: string | null;
+    cover: string | null;
+    videosCount: number | null;
+    organization?: Organization;
+    isEnabled: boolean;
+}
+
+/**
+ * @public
+ */
+declare interface ApplicationScreenConfig {
+    name: Translation;
+    order: number;
+    path: string;
+    screenConfig: ScreenConfig | null;
+}
+
+declare enum ApplicationType {
+    TIVIO_PRO = "TIVIO_PRO",
+    ORGANIZATION = "ORGANIZATION"
+}
+
+/**
+ * @public
+ */
+declare interface ApplyScreenConditionPayload {
+    embedUrl?: string;
+    userPurchases?: Purchase[];
+    isSignedIn?: boolean;
+    condition: RenderCondition;
+}
+
+/**
+ * @public
+ */
+declare type ArrisDeviceInfo = {
+    type: 'arris';
+    model?: 'VIP1003' | 'VIP1113' | 'VIP5305';
+};
+
+/**
+ * @public
+ */
+declare interface Article extends RowItem, MonetizableItem, ReactableContent {
+    id: string;
+    itemType: ROW_ITEM_TYPES.ARTICLE;
+    blocks: ArticleBlock[];
+    cover: string;
+    organizationId?: string;
+    detailBanner?: string;
+    episodeNumber?: number;
+    seasonNumber?: number;
+}
+
+/**
+ * @public
+ */
+declare interface ArticleBlock {
+    id: string;
+    type: ArticleBlockType;
+    htmlContent?: string;
+    imageUrl?: string;
+    textContent?: string;
+    videoId?: string;
+    isOverflowImage?: boolean;
+    imageDescription?: string;
+}
+
+/**
+ * @public
+ */
+declare type ArticleBlockType = 'PARAGRAPH' | 'IMAGE' | 'VIDEO' | 'HEADING' | 'PAYWALL' | 'BLOCK_QUOTE';
+
+/**
+ * @public
+ */
+declare interface Asset {
+    background: string;
+}
+
+/**
+ * @public
+ */
+declare interface AssetsField<TAsset extends ScalableAsset = ScalableAsset> {
+    [assetName: string]: TAsset;
+}
+
+/**
+ * @public
+ */
+declare interface AvailableSeason {
+    seasonNumber: number;
+    seasonName?: string;
+}
+
+declare interface AvailableSeasonField {
+    seasonNumber: number;
+    seasonName?: Translation;
+}
+
+declare enum BannerItemComponent {
+    CLASSIC = "CLASSIC",
+    SPLIT = "SPLIT",
+    BACKGROUND = "BACKGROUND",
+    BACKGROUND_BLUR = "BACKGROUND_BLUR",
+    ORGANIZATION_BANNER = "ORGANIZATION_BANNER",
+    CAROUSEL = "CAROUSEL"
+}
+
+/**
+ * @public
+ */
+declare type BottomComponent = 'dateOfPublication' | 'description' | undefined;
+
+/**
+ * @public
+ */
+declare interface ChannelSourceInterface extends PlayerSourceInterface<SourceType.CHANNEL> {
+    tvChannelType: TvChannelType;
+    channelName: string;
+    programName?: string;
+    programDescription?: string;
+    from: Date;
+    to: Date;
+    poster: string | null;
+    tvMode: TvMode | 'live' | null;
+}
+
+/**
+ * @public
+ */
+declare interface ChannelSourceParams extends PlayerSourceParams<SourceType.CHANNEL> {
+    tvChannelType: TvChannelType;
+    channelName: string;
+    programName?: string;
+    programDescription?: string;
+    from: Date;
+    to: Date;
+    tvMode?: TvMode | 'live' | null;
+}
+
+/**
+ * @public
+ */
+declare type CmpConfig = 'default' | 'debug' | 'none';
+
+/**
+ * TODO same name as core-js entity, not convenient
+ * @public
+ */
+declare type CommonSource = PlayerSource | AdSourceInterface;
+
+/**
+ * Use this interface only for inheritance. Otherwise use {@link CommonSource}
+ * @public
+ */
+declare interface CommonSourceInterface<T extends SourceType = SourceType> {
+    type: T;
+    url: string;
+    name?: string;
+    description?: string;
+    currentTime: number;
+    event: any | null;
+    setEvent(event: any | null): void;
+    onTimeChanged(ms: number): void;
+    next: CommonSource | null;
+    canSeek: boolean;
+    hasNext: boolean;
+    isFinished: boolean;
+    setIsFinished(isFinished: boolean): void;
+    isStarted: boolean;
+    setIsStarted(isStarted: boolean): void;
+    autoplay?: boolean;
+    autoplayMuteFallback: boolean;
+    toLog(): any;
+}
+
+/**
+ * @public
+ */
+declare interface CommonSourceParams<T extends SourceType = SourceType> {
+    type: T;
+    url: string;
+    name?: string;
+    description?: string;
+    autoplay?: boolean;
+}
+
+export declare type Conf = Pick<InternalConf, 'bundleUrlOverride' | 'capabilitiesOptions' | 'deviceCapabilities' | 'enableSentry' | 'forceCloudFnResolver' | 'language' | 'logger' | 'secret' | 'verbose'>;
+
+/**
+ * @public
+ */
+declare interface ConsumedAds {
+    chapterIds: Set<string>;
+    markerIds: Set<string>;
+    postroll: boolean;
+    /**
+     * TODO refactor
+     * true when preroll has been loaded (not when it was watched)
+     */
+    preroll: boolean;
+}
+
+/**
+ * @public
+ */
+declare interface ContentAvailability {
+    from: Date;
+    to: Date | null;
+    manual: boolean;
+}
+
+declare type ContentType = 'ARTICLE' | 'VIDEO' | 'SERIES' | 'EPISODE';
+
+/**
+ * @public
+ */
+declare type ContinuePosition = number | null | Promise<number | null>;
+
+/**
+ * @public
+ */
+declare interface Conversation {
+    id: string;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+    createdBy: MessageParticipant | null;
+    isSending: boolean;
+    lastMessage: ConversationMessage | null;
+    lastSeen: {
+        [key: string]: ConversationLastSeen | undefined;
+    };
+    participants: MessageParticipant[];
+    title: string;
+    messages: ConversationMessage[];
+    notSeenCount: number;
+    isLoading: boolean;
+    subscribeToMessages(): void;
+    sendMessage(text: string): Promise<SendMessageResponse>;
+    markAsRead(messageId: string): Promise<void>;
+    destroy(): void;
+}
+
+/**
+ * @public
+ */
+declare interface ConversationLastSeen {
+    message: Message;
+    date?: Date;
+}
+
+/**
+ * @public
+ */
+declare interface ConversationMessage {
+    id: string;
+    participant: MessageParticipant;
+    text: string;
+    createdAt: Date;
+    editedAt: Date | null;
+}
+
+/**
+ * @public
+ */
+declare interface ConversationStore {
+    conversations: Map<string, Conversation>;
+    isLoading: boolean;
+    setParticipantPath(participantPath: string | null): void;
+    setConversations(callback: (conversations: Conversation[]) => Conversation[]): void;
+    subscribeConversations(participantPath: string): Promise<void>;
+    createConversation(participantPaths: string[]): Promise<{
+        id: string;
+    } | undefined>;
+    clearConversations(): void;
+    getConversationById(id: string): Conversation | undefined;
+    readonly allConversations: Conversation[];
+    readonly notSeenCount: number;
+    setDisposer(key: 'conversations', disposer: Disposer_2): void;
+    unsubscribeConversations(): void;
+}
+
+/**
+ * @param {PlayerInterfaceForPlayerWrapper} playerImplementation - player implementation
+ * @returns player wrapper instance
+ */
+export declare const createPlayerWrapper: (playerImplementation: PlayerInterfaceForPlayerWrapper) => PlayerWrapper;
+
+declare type CreatePlayerWrapperType = (playerImplementation: PlayerInterfaceForPlayerWrapper) => TivioPlayerWrapper;
+
+/**
+ * Fetch & load CommonJS remote module.
+ */
+export declare const createRemotePackageLoader: () => (conf: InternalConf) => Promise<any>;
+
+export declare const createTivio: () => (conf: Conf) => Promise<RemoteBundleState>;
+
+/**
+ * @public
+ */
+declare type CreateUserWithEmailAndPassword = (email: string, password: string, username?: string, phoneNumber?: string, referralToken?: string) => Promise<string | null>;
+
+/**
+ * Three upper-case letters according to ISO-4217.
+ * @public
+ */
+declare type Currency = 'CZK' | 'EUR' | 'USD';
+
+/**
+ * @public
+ */
+declare enum CustomerId {
+    CESTMIR_STRAKATY = "CESTMIR_STRAKATY",
+    CNC = "CNC",
+    DVTV = "DVTV",
+    DVTV_DEV = "DVTV_DEV",
+    DVTV_SK = "DVTV_SK",
+    GARAZ = "GARAZ",
+    GRAPE = "GRAPE",
+    HODINA_DEJEPICHU = "HODINA_DEJEPICHU",
+    INVESTICNI_PRUVODCE = "INVESTICNI_PRUVODCE",
+    INVESTOREES = "INVESTOREES",
+    JOJ = "JOJ",
+    KLUCI_Z_PRAHY = "KLUCI_Z_PRAHY",
+    MALL = "MALL",
+    MEDIAR = "MEDIAR",
+    NANGU_DEV = "NANGU_DEV",
+    O2 = "O2",
+    OKTAGON = "OKTAGON",
+    ONDREJ_AUST = "ONDREJ_AUST",
+    ONDREJ_KOBERSKY = "ONDREJ_KOBERSKY",
+    REALTALK = "REALTALK",
+    STARMAX = "STARMAX",
+    STARGAZE = "STARGAZE",
+    STORYBOOK = "STORYBOOK",// dev
+    TIVIO = "TIVIO",
+    TIVIO_PRO = "TIVIO_PRO",
+    U_KULATEHO_STOLU = "U_KULATEHO_STOLU",
+    VIRTUAL_CHANNEL_VIDEOS = "VIRTUAL_CHANNEL_VIDEOS",
+    VOJTA_ZIZKA = "VOJTA_ZIZKA",
+    LIGA_NARUBY = "LIGA_NARUBY",
+    VIC_NEZ_SI_MYSLITE = "VIC_NEZ_SI_MYSLITE",
+    ZIMAK = "ZIMAK",
+    TYDENIK_HOROSKOPU = "TYDENIK_HOROSKOPU",
+    THE_MAG = "THE_MAG",
+    FNO = "FNO",
+    HARTMANNRICO = "HARTMANNRICO",
+    DRASLOVKA = "DRASLOVKA",
+    CSOB = "CSOB",
+    MAGNA = "MAGNA",
+    REPORTERKY = "REPORTERKY",
+    TV_LUX = "TV_LUX",
+    KVIFF = "KVIFF",
+    KVIFF_WEB = "KVIFF_WEB",
+    SPORTY_TV = "SPORTY_TV",
+    PALATINUM = "PALATINUM",
+    MIRA_BOSAK = "MIRA_BOSAK",
+    KOVACIC_360 = "KOVACIC_360",
+    SIFRA_TV = "SIFRA_TV",
+    BLESK = "BLESK",
+    NERUDA_TV = "NERUDA_TV",
+    DAVID_FRANK_TV = "DAVID_FRANK_TV",
+    LEPSI_UZ_TO_NEBUDE = "LEPSI_UZ_TO_NEBUDE",
+    BEAT_SEXISM = "BEAT_SEXISM"
+}
+
+/**
+ * @public
+ */
+declare interface Cutout {
+    startMs: number;
+    endMs: number;
+}
+
+/**
+ * @public
+ */
+declare type DefaultOrderByField = 'created';
+
+/**
+ * @public
+ */
+declare interface DetailedPrice {
+    amount: number;
+    currency: Currency;
+    frequency?: MONETIZATION_FREQUENCY;
+    durationDays?: number;
+}
+
+/**
+ * @public
+ */
+declare type DeviceInfo = ArrisDeviceInfo | ReactNativeDeviceInfo;
+
+export declare type Disposer = () => void;
+
+/**
+ * @public
+ */
+declare type Disposer_2 = () => void;
+
+declare interface Drm {
+    encryption: VideoSourceEncryption;
+    /**
+     * Url to retrieve fairplay from.
+     */
+    certificateUrl?: string;
+    /**
+     * Url to send license to.
+     */
+    licenseUrl: string;
+    /**
+     * Headers with corresponding values to send to license server.
+     */
+    licenseRequestHeaders: {
+        [key: string]: string;
+    };
+}
+
+/**
+ * @public
+ */
+declare interface Duration {
+    units: DurationUnits;
+    value: number;
+}
+
+/**
+ * @public
+ */
+declare enum DurationUnits {
+    DAY = "day",
+    MONTH = "month"
+}
+
+/**
+ * @public
+ */
+declare interface EmitterInterface {
+    isSupported: (even: string) => boolean;
+    addListener: <T = any>(event: string, cb: (value: T) => Empty_2) => void;
+    removeListener: <T = any>(event: string, cb: (value: T) => Empty_2) => void;
+}
+
+export declare type Empty = Promise<void> | void;
+
+/**
+ * @public
+ */
+declare type Empty_2 = void | Promise<void> | undefined | Promise<undefined>;
+
+export declare const fetchBundleViaResolver: (conf: InternalConf) => Promise<string>;
+
+/**
+ * Copyright (c) 2021, nangu.TV, a.s. All rights reserved.
+ * nangu.TV, a.s PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+declare type FetchPackage = (url: string) => Promise<string>;
+
+/**
+ * @public
+ */
+declare type FollowedOrganizationData = {
+    id: string;
+    name: string;
+    application: {
+        id: string;
+        urlHandle: string;
+        logo?: string;
+        logoLandscape?: string;
+        profilePhoto?: string;
+    };
+};
+
+/**
+ * @public
+ */
+declare type FrequencyInfo = {
+    title: Translation;
+    unit: string;
+    value: number;
+};
+
+/**
+ * @public
+ */
+declare type GeoBlocking = {
+    whitelist: Array<any>;
+} | {
+    blacklist: Array<any>;
+};
+
+/**
+ * @public
+ */
+declare interface GetPurchasableMonetizationsOptions {
+    includeMonetizationsWithPurchaseDisabled: boolean;
+}
+
+declare interface GetSourceUrlResponse {
+    /**
+     * The resulting source url.
+     */
+    url: string;
+    /**
+     * Which sources did client (or cloud function) has already tried out.
+     */
+    sourceHistory: string[];
+    /**
+     * DRM configuration to {@link url} if source is encrypted.
+     */
+    drm?: Drm;
+    /**
+     * See {@link SourcePlayMode} type.
+     */
+    sourcePlayMode: SourcePlayMode;
+    /**
+     * Returns url to manifest with audio only chunks.
+     */
+    audioOnly?: boolean;
+    /**
+     * Current session id for given user and source.
+     */
+    sessionId?: string;
+    /**
+     * Template for generating image previews for user scrubbing in player.
+     */
+    seekingMatrix?: SeekingMatrixTemplate;
+}
+
+declare interface GetUserRssUrlResponse {
+    rssUrl: string;
+    createdAt?: number;
+    expiresAt?: number;
+}
+
+declare type InternalConf = {
+    /**
+     * @private URL of remote code bundle to be fetched directly (without using resolver)
+     */
+    bundleUrlOverride?: string;
+    /**
+     * Tells Tivio which technologies/protocols etc. is the device capable to play.
+     * If not provided, Tivio will try to guess it (based on the browser).
+     */
+    deviceCapabilities?: PlayerCapability[];
+    /**
+     * Additional options for deviceCapabilities
+     */
+    capabilitiesOptions?: {
+        /**
+         * Should the player prefer HTTP sources instead HTTPs if they are available.
+         * This can be used on platforms that support mixed content but do not support
+         * specific HTTPS certificates. (e.g. certificates from Letsencrypt not supported on LG TVs)
+         */
+        preferHttp?: boolean;
+    };
+    secret: string;
+    resolverUrl: string;
+    logger?: Logger | null;
+    fetchPackage: FetchPackage;
+    language?: string;
+    sdkVersion: string;
+    /**
+     * Can force using bundle resolver method which doesn't depend on indexedDB (useful when some polyfill
+     * for indexedDB is used but indexedDB is not fully supported - it leads to situation where check for indexedDB
+     * presence passes but resolver fails anyway).
+     */
+    forceCloudFnResolver?: boolean;
+    /**
+     * Can turn off Tivio's Sentry logging, defaults to true.
+     */
+    enableSentry?: boolean;
+    /**
+     * Can turn on Tivio's console logging, defaults to false.
+     */
+    verbose?: boolean;
+};
+
+/**
+ * Responsible for handling of all player wrapper methods (it's called through PlayerWrapper).
+ * Also handles state when player wrapper from core-js is not ready yet and situation when it becomes ready.
+ */
+declare class InternalPlayerWrapper implements TivioPlayerWrapper {
+    private playerImplementation;
+    private id;
+    corePlayerWrapperInstance: TivioPlayerWrapper | null;
+    listenersWaitingToRegister: {
+        eventType: PlayerWrapperEventTypeType;
+        listener: Listener;
+    }[];
+    constructor(playerImplementation: PlayerInterfaceForPlayerWrapper, id: string);
+    addEventListener(eventType: PlayerWrapperEventTypeType, listener: Listener): void;
+    reportError(error: Error): void;
+    reportPlaybackEnded(): void;
+    reportTimeProgress(ms: number): void;
+    seekTo(ms: number): void;
+    setSource(source: Source | null, calibrationId?: string): void;
+    /**
+     * Set instance of the real player wrapper (from core-js).
+     *
+     * @param createPlayerWrapper - create player wrapper method from core-js
+     */
+    onPlayerWrapperReady(createPlayerWrapper: CreatePlayerWrapperType): void;
+}
+
+/**
+ * @public
+ */
+declare type ItemInRow = Tag | Video | TvChannel | Advertisement | Application | Article | Series;
+
+/**
+ * Enum of all supported languages codes as in ISO 639-1
+ * @public
+ */
+declare enum LangCode {
+    CS = "cs",
+    DE = "de",
+    EN = "en",
+    FR = "fr",
+    IT = "it",
+    PL = "pl",
+    PT = "pt",
+    SK = "sk",
+    ES = "es",
+    HU = "hu"
+}
+
+/**
+ * @public
+ */
+declare interface LinkedVideo {
+    video: Video;
+    type: 'CUT' | 'TRAILER' | 'BONUS' | 'CHILD' | 'TEASER' | 'TASTING' | 'VIRTUAL_PROGRAM' | 'PIP';
+}
+
+/**
+ * @public
+ */
+declare interface LinkedVideoRaw {
+    videoRef: any;
+    type: LinkedVideo['type'];
+}
+
+/**
+ * @public
+ */
+declare type Listener = ListenerAdMetadata | ListenerMarkers;
+
+/**
+ * @public
+ */
+declare type ListenerAdMetadata = (metadata: AdMetadata) => void;
+
+/**
+ * @public
+ */
+declare type ListenerMarkers = (marker: Marker[] | null) => void;
+
+/**
+ * Not supported yet, now it does pass-through only.
+ *
+ * @public
+ */
+declare type LiveTvChannelSource = SourceBase & {
+    type: 'live_tv_channel';
+    /**
+     * Tivio needs channel name in order to load markers.
+     */
+    channelName: string;
+};
+
+declare interface Logger {
+    /** important messages */
+    warn(...data: LoggerArgs): void;
+    /** errors */
+    error(...data: LoggerArgs): void;
+    /** critical errors */
+    exception(...data: LoggerArgs): void;
+    /** metrics */
+    info(...data: LoggerArgs): void;
+    /** non-production messages */
+    debug(...data: LoggerArgs): void;
+}
+
+/**
+ * Copyright (c) 2021, nangu.TV, a.s. All rights reserved.
+ * nangu.TV, a.s PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+declare type LoggerArgs = any[];
+
+/**
+ * @public
+ */
+declare interface Marker {
+    id: string;
+    from: Date;
+    to: Date;
+    count?: number;
+    fromMs?: number;
+    toMs?: number;
+    relativeFromMs: number;
+    relativeToMs: number;
+    type: 'AD' | 'AD_SEGMENT' | 'START' | 'END' | 'INTRO';
+}
+
+/**
+ * @public
+ */
+declare interface Message {
+    id: string;
+    text: string;
+    videoTime: number | null;
+    createdAt: Date;
+    editedAt: Date | null;
+    user: MessageUser | null;
+    reactions: Record<string, number> | null;
+    repliesCount: number | null;
+    isReady: boolean;
+    updateRepliesCount: (increment: boolean) => void;
+}
+
+/**
+ * @public
+ */
+declare interface MessageParticipant {
+    path: string;
+    name: string;
+    avatarUrl: string;
+    email: string;
+}
+
+/**
+ * @public
+ */
+declare interface MessageUser {
+    name: string;
+    avatarUrl: string | null;
+    email: string;
+}
+
+declare interface MonetizableItem {
+    /**
+     * Returns true if content is purchased (via transaction or subscription) or free.
+     */
+    isPaid: boolean;
+    /**
+     * Gets the most relevant monetization for this content.
+     */
+    purchasableMonetization: PurchasableMonetization | null;
+    /**
+     * Returns all transactions and subscriptions applied to this video.
+     * Transactions before subscriptions, sorted by price ascending.
+     */
+    getPurchasableMonetizations(options?: GetPurchasableMonetizationsOptions): PurchasableMonetization[];
+}
+
+/**
+ * @public
+ */
+declare interface Monetization {
+    id: string;
+    type?: MonetizationType;
+    name?: string;
+    description?: string;
+    organizationId?: string;
+    order?: number;
+}
+
+/**
+ * @public
+ */
+declare enum MONETIZATION_DURATION {
+    UNLIMITED = -1,
+    DAY = 1,
+    WEEK = 7,
+    MONTH = 30,
+    HALF_YEAR = 183,
+    YEAR = 365
+}
+
+/**
+ * @public
+ */
+declare enum MONETIZATION_FREQUENCY {
+    ONE_TIME_PAYMENT = "ONE_TIME_PAYMENT",
+    DAILY = "DAILY",
+    WEEKLY = "WEEKLY",
+    MONTHLY = "MONTHLY",
+    HALF_ANNUALLY = "HALF_ANNUALLY",
+    ANNUALLY = "ANNUALLY"
+}
+
+/**
+ * @public
+ * @TODO change to enum
+ */
+declare type MonetizationType = 'advertisement' | 'transaction' | 'subscription' | 'display';
+
+declare type NextPageParamType = 'screenId' | 'rowId' | 'filter';
+
+/**
+ * @public
+ */
+declare type NonAdSourceType = Exclude<SourceType, SourceType.ADVERTISEMENT>;
+
+/**
+ * @public
+ */
+declare interface OrderBy<T = void> {
+    field: T extends void ? string : T;
+    directionStr?: OrderByDirection;
+}
+
+declare type OrderByDirection = 'desc' | 'asc';
+
+/**
+ * @public
+ */
+declare interface Organization {
+    id: string;
+    userProfileConfiguration: any;
+    screenConfigs: ScreenConfig[];
+    logo: string | null;
+    logoLandscape: string | null;
+    organizationBanner: string | null;
+    profilePhoto: string | null;
+    defaultLanguage?: string;
+}
+
+/**
+ * If Tivio PlayerWrapper is an interception layer, it should allow the pass-through
+ * of not just Tivio source types but any other source types that the 3rd party app may be using.
+ *
+ * @public
+ */
+declare type OtherSource = SourceBase & StartAndContinuePosition & {
+    type: 'other';
+};
+
+declare interface PaginatedResponse<T = unknown, U extends NextPageParamType = NextPageParamType> {
+    items: T[];
+    nextPageParams: {
+        offset: number;
+        limit: number;
+    } & (U extends 'screenId' ? {
+        organizationId: string;
+        screenId: string;
+        initialTilesCount: number;
+    } : U extends 'rowId' ? {
+        organizationId: string;
+        rowId: string;
+    } : U extends 'filter' ? {
+        filter: Omit<RowFilterField, 'limit'>;
+    } : {}) | null;
+}
+
+/**
+ * @public
+ */
+declare type PaginationInterface<Entity> = {
+    items: Entity[];
+    fetchMore: () => void;
+    hasNextPage?: boolean;
+    loading?: boolean;
+    initialLoading?: boolean;
+};
+
+/**
+ * @public
+ */
+declare type PaginationOptions = Partial<{
+    limit: number;
+    noLimit: boolean;
+    noAutoFetch: boolean;
+}>;
+
+declare type PatreonUserAuth = {
+    access_token: string;
+    refresh_token: string;
+    expires_in: number;
+    token_type?: string;
+    scope?: string;
+    version?: string;
+};
+
+/**
+ * @public
+ */
+declare enum PLATFORM {
+    /**
+     * Includes tablets.
+     */
+    MOBILE = "MOBILE",
+    WEB = "WEB",
+    TV = "TV",
+    /**
+     * @deprecated Used only in big query. In the future we'll migrate to undefined value and delete this.
+     */
+    UNKNOWN = "unknown"
+}
+
+/**
+ * @public
+ */
+declare type Player = {
+    ad: any;
+    currentTime: any;
+    adSegment: any;
+    event: any;
+    events: any;
+    source: any;
+    state: any;
+    onPlaybackEnded: any;
+    onSourceChanged: any;
+    onStateChanged: any;
+    onTimeChanged: any;
+    pause: any;
+    play: any;
+    togglePlayPause: any;
+    register: any;
+    seekTo: any;
+    setVolume: any;
+    triggerEvent: any;
+};
+
+export declare interface PlayerCapability {
+    codec: 'h264' | 'h265';
+    encryption: 'fairplay' | 'none' | 'playready' | 'widevine';
+    protocol: 'dash' | 'hls';
+}
+
+/**
+ * @public
+ */
+declare interface PlayerCapability_2 {
+    codec: VideoSourceCodec;
+    encryption: VideoSourceEncryption;
+    protocol: VideoSourceProtocol;
+}
+
+/**
+ * @public
+ */
+declare type PlayerConfig = {
+    enabled?: boolean;
+    /**
+     * Some devices do not seek exactly
+     *
+     * e.g. on Arris if we request seek to position P, in reality it will seek to P -+5s
+     * e.g. on Arris if we request play from position P, in reality it will play from P -+5s
+     * (on Arris the error margin varies according to video format)
+     */
+    acceptablePositionAnomalyMs?: number;
+    /**
+     * Stream delay config
+     *
+     * IP TV apps have TV program / TV channel streams delayed relative to the original
+     * video source. Therefore stream markers taken from the original video source
+     * are delayed relative to the TV stream seen by end users of the IP TV app.
+     *
+     * This delay must be corrected.
+     */
+    streamDelayConfig?: {
+        /**
+         * ID of the delay config
+         */
+        id: string;
+    };
+    ui?: {
+        /**
+         * ID of a DOM element inside which Tivio should display its player-related UI
+         * such as ad buttons. This DOM element is an anchor point for Tivio UI. Preferably
+         * it should be a <div/> element styled to cover the whole area of the video player
+         * and it should be positioned to be on top the existing player UI (e.g. via z-index).
+         */
+        domAnchorId: string | null;
+    };
+    protocols?: {
+        mp4?: {
+            /**
+             * Set to false if player does not support MP4 files that require full file download
+             * (i.e. they do not support progressive MP4 download and therefore the whole file
+             * must be downloaded before playback can start)
+             */
+            fullFileDownloadSupport?: boolean;
+        };
+    };
+    /**
+     * Ad service settings
+     */
+    adService?: {
+        /**
+         * TIVIO AD SERVICE - can be used in websites and TV apps. Does not support VPAID
+         * IMA - can be used only in websites. Supports VAST 2, partially VAST 3, VAST 4, SIMID 1.0, OM SDK 1.3,
+         *   VPAID 2 (HTML5) https://developers.google.com/interactive-media-ads/docs/sdks/html5/client-side/compatibility
+         */
+        name: 'IMA SDK' | 'TIVIO AD SERVICE';
+    };
+};
+
+declare interface PlayerError {
+    message: string;
+}
+
+/**
+ * @public
+ */
+declare interface PlayerInterface {
+    /**
+     * Pause playback
+     */
+    pause: () => void;
+    /**
+     * Unpause playback
+     */
+    play: () => Promise<void> | void;
+    /**
+     * Stop and close video
+     */
+    stop: () => Promise<void> | void;
+    /**
+     * Seek to position in ms
+     *
+     * @param {number} ms - milliseconds relative to start of video (relative to 0 ms)
+     *  or in case of TV programs relative to start of the program (relative to source.from ms)
+     */
+    seekTo: (ms: number) => void;
+    /**
+     * Send this source to player. And either start playing it immediately if `source.autoplay` is true
+     * or just load it and keep it paused and ready to play if `source.autoplay` is false.
+     * If source is `null`, stop and close the player (this is the same as if `this.stop()` was called.)
+     */
+    setSource: (source: CommonSource | null) => Promise<void> | void;
+    /**
+     * Set volume
+     *
+     * @param {number} volume value in [0,1]
+     */
+    setVolume?: (volume: number) => void;
+    /**
+     * Mute the player volume
+     */
+    mute?: () => void;
+    /**
+     * Unmute the player volume and restore it to the save level that was before it has been muted
+     */
+    unmute?: () => void;
+    /**
+     * Sets native IMA ad URL which is then loaded and played on RN side
+     */
+    setNativeImaAdUrl?: (url: string) => void;
+    /**
+     * Try to load and play native IMA ad using provided URL
+     */
+    playNativeImaAd?: (url: string) => Promise<void>;
+    /**
+     * Get URL of native IMA ad which is currently playing
+     */
+    getNativeImaAdUrl?: () => string | null;
+    lastQuality?: number | null;
+    getQualities?: () => Track[];
+    /**
+     * Attribute indicating that the video is to be played "inline"
+     * https://developer.mozilla.org/en-US/docs/Web/HTML/Element/video#playsinline
+     */
+    setPlaysInline?: (value: boolean) => void;
+    setControlsList?: (value: string[]) => void;
+}
+
+/**
+ * @public
+ */
+declare interface PlayerInterfaceForPlayerWrapper {
+    /**
+     * @param {number} ms - milliseconds relative to start of video (relative to 0 ms)
+     *  or in case of TV programs relative to start of the program (relative to source.from ms)
+     */
+    seekTo: (ms: number) => void;
+    setSource: (source: Source | null) => void;
+}
+
+/**
+ * TODO same name as core-js entity, not convenient
+ * @public
+ */
+declare type PlayerSource = VodTivioSourceInterface | VodExternalSourceInterface | ChannelSourceInterface | VirtualChannelSourceInterface;
+
+/**
+ * Use this interface only for inheritance. Otherwise use {@link PlayerSource}
+ * @public
+ */
+declare interface PlayerSourceInterface<T extends NonAdSourceType = NonAdSourceType> extends CommonSourceInterface<T> {
+    adSegment: AdSegment | null;
+    consumedAds: ConsumedAds;
+    currentMarker: any | null;
+    drm?: Drm;
+    markers: any[];
+    setMarkers(markers: any[]): void;
+    isMarkersLoaded: boolean;
+    setOutroMarker(marker: any): void;
+    durationMs: number;
+    setDurationMs(ms: number): void;
+    reset(): void;
+    cutout: Cutout | null;
+    destroy(): void;
+    seekTo(ms: number): void;
+    adMonetization: any;
+    setAdMonetization(monetization: any): void;
+    setInitialTime(ms: number): void;
+    setContinueFromPosition(ms: ContinuePosition): void;
+    isLive: boolean;
+    sourcePlayMode?: SourcePlayMode;
+    language?: LangCode | null;
+    availableLanguages?: LangCode[] | null;
+    startOrResumeReactions(): void;
+    pauseReactions(): void;
+    correctStartPosition(): Promise<void | null>;
+    setCanSeek(canSeek: boolean): void;
+    originalOptions: Record<string, any>;
+}
+
+/**
+ * @public
+ */
+declare interface PlayerSourceParams<T extends NonAdSourceType = NonAdSourceType> extends CommonSourceParams<T> {
+    originalOptions?: Record<string, any>;
+    continuePositionMs?: ContinuePosition;
+    poster?: string | null;
+    language?: LangCode | null;
+    availableLanguages?: LangCode[] | null;
+    sourcePlayMode: SourcePlayMode;
+}
+
+/**
+ * @public
+ */
+declare type PlayerState = 'idle' | 'playing' | 'paused';
+
+/**
+ * Player wrapper which instances are exposed to SDK user.
+ */
+declare class PlayerWrapper implements TivioPlayerWrapper {
+    private internalPlayerWrapper;
+    constructor(internalPlayerWrapper: InternalPlayerWrapper);
+    addEventListener(eventType: 'adMetadata', listener: ListenerAdMetadata): void;
+    addEventListener(eventType: 'markers', listener: ListenerMarkers): void;
+    reportError: (error: Error) => void;
+    reportPlaybackEnded: () => void;
+    reportTimeProgress: (ms: number) => void;
+    seekTo: (ms: number) => void;
+    setSource: (source: Source | null, calibrationId?: string) => void;
+}
+
+/**
+ * @public
+ */
+declare interface PlayerWrapper_2 {
+    /**
+     * Report that playback of video has finished
+     */
+    onPlaybackEnded: () => void;
+    /**
+     * Report video progress in milliseconds
+     */
+    onTimeChanged: (ms: number) => void;
+    /**
+     * Report that video state changed
+     */
+    onStateChanged: (state: PlayerState) => void;
+    /**
+     * Send source to Tivio
+     */
+    onSourceChanged: (source: PlayerSource | null) => void;
+    /**
+     * Report that video failed to load (never started playing)
+     */
+    onLoadError: (error: Error) => void;
+    /**
+     * Report that video failed during playback (successfully loaded and then failed, e.g. part of stream is invalid)
+     */
+    onError: (error: Error) => void;
+    /**
+     * Unpause video
+     */
+    play: () => void;
+    /**
+     * Pause video
+     */
+    pause: () => void;
+    /**
+     * Currently playing source
+     */
+    source: PlayerSource | null;
+    events: EmitterInterface;
+    /**
+     * Register a low level player that implements player methods, like play video, change volume, etc.
+     */
+    register: (playerInterface: PlayerInterface) => void;
+    /**
+     * duration of current source in ms (both setter and getter)
+     */
+    durationMs: number | null;
+    isPlaybackStarted?: boolean;
+    isPaused: boolean;
+    isPlaying: boolean;
+    isIdle: boolean;
+    error: PlayerError | null;
+    /**
+     * Replay the video that finished playback
+     */
+    replay: () => void;
+    /**
+     * Retry to play a video that failed to start playing (e.g. due to a network error)
+     */
+    retry: () => void;
+    togglePlayPause: () => void;
+    seekTo: (ms: number) => void;
+    /**
+     * set volume to value between 0,1
+     */
+    setVolume: (volume: number) => void;
+    /**
+     * change volume by value between -1,1
+     */
+    changeVolumeBy: (volume: number) => void;
+    setMuted: (muted: boolean) => void;
+    toggleMuted: () => void;
+    getQualities: () => Track[];
+}
+
+/**
+ * @public
+ */
+declare enum PlayerWrapperEventType {
+    adMetadata = "adMetadata",
+    markers = "markers"
+}
+
+/**
+ * @public
+ */
+declare type PlayerWrapperEventTypeType = `${PlayerWrapperEventType}`;
+
+/**
+ * @public
+ */
+declare interface Promotion {
+    duration?: Duration;
+    price?: number;
+    requiresPaymentAuthorization?: boolean;
+    hideOtherSubscriptions?: boolean;
+}
+
+/**
+ * @public
+ */
+declare enum PublishedStatus {
+    /**
+     * Content is not published, is not shown in any application and cannot be played,
+     * even if user enters url directly into browser.
+     */
+    DRAFT = "DRAFT",
+    /**
+     * Content is published and can be accessed and played freely in any application.
+     */
+    PUBLISHED = "PUBLISHED",
+    /**
+     * Content is not visible in the application (e.g. rows, search), but if user has direct url to it, they can play it.
+     */
+    UNLISTED = "UNLISTED"
+}
+
+/**
+ * @public
+ */
+declare interface PurchasableMonetization extends Monetization {
+    /**
+     * Price before any discounts (e.g. promotions).
+     */
+    originalPrice: number;
+    /**
+     * Final price (after discounts).
+     */
+    price?: string | number;
+    promotion: Promotion | null;
+    frequency?: MONETIZATION_FREQUENCY;
+    frequencyInfo?: FrequencyInfo;
+    durationDays?: number;
+    /**
+     * Returns TRUE if subscription is purchased (and not expired) by user.
+     * Returns TRUE if transaction is purchased (and not expired) for transactionItemId.
+     * Returns FALSE otherwise.
+     *
+     * @param transactionItemId id of item for which transaction purchase is checked
+     * @param transactionField type of item (video or tvChannel)
+     */
+    isPurchased(transactionItemId?: string, transactionField?: 'videoId' | 'tvChannelId'): boolean;
+    benefits?: Translation[];
+    localizedBenefits?: string[];
+    /**
+     * Set to true for subscriptions which is not possible to buy - typically for historical subscriptions which users
+     * still have bought but can't be purchased anymore.
+     */
+    purchaseDisabled?: boolean;
+    /**
+     * When set to true, users can buy this monetization as a voucher (e.g. to send it as a gift to a friend).
+     * If not set or set to false, users cannot buy it as a voucher.
+     */
+    isPurchasableAsVoucher?: boolean;
+    /**
+     * Returns array of tag ids of monetization placements
+     */
+    tagIds: string[];
+    /**
+     * When set to true, subscription is hidden in UI (e.g. in MonetizationSelectOverlay).
+     */
+    subscriptionIsHidden?: boolean;
+    /**
+     * Price that is used for marketing purposes (strike-through price).
+     */
+    regularPrice?: DetailedPrice;
+    /**
+     * Number of seats left for the subscription.
+     */
+    seatsLeft?: number;
+    maxQuantity?: number;
+}
+
+/**
+ * @public
+ */
+declare type Purchase = {
+    /**
+     * Timestamp of the purchase creation in milliseconds.
+     */
+    created: number | null;
+    /**
+     * Email of the user who created the purchase manually.
+     */
+    createdBy?: string;
+    expirationDate: Date | null;
+    gateway: PurchaseDocumentGateway | null;
+    id: string;
+    isExpired: boolean;
+    /**
+     * @deprecated isPurchased is ambiguous name. Now it means that purchase.status is "PAID".
+     * So use purchase.status === PurchaseStatus.PAID instead.
+     */
+    isPurchased: boolean;
+    monetization: PurchaseMonetization | null;
+    monetizationId: string | null;
+    monetizationRef: any | null;
+    status: PurchaseStatus | null;
+    type: PurchaseType | null;
+    /**
+     * Timestamp of the last purchase status update in milliseconds.
+     */
+    updated: number | null;
+    videoId: string | null;
+    videoRef: any | null;
+    voucherId: string | null;
+    isVoucherActivation?: boolean;
+    rebalancingVideoRef?: any;
+};
+
+/**
+ * @public
+ */
+declare enum PurchaseDocumentGateway {
+    'qerko' = "qerko",
+    'oktagon' = "oktagon",
+    'voucher' = "voucher",
+    'comgate' = "comgate",
+    'tivio' = "tivio",
+    'patreon' = "patreon",
+    'paypal' = "paypal",
+    'unknown' = "unknown",
+    'stargaze' = "stargaze"
+}
+
+/**
+ * @public
+ */
+declare type PurchaseMonetization = {
+    durationDays?: MONETIZATION_DURATION | number;
+    currency?: Currency;
+    price?: number;
+    /**
+     * Here are only transaction and subscription because purchasing of advertisement monetization doesn't make sense.
+     */
+    type: 'transaction' | 'subscription';
+    title?: string;
+    frequency?: MONETIZATION_FREQUENCY | null;
+    /**
+     * If set purchase (subscription) activated by voucher will stay valid for this amount of seconds.
+     * Otherwise purchase will be valid for one "monetization frequency" period.
+     */
+    voucherPurchaseDuration?: number;
+};
+
+/**
+ * @public
+ */
+declare enum PurchaseStatus {
+    NEW = "NEW",
+    PAID = "PAID",
+    CANCELLED = "CANCELLED",
+    ERROR = "ERROR",
+    /**
+     * Used when purchase is terminated due to terms and conditions violation (e.g. restreaming).
+     */
+    BLOCKED = "BLOCKED",
+    /**
+     * Used in subscription purchases when subscription is renewed.
+     */
+    RENEWED = "RENEWED",
+    /**
+     * From NEW to ABORTED when user cancels purchase before payment or when payment fails.
+     */
+    ABORTED = "ABORTED",
+    /**
+     * When user manually cancels purchase but still has access to content until expiration date.
+     */
+    CANCELLING = "CANCELLING",
+    /**
+     * From PAID to EXPIRED when payment fails to renew subscription.
+     */
+    EXPIRED = "EXPIRED",
+    /**
+     * From PAID to EXPIRING when a Stargaze purchase has passed its expire date but hasn't been fully expired yet.
+     * Stargaze will try to renew the purchase even after it has expired.
+     */
+    EXPIRING = "EXPIRING"
+}
+
+/**
+ * Purchase is a purchase of one video (transaction type) purchase of subscription or voucher.
+ *
+ * @public
+ */
+declare type PurchaseType = 'transaction' | 'subscription' | 'voucher';
+
+/**
+ * @public
+ */
+declare interface ReactableContent {
+    path: string;
+    reactions: {
+        [key in ReactionEnum]?: number;
+    } | null;
+    updateReactionCount: (reaction: ReactionEnum, newCount: number) => void;
+    isFavorite?: boolean;
+    removeFromFavorites?: () => void;
+    addToFavorites?: () => void;
+}
+
+/**
+ * @public
+ */
+declare enum ReactionEnum {
+    LIKE = "LIKE",
+    DISLIKE = "DISLIKE",
+    LOVE = "LOVE",
+    HAHA = "HAHA",
+    WOW = "WOW",
+    SAD = "SAD",
+    ANGRY = "ANGRY",
+    CARE = "CARE",
+    SUPPORT = "SUPPORT",
+    PRAY = "PRAY",
+    THINK = "THINK",
+    CELEBRATE = "CELEBRATE",
+    THANKFUL = "THANKFUL",
+    LAUGH = "LAUGH",
+    INSPIRED = "INSPIRED",
+    AWW = "AWW"
+}
+
+/**
+ * @public
+ */
+declare type ReactNativeDeviceInfo = {
+    type: 'react-native';
+    /**
+     * Type values defined according to {@link OperatingSystem} from `detect-browser` package for convenience.
+     */
+    os?: 'iOS' | 'Android OS';
+    osVersion: string;
+    platform: PLATFORM;
+    isTablet?: boolean;
+};
+
+export declare type RemoteBundleState = {
+    state: 'loading' | 'error' | 'ready';
+    error: string | null;
+    conf: InternalConf;
+    settings: Settings;
+} & Omit<Partial<TivioJsBundleExposedApi>, 'createPlayerWrapper'>;
+
+export declare type RemoteProviderProps = {
+    language?: string;
+};
+
+/**
+ * Conditions that are dynamically applied to screens before they are rendered.
+ * eg. when we want to render an embed only if certain conditions are met.
+ * 'type' indicates type of the condition, eg. 'subscribed'.
+ * 'else' indicates what should happen if the conditions are not met.
+ * 'elseValue' is a payload.
+ */
+declare interface RenderCondition {
+    type: ScreenConditionType;
+    value?: RenderConditionValue[];
+    else: ScreenConditionElse;
+    elseValue: RenderConditionElseValue[];
+}
+
+declare interface RenderConditionElseValue {
+    key: string;
+    value: string;
+}
+
+declare interface RenderConditionValue {
+    subscriptionRefs?: any[];
+}
+
+/**
+ * @public
+ */
+declare interface Row {
+    id: string;
+    rowId: string;
+    name: string;
+    description?: string;
+    assets: AssetsField;
+    type: ScreenRowType;
+    isLiveRow: boolean;
+    tiles: PaginationInterface<ItemInRow>;
+    numberOfLines?: number;
+    monetizations?: {
+        monetizationRef: any;
+    }[];
+    rowComponent: RowComponent.ROW | RowComponent.BANNER;
+    itemComponent: RowItemComponent | BannerItemComponent;
+    organizationId?: string;
+    bottomComponent?: BottomComponent;
+    showDescriptionAsTitle?: boolean;
+}
+
+/**
+ * @public
+ */
+declare enum ROW_ITEM_TYPES {
+    APPLICATION = "APPLICATION",
+    VIDEO = "VIDEO",
+    TAG = "TAG",
+    TV_CHANNEL = "TV_CHANNEL",
+    ADVERTISEMENT = "ADVERTISEMENT",
+    ARTICLE = "ARTICLE",
+    SERIES = "SERIES"
+}
+
+/**
+ * @public
+ */
+declare enum RowComponent {
+    ROW = "ROW",
+    BANNER = "BANNER"
+}
+
+declare enum RowFilterCollection {
+    VIDEOS = "videos",
+    /**
+     * This is not real collection path. Path always should be ${organizationId}/tags
+     */
+    TAGS = "tags",
+    TV_CHANNELS = "tvChannels",
+    CONTENTS = "contents",
+    APPLICATIONS = "applications"
+}
+
+/**
+ * RowFilterField that is used in @tivio/firebase needs to be retyped here.
+ * @public
+ */
+declare interface RowFilterField {
+    collection: RowFilterCollection;
+    limit?: number;
+    orderBy?: {
+        fieldPath: RowOrderByFieldPath;
+        directionStr?: OrderByDirection;
+    };
+    where?: RowFilterWhereField[];
+}
+
+declare interface RowFilterWhereField {
+    fieldPath: RowWhereFilterFieldPath;
+    opStr: WhereFilterOp;
+    value: any;
+}
+
+/**
+ * @public
+ */
+declare interface RowItem extends RowItemAssets {
+    created?: Date;
+    itemType: ROW_ITEM_TYPES;
+    name?: string;
+    description?: string;
+    assets: AssetsField | null;
+    application: RowItemApplicationData | null;
+    feedVisible?: boolean;
+}
+
+/**
+ * @public
+ */
+declare interface RowItemApplicationData {
+    name: string;
+    logo?: string | null;
+    logoLandscape?: string | null;
+    profilePhoto?: string | null;
+    urlHandle: string;
+    organizationId?: string | null;
+}
+
+/**
+ * @public
+ */
+declare interface RowItemAssets {
+    landscape?: string | null;
+    portrait?: string | null;
+    circled?: string | null;
+    square?: string | null;
+    banner?: string | null;
+    bannerMobile?: string | null;
+}
+
+/**
+ * @public
+ */
+declare enum RowItemComponent {
+    ROW_ITEM_PORTRAIT = "ROW_ITEM_PORTRAIT",
+    ROW_ITEM_LANDSCAPE = "ROW_ITEM_LANDSCAPE",
+    ROW_ITEM_SQUARE = "ROW_ITEM_SQUARE",
+    ROW_ITEM_CREATORS_SQUARE = "ROW_ITEM_CREATORS_SQUARE",
+    ROW_ITEM_CREATORS_LANDSCAPE = "ROW_ITEM_CREATORS_LANDSCAPE",
+    ROW_ITEM_CIRCLED = "ROW_ITEM_CIRCLED",
+    ROW_ITEM_HIGHLIGHTED = "ROW_ITEM_HIGHLIGHTED",
+    ROW_ITEM_PLAIN = "ROW_ITEM_PLAIN"
+}
+
+/**
+ * RowOrderByFieldPath that is used in @tivio/firebase needs to be retyped here.
+ * @public
+ */
+declare enum RowOrderByFieldPath {
+    CREATED = "created",
+    DEFAULT_NAME = "defaultName"
+}
+
+declare enum RowWhereFilterFieldPath {
+    CREATED = "created",
+    TAGS = "tags",
+    TAG_TYPE_REF = "tagTypeRef",
+    TYPE = "type",
+    CONTENT_TYPE = "contentType",
+    CHANNEL_KEY = "channelKey",
+    PUBLISHED_STATUS = "publishedStatus",
+    ORGANIZATION_REF = "organizationRef",
+    TRANSCODING_STATUS = "transcodingStatus"
+}
+
+/**
+ * @public
+ */
+declare type ScalableAsset = {
+    '@1': Asset;
+    '@2'?: Asset;
+    '@3'?: Asset;
+};
+
+/**
+ * @public
+ */
+declare interface Screen_2 {
+    id: string;
+    name: string | null;
+    description?: string | null;
+    assets: AssetsField;
+    rows: PaginatedResponse<Row>;
+    type?: ScreenType;
+    filter?: RowFilterField | null;
+    embedUrl?: string;
+    screenId: string;
+    renderConditions: RenderCondition[];
+    getRenderCondition: (context: {
+        purchasedSubscriptions: Purchase[];
+    }) => RenderCondition | undefined;
+    applyRenderCondition: (payload: ApplyScreenConditionPayload) => {
+        isSignInRequired?: boolean;
+        isPurchaseRequired?: boolean;
+        embedUrl?: string;
+    };
+    fetchMoreRows: () => Promise<void>;
+    hasNextPage: boolean;
+    refetchIfNeeded: () => Promise<void>;
+}
+
+declare enum ScreenConditionElse {
+    SET_QUERY_PARAMS = "setQueryParams",
+    SHOW_PURCHASE_MODAL = "showPurchaseModal"
+}
+
+declare enum ScreenConditionType {
+    SUBSCRIBED = "subscribed",
+    SIGNED_IN = "signedIn"
+}
+
+/**
+ * @public
+ */
+declare type ScreenConfig = {
+    id: string;
+    name: string;
+    route?: string;
+    isHiddenFromMenu?: boolean;
+    showForUserProfileType?: {
+        kids: boolean;
+        adults: boolean;
+    };
+    monetizationAccessIds?: string[];
+};
+
+/**
+ * @public
+ */
+declare type ScreenRowType = 'filter' | 'custom' | 'continueToWatch' | 'favourites' | 'topWatched' | 'applications';
+
+declare enum ScreenType {
+    DEFAULT = "default",
+    GRID = "grid",
+    EMBED = "embed",
+    RECOMMENDATION = "recommendation",
+    FEED = "feed",
+    EPG = "epg"
+}
+
+/**
+ * @public
+ */
+declare interface SeekingMatrix {
+    url: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    interval: number;
+    timeMs: number;
+}
+
+/**
+ * @public
+ */
+declare interface SeekingMatrixTemplate {
+    pattern: string;
+    width: number;
+    height: number;
+    columns: number;
+    rows: number;
+    interval: number;
+}
+
+/**
+ * @public
+ */
+declare interface SendMessageResponse {
+    conversationId: string;
+    messageId?: string;
+}
+
+/**
+ * @public
+ */
+declare interface Series extends RowItem, MonetizableItem, ReactableContent {
+    id: string;
+    itemType: ROW_ITEM_TYPES.SERIES;
+    cover: string;
+    organizationId?: string;
+    /**
+     * Only used for non migrated series
+     */
+    originalSeriesTagRef?: any;
+    ref: DocumentReference<any>;
+    availableSeasons: AvailableSeason[];
+    actors?: DocumentReference<any>[];
+    linkedContent?: {
+        type: ContentType;
+        contentRef: DocumentReference<any>;
+    }[];
+    seriesDetailArticle?: Article;
+    originalTagId?: string;
+}
+
+declare type Settings = {
+    onSetUser: (handler: (userId: string, userPayload: unknown) => void) => void;
+    setUser: (userId: string, userPayload: unknown) => void;
+};
+
+/**
+ * @public
+ */
+declare type Source = TvProgramSource | TivioVodSource | AdSource | OtherSource | LiveTvChannelSource;
+
+/**
+ * @public
+ */
+declare type SourceBase = {
+    /**
+     * Tivio SDK users may use pretty complicated source objects in their existing code and if Tivio player
+     * is an interception layer, it should allow them to pass through any type of object.
+     */
+    additionalPayload?: Record<string, any>;
+    /**
+     * Source type.
+     */
+    type: 'ad' | 'live_tv_channel' | 'other' | 'tivio_vod' | 'tv_program';
+    /**
+     * URI to play.
+     */
+    uri: string;
+};
+
+/**
+ * Based on this value player will change how the source is played. This, for example, affects whether source:
+ *  - will be seekable or not
+ *  - duration will be dynamically updated as time goes on
+ *  - live button will be shown in ui
+ */
+declare enum SourcePlayMode {
+    ON_DEMAND = "ON_DEMAND",
+    LIVE = "LIVE",
+    /**
+     * ON_DEMAND and LIVE at the same time.
+     */
+    HYBRID = "HYBRID"
+}
+
+/**
+ * @public
+ */
+declare enum SourceType {
+    ADVERTISEMENT = "ad",
+    CHANNEL = "channel",
+    VOD_TIVIO = "vod_tivio",
+    VOD_EXTERNAL = "vod_external"
+}
+
+/**
+ * @public
+ */
+declare type StartAndContinuePosition = {
+    /**
+     * Relative from stream start, in ms.
+     *
+     * On input to Tivio either `startFromPosition` or `continueFromPosition` must always be provided.
+     *
+     * On output from Tivio it is always defined. Tivio can change this value.
+     * (e.g. in order to fix start position of a TV program)
+     */
+    startFromPosition?: number;
+    /**
+     * Relative from stream start, in ms.
+     *
+     * On input to Tivio either `startFromPosition` or `continueFromPosition` must always be provided.
+     *
+     * If provided, tivio will not correct it and will send this value back in startFromPosition.
+     * If provided, startFromPosition is ignored.
+     */
+    continueFromPosition?: number;
+};
+
+/**
+ * @public
+ */
+declare interface StorageManager_2 {
+    getItem(key: string): string | null | Promise<string | null>;
+    setItem(key: string, value: string): void | Promise<void>;
+    removeItem(key: string): void | Promise<void>;
+}
+
+/**
+ * @public
+ */
+declare type SubscribeToItemsInRow = (rowId: string, cb: (error: Error | null, data: PaginationInterface<ItemInRow> | null) => void, options?: SubscribeToItemsInRowOptions, organizationId?: string) => Disposer_2;
+
+/**
+ * @public
+ */
+declare type SubscribeToItemsInRowOptions = Partial<{
+    fetchTags: boolean;
+    orderBy?: OrderBy<'defaultName' | DefaultOrderByField>[];
+    where?: WhereFilter[];
+}> & PaginationOptions;
+
+/**
+ * @public
+ */
+declare type SubscribeToRowsInScreen = (screenId: string, cb: (error: Error | null, data: PaginationInterface<Row> | null) => void, options?: PaginationOptions) => Disposer_2;
+
+/**
+ * @public
+ */
+declare type SubscribeToTaggedVideos = (tagIds: string[], cb: (error: Error | null, data: PaginationInterface<Video> | null) => void, options?: SubscribeToTaggedVideosOptions, organizationPath?: string) => Disposer_2;
+
+/**
+ * @public
+ */
+declare type SubscribeToTaggedVideosOptions = Omit<SubscribeToItemsInRowOptions, 'orderBy'> & {
+    orderBy?: OrderBy<TaggedVideosOrderByField>[];
+};
+
+/**
+ * @public
+ */
+declare interface Tag extends RowItem {
+    id: string;
+    itemType: ROW_ITEM_TYPES.TAG;
+    tagId: string;
+    type?: string | null;
+    metadata?: TagMetadataField[];
+    color?: string;
+    detailBanner?: string;
+    availableSeasons?: AvailableSeason[];
+    isFavorite: boolean;
+    addToFavorites: () => void;
+    removeFromFavorites: () => void;
+    cover: string;
+    getApplicationName: () => string | undefined;
+    seriesRef?: DocumentReference<any>;
+    fetchData: () => Promise<void>;
+    getSeriesEntity: (path: string) => Promise<Series>;
+    ref: DocumentReference<any>;
+    seriesEntity: Series | null;
+    tagType: {
+        tagTypeId: string | null;
+    } | null;
+    initSeries: () => Promise<void>;
+}
+
+declare interface TagAvailableSeasonsFieldType extends TagMetadataFieldDefinition {
+    type: TagMetadataFieldType.AVAILABLE_SEASONS;
+    value: AvailableSeasonField[];
+}
+
+declare interface TagBooleanFieldType extends TagMetadataFieldDefinition {
+    type: TagMetadataFieldType.BOOLEAN;
+    value: boolean;
+}
+
+/**
+ * @public
+ */
+declare type TaggedVideosOrderByField = 'seasonNumber' | 'episodeNumber' | 'contentType' | DefaultOrderByField;
+
+declare type TagMetadataField = TagStringFieldType | TagNumberFieldType | TagBooleanFieldType | TagTranslationFieldType | TagAvailableSeasonsFieldType | TagOrganizationRefFieldType;
+
+declare interface TagMetadataFieldDefinition {
+    key: string;
+    type: TagMetadataFieldType;
+}
+
+declare enum TagMetadataFieldType {
+    STRING = "STRING",
+    TRANSLATION = "TRANSLATION",
+    NUMBER = "NUMBER",
+    BOOLEAN = "BOOLEAN",
+    AVAILABLE_SEASONS = "AVAILABLE_SEASONS",
+    ORGANIZATION_REF = "ORGANIZATION_REF"
+}
+
+declare interface TagNumberFieldType extends TagMetadataFieldDefinition {
+    type: TagMetadataFieldType.NUMBER;
+    value: number;
+}
+
+declare interface TagOrganizationRefFieldType extends TagMetadataFieldDefinition {
+    type: TagMetadataFieldType.ORGANIZATION_REF;
+    value: DocumentReference<any>;
+}
+
+declare interface TagStringFieldType extends TagMetadataFieldDefinition {
+    type: TagMetadataFieldType.STRING;
+    value: string;
+}
+
+declare interface TagTranslationFieldType extends TagMetadataFieldDefinition {
+    type: TagMetadataFieldType.TRANSLATION;
+    value: Translation;
+}
+
+/**
+ * @public
+ */
+declare interface TivioAuth {
+    /**
+     * @param email
+     * @param password
+     */
+    createUserWithEmailAndPassword: CreateUserWithEmailAndPassword;
+    /**
+     * Sign in the user and starts listening on his purchases
+     * @param email
+     * @param password
+     */
+    signInWithEmailAndPassword: (email: string, password: string) => Promise<string | null>;
+    signInWithCustomToken: (token: string) => Promise<string | null>;
+    signOut: () => Promise<void>;
+    /**
+     * Used for reset forgotten password by user
+     */
+    resetPassword: (email: string) => Promise<void>;
+}
+
+export declare type TivioBundle = TivioJsBundle;
+
+export declare let tivioBundle: RemoteBundleState | null;
+
+/**
+ * @public
+ */
+declare interface TivioConfig {
+    /**
+     * Tells Tivio which technologies/protocols etc. is the device capable to play.
+     * If not provided, Tivio will try to guess it (based on the browser).
+     */
+    deviceCapabilities?: PlayerCapability_2[];
+    /**
+     * Additional options for deviceCapabilities
+     */
+    capabilitiesOptions?: {
+        /**
+         * Should the player prefer HTTP sources instead HTTPs if they are available.
+         * This can be used on platforms that support mixed content but do not support
+         * specific HTTPS certificates. (e.g. certificates from Letsencrypt not supported on LG TVs)
+         */
+        preferHttp?: boolean;
+    };
+    secret: string;
+    language: LangCode;
+    debug?: boolean;
+    verbose?: boolean;
+    firebaseApp?: any | null;
+    firebaseFactory?: (config: Object, appName?: string) => firebase.FirebaseApp;
+    authDomainOverride?: string;
+    firestore?: any | null;
+    currency: Currency;
+    applicationId?: string;
+    isTivioProApp?: boolean;
+    lockApplicationHandle?: string;
+    /**
+     * Configuration for GDPR consent collection (CMP)
+     */
+    cmp?: CmpConfig;
+    /**
+     * Device information - model, os, version, etc. This is useful for devices
+     * where this information cannot be reliably auto-detected.
+     */
+    deviceInfo?: DeviceInfo;
+    player?: PlayerConfig;
+    /**
+     * Used for purposes where we need to differentiate organizations before it is known based on secret and data from DB.
+     *
+     * At this time it is necessary only for LG builds because on LG TVs it is needed to separate apps indexedDB storages
+     * (otherwise organizations would share login token).
+     */
+    customerId?: CustomerId;
+}
+
+/**
+ * @public
+ */
+declare type TivioGetters = {
+    isTivioLoaded: (cb: (isLoaded: boolean) => void) => void;
+    isSignedIn: () => boolean;
+    /**
+     * Get (or create) player wrapper instance
+     * @param opt - player getter options
+     * @returns {PlayerWrapper} player wrapper instance
+     */
+    getPlayerWrapper: (opt: {
+        playerWrapperId?: string;
+    }) => PlayerWrapper_2;
+    organization: {
+        /**
+         * Get organization subscriptions
+         * @returns {Promise<Monetization[] | undefined>} organization subscriptions or undefined if organization does not exists
+         */
+        getSubscriptions: () => Promise<Monetization[] | undefined>;
+    };
+    /**
+     * Get video by its id.
+     * @param videoId - video id
+     * @returns {Promise<Video | null>} video or null if video does not exists
+     */
+    getVideoById: (videoId: string) => Promise<Video | null>;
+    /**
+     * Get screen by its id.
+     * @param screenId - screen id
+     * @returns {Promise<Screen | null>} screen or null if screen does not exists
+     */
+    getScreenById: (screenId: string, cb?: (error: Error | null, data: Screen_2 | null, disposer?: Disposer_2) => void) => Promise<Screen_2 | null>;
+    /**
+     * Get player capabilities based on user's browser and OS as resolved by Tivio.
+     * @returns PlayerCapability[]
+     */
+    getPlayerCapabilities: () => PlayerCapability_2[];
+};
+
+/**
+ * @internal
+ */
+declare type TivioJsBundle = TivioJsBundleExposedApi & {
+    init: (config: TivioConfig) => void | Promise<void>;
+    tivio: any;
+};
+
+/**
+ * @public
+ */
+declare type TivioJsBundleExposedApi = {
+    AdSource: any;
+    ChannelSource: any;
+    VodTivioSource: any;
+    /**
+     * Get (or create) player wrapper instance
+     * @param id - player wrapper id
+     * @returns {Player} player wrapper instance
+     */
+    getPlayerWrapper: (id: string) => Player;
+    /**
+     * Get tv channel by its id.
+     * @param tvChannelId - tv channel id
+     * @returns {Promise<TvChannel | null>} channel or null if tv channel does not exists
+     */
+    getTvChannelById: (tvChannelId: string) => Promise<TvChannel | null>;
+    /**
+     * Get tag by its id.
+     * @param tagId - tag id
+     * @returns {Promise<Tag | null>} widget or null if tag does not exists
+     */
+    getTagById: (tagId: string) => Promise<Tag | null>;
+    createPlayerWrapper: (playerImplementation: PlayerInterfaceForPlayerWrapper) => TivioPlayerWrapper;
+    destroy: () => Promise<void>;
+} & Pick<TivioGetters, 'getVideoById' | 'getScreenById' | 'organization'> & Pick<TivioSubscriptions, 'subscribeToVideo' | 'subscribeToItemsInRow' | 'subscribeToRowsInScreen'> & Pick<TivioAuth, 'createUserWithEmailAndPassword' | 'signInWithEmailAndPassword'> & Pick<TivioSetters, 'setBundleVersion' | 'setUser' | 'setLanguage' | 'setStorageManager'>;
+
+/**
+ * @public
+ */
+declare interface TivioPlayerWrapper {
+    addEventListener: (eventType: PlayerWrapperEventTypeType, listener: Listener) => void;
+    reportError: (error: Error) => void;
+    reportPlaybackEnded: () => void;
+    reportTimeProgress: (ms: number) => void;
+    seekTo: (ms: number) => void;
+    /**
+     * @param {Source} source - source to set
+     * @param {string} calibrationId - id of calibration profile
+     */
+    setSource: (source: Source | null, calibrationId?: string) => void;
+}
+
+/**
+ * @public
+ */
+declare type TivioSetters = {
+    setBundleVersion: (bundleVersion: string | null) => void;
+    /**
+     * Set tivio language.
+     * @param language
+     */
+    setLanguage: (language: LangCode) => void;
+    setStorageManager: (storageManager: StorageManager_2) => void;
+    setUser: (userId: string | null, userPayload?: UserPayload) => Promise<void>;
+};
+
+/**
+ * @public
+ */
+declare type TivioSubscriptions = {
+    subscribeToUser: (cb: (error: string | null, user: User | null) => void) => void;
+    /**
+     * Listen to video changes.
+     * @param videoId - video id
+     * @param cb - callback on video updates or on error
+     */
+    subscribeToVideo: (videoId: string, cb: (error: Error | null, data: Video | null, disposer?: Disposer_2) => void) => void;
+    subscribeToItemsInRow: SubscribeToItemsInRow;
+    subscribeToRowsInScreen: SubscribeToRowsInScreen;
+    subscribeToTaggedVideos: SubscribeToTaggedVideos;
+    registerOverlayCallbacks: (callbacks: {
+        onShow: () => void;
+        onHide: () => void;
+    }) => void;
+};
+
+/**
+ * @public
+ */
+declare type TivioVodSource = SourceBase & StartAndContinuePosition & {
+    type: 'tivio_vod';
+    /**
+     * Allows Tivio to load monetization config an apply ads.
+     */
+    videoPath: string;
+};
+
+declare interface TokenInterface {
+    token: string;
+    expirationDate: Date;
+    type: TokenType;
+    active: boolean;
+}
+
+declare type TokenType = 'rss';
+
+/**
+ * @public
+ * Video track
+ */
+declare interface Track {
+    id: number;
+    /**
+     * e.g. 480, 720, 1080
+     */
+    height: number;
+    width: number;
+    active: boolean;
+    language: LangCode;
+}
+
+/**
+ * Represents one string in every supported language mutation.
+ * @public
+ */
+declare type Translation = {
+    [key in LangCode]?: string;
+};
+
+/**
+ * @public
+ */
+declare interface TvChannel extends RowItem {
+    id: string;
+    itemType: ROW_ITEM_TYPES.TV_CHANNEL;
+    name: string;
+    path: string;
+    country?: string;
+    filters: string[];
+    logo?: string;
+    logoPendingOverlayWidth?: string;
+    hls: string;
+    dash: string;
+    /**
+     * Returns all transactions and subscriptions applied to this tv channel.
+     * Transactions before subscriptions, sorted by price ascending.
+     */
+    getPurchasableMonetizations(options?: GetPurchasableMonetizationsOptions): PurchasableMonetization[];
+    getSourceUrl(options?: {
+        language?: LangCode;
+    }): Promise<GetSourceUrlResponse & {
+        language?: LangCode;
+    }>;
+    purchasableMonetization: any | null;
+    price: number;
+    cover: string;
+    isPlayable: boolean;
+    url: string;
+    type?: TvChannelType;
+}
+
+declare enum TvChannelType {
+    /**
+     * Classic live tv channel
+     */
+    CLASSIC = "CLASSIC",
+    /**
+     * "Virtual" tv channel constructed from separate videos
+     */
+    VIRTUAL = "VIRTUAL"
+}
+
+/**
+ * @public
+ */
+declare type TvMode = 'startover' | 'timeshift';
+
+declare interface TvProgram {
+    id: string;
+    from: Date | null;
+    to: Date | null;
+    name: string;
+    description: string;
+    url: string;
+    image: string;
+    landscape?: string | null;
+    video: Video | null;
+    tvChannelRef?: any;
+    loadVideo?: () => Promise<void>;
+}
+
+/**
+ * @public
+ */
+declare type TvProgramSource = SourceBase & StartAndContinuePosition & {
+    type: 'tv_program';
+    /**
+     * If epgTo is wrong, Tivio cannot correctly guess if the video it startover or timeshift . For such cases
+     * Tivio needs explicit tv mode.
+     * null if source begins in the future.
+     */
+    tvMode: 'startover' | 'timeshift' | null;
+    /**
+     * Tivio needs channel name in order to load markers.
+     */
+    channelName: string;
+    /**
+     * Tivio needs EPG from in order to load markers.
+     */
+    epgFrom: Date;
+    /**
+     * Tivio needs EPG to in order to load markers.
+     */
+    epgTo: Date;
+    /**
+     * When the stream (provided in uri) really starts - typically few minutes before epgFrom.
+     */
+    streamStart: Date;
+};
+
+/**
+ * @public
+ */
+declare type User = {
+    /**
+     * Unique id of the corresponding user document.
+     */
+    id: string;
+    /**
+     * Returns "active" (non-expired) purchases so they give access to some content.
+     * Does not return voucher purchases because they give access to videos/subscriptions only for user who activates voucher
+     * not for user who purchases it.
+     */
+    purchases: Purchase[];
+    /**
+     * Returns all PAID or CANCELLED user purchases (expired and non-expired)
+     */
+    allPurchases: Purchase[];
+    availablePromotionsIds: string[];
+    /**
+     * Returns "active" (not CANCELLED) VoD purchases ("transaction" type)
+     */
+    purchasedVods: Purchase[];
+    /**
+     * Returns "active" (non-expired) subscription purchases
+     */
+    purchasedSubscriptions: Purchase[];
+    /**
+     * Returns last expired subscription which user can renew or undefined
+     */
+    extendableSubscription?: Purchase;
+    getPurchasedVideos: () => unknown[];
+    getOneTimePurchases: () => Purchase[];
+    isPurchasesInitialized: boolean;
+    isSignedIn: boolean;
+    isReady: boolean;
+    email?: string;
+    type?: UserType;
+    photoURL: string | null;
+    name?: string;
+    /**
+     * Authentication id differs from {@link id}.
+     */
+    authUserId?: string;
+    favorites: any[];
+    watchedPositions: any[];
+    watchHistory: any[];
+    profiles: any[];
+    activeUserProfileId: string | null;
+    patreon?: PatreonUserAuth;
+    subscriptionIdsToShow: string[] | null;
+    followedOrganizationIds: string[];
+    isAnonymous: boolean;
+    isDiscordConnected: boolean;
+    disconnectDiscord: () => Promise<void>;
+    createUserProfile: (request: any) => Promise<void>;
+    deleteUserProfile: (profileId: string) => Promise<void>;
+    setActiveUserProfileId: (id: string) => void;
+    getFollowedOrganizations: () => Promise<Array<FollowedOrganizationData | undefined>>;
+    sendFinalizeRegistrationEmail: (email: string) => Promise<void>;
+    isUserAlreadyRegisteredByTenant: (email: string) => Promise<boolean>;
+    getAllExtendableSubscriptions: () => Promise<Purchase[]>;
+    getRssValidToken: () => Promise<TokenInterface | undefined>;
+    getRssUrl: () => Promise<GetUserRssUrlResponse>;
+    invalidateAllTokens: (type: TokenType) => Promise<void>;
+    isPartiallyRegistered: boolean;
+    conversationStore: ConversationStore;
+};
+
+/**
+ * @public
+ */
+declare type UserPayload = Record<string, any>;
+
+/**
+ * @public
+ */
+declare enum UserType {
+    ORGANIZATION_USER = "ORGANIZATION_USER",
+    TIVIO_USER = "TIVIO_USER"
+}
+
+/**
+ * @public
+ * null - classic VAST
+ * VPAID - VAST with VPAID extension
+ * others...
+ */
+declare type VastApiFramework = string | 'VPAID' | null;
+
+/**
+ * @public
+ */
+declare enum VastProvider {
+    CNC_PREBID = "cnc-prebid",
+    CNC_STARGAZE_PREROLL_1 = "cnc-stargaze-preroll-1",
+    CNC_STARGAZE_PREROLL_2 = "cnc-stargaze-preroll-2",
+    CNC_STARGAZE_MIDROLL = "cnc-stargaze-midroll",
+    ETARGET_PREBID = "etarget-prebid",
+    FALLBACK_HLS = "fallback-hls",
+    FALLBACK_MP4 = "fallback",
+    GARAZ_TV = "garaz.tv",
+    GARAZ_TV_DEV = "garaz.tv.dev",
+    IMPRESSION_MEDIA_PREBID = "impressionMedia-prebid",
+    JOJ_ADFORM = "joj",
+    JOJ_SMART = "joj-smart",
+    JOJ_AD_MANAGER_VOD_PREROLL = "joj-ad-manager-vod-preroll",
+    JOJ_AD_MANAGER_VOD_MIDROLL = "joj-ad-manager-vod-midroll",
+    JOJ_AD_MANAGER_LIVE_PREROLL = "joj-ad-manager-live-preroll",
+    MALL_TV = "malltv",
+    MALL_TV_PREBID = "malltv-prebid",
+    PRIMA = "prima",
+    TEST = "test",
+    TEST_VPAID = "test-vpaid",
+    TIVIO_ADS = "tivio-ads",
+    JOJ_TEST_AD_FORM_PROGRAMMATIC = "joj-test-ad-form-programmatic",
+    JOJ_TEST_TESTER_VASTERIX = "joj-test-tester-vasterix",
+    JOJ_TEST_TESTER_ADFORM_30 = "joj-test-tester-adform-30"
+}
+
+/**
+ * @public
+ */
+declare interface Video extends RowItem, MonetizableItem, ReactableContent {
+    id: string;
+    itemType: ROW_ITEM_TYPES.VIDEO;
+    /**
+     * @deprecated use assets instead
+     */
+    cover: string | null;
+    sectionId: string | null;
+    channelId: string | null;
+    duration: number;
+    path: string;
+    tags: Tag[];
+    image: string | null;
+    isPlayable: boolean;
+    monetizations: Monetization[];
+    getSourceUrl(options?: {
+        language?: LangCode;
+    }): Promise<GetSourceUrlResponse & {
+        language?: LangCode;
+    }>;
+    getSeekingMatrixPreviewByTime(timeMs: number, offsetIndex?: number): SeekingMatrix | null;
+    purchasableMonetization: any | null;
+    transaction: PurchasableMonetization | undefined;
+    subscriptions: PurchasableMonetization[];
+    sources?: any[];
+    allSources?: any[];
+    isPlaylist: boolean;
+    name: string;
+    urlNames?: string[];
+    urlName?: string;
+    price: number | null;
+    detailedPrice: DetailedPrice | null;
+    url: string;
+    adMonetizationId?: string;
+    from?: Date;
+    to?: Date;
+    detailBanner?: string;
+    descriptionRich?: string;
+    organizationId?: string;
+    linkedVideosRaw: LinkedVideoRaw[] | undefined;
+    linkedVideos: LinkedVideo[] | undefined;
+    pipPaths?: string[];
+    contentType: VideoContentType | null;
+    year?: number;
+    episodeNumber?: number;
+    seasonNumber?: number;
+    getTagsOfType: (type: string) => Tag[];
+    geoBlocking: GeoBlocking | undefined;
+    loadLinkedVideos: () => any;
+    getLinkedVideos: (type: any) => any;
+    trailer: Video | null;
+    teaser: Video | null;
+    hasTasting: boolean;
+    isTastingValid: () => boolean;
+    tasting: Video | null;
+    watchPosition: number | null;
+    isFavorite: boolean;
+    addToFavorites: () => void;
+    removeFromFavorites: () => void;
+    availability: ContentAvailability | null;
+    sourceLanguages: LangCode[];
+    urlByLanguage: (lang: LangCode) => string | undefined;
+    getApplicationName: () => string | undefined;
+    getApplicationLogo: () => string | undefined;
+    setApplicationData: (applicationData: RowItemApplicationData) => void;
+    linkedVideosInNotLoaded: () => boolean | undefined;
+    initApplication: () => Promise<void>;
+    init: () => Promise<void>;
+    progress?: number;
+    backgroundBlurBannerMobile?: string | null;
+    isWatched?: boolean;
+    pgRating?: string;
+    contentDescriptors?: string[];
+    publishedStatus?: PublishedStatus;
+}
+
+/**
+ * @public
+ */
+declare enum VideoContentType {
+    /**
+     * Default video content type
+     */
+    VIDEO = "VIDEO",
+    FILM = "FILM",
+    SERIES = "SERIES"
+}
+
+declare enum VideoSourceCodec {
+    H264 = "h264",
+    H265 = "h265",
+    MPEG_2 = "MPEG-2"
+}
+
+declare enum VideoSourceEncryption {
+    NONE = "none",
+    WIDEVINE = "widevine",
+    FAIRPLAY = "fairplay",
+    PLAYREADY = "playready"
+}
+
+declare enum VideoSourceProtocol {
+    HLS = "hls",
+    DASH = "dash",
+    MP4 = "mp4",
+    MP3 = "mp3"
+}
+
+/**
+ * @public
+ */
+declare interface VirtualChannelSourceInterface extends ChannelSourceInterface {
+    tvChannelType: TvChannelType.VIRTUAL;
+    program?: TvProgram | null;
+    video?: Video | null;
+    clone(params?: Partial<VirtualChannelSourceParams>): VirtualChannelSourceInterface;
+    initializeNext(): Promise<void>;
+}
+
+/**
+ * @public
+ */
+declare interface VirtualChannelSourceParams extends ChannelSourceParams {
+    tvChannelType: TvChannelType.VIRTUAL;
+    currentProgram?: TvProgram | null;
+    drm?: Drm;
+}
+
+/**
+ * @public
+ */
+declare interface VodExternalSourceInterface extends PlayerSourceInterface<SourceType.VOD_EXTERNAL> {
+    monetizationId?: string;
+    originalOptions: Record<string, any>;
+    poster: string | null;
+}
+
+/**
+ * @public
+ */
+declare interface VodTivioSourceInterface extends PlayerSourceInterface<SourceType.VOD_TIVIO> {
+    /**
+     * e.g. 259ud0fgdf4
+     */
+    adMonetizationId?: string;
+    /**
+     * e.g. videos/1532543
+     */
+    videoPath: string;
+    poster: string | null;
+    /**
+     * Position to continue playing from in milliseconds
+     */
+    continuePositionMs?: ContinuePosition;
+    /**
+     * Drm configuration
+     */
+    drm?: Drm;
+    watermark: Watermark | null;
+    canWatchOnDevice: boolean;
+    isAvailable: boolean;
+    availability: ContentAvailability | null;
+    video: Video;
+    clone: (params?: Partial<VodTivioSourceParams>) => VodTivioSourceInterface;
+}
+
+/**
+ * @public
+ */
+declare interface VodTivioSourceParams extends PlayerSourceParams<SourceType.VOD_TIVIO> {
+    videoPath: string;
+    adMonetizationId?: string;
+    language?: LangCode;
+    drm?: Drm;
+    ignoreWatchPosition?: boolean;
+}
+
+/**
+ * @public
+ */
+declare interface Watermark {
+    caption: string;
+    size: 'large' | 'medium';
+}
+
+/**
+ * @public
+ */
+declare interface WhereFilter {
+    field: string;
+    operator: WhereFilterOp;
+    value: any;
+}
+
+declare type WhereFilterOp = '<' | '<=' | '==' | '!=' | '>=' | '>' | 'array-contains' | 'in' | 'array-contains-any' | 'not-in';
+
+export { }