@tivio/sdk-react 3.5.1 → 3.6.1

package/dist/index.d.ts

@@ -1,21 +1,1729 @@
-import 'whatwg-fetch';
-import 'es7-object-polyfill';
-export { PlayerProvider, withPlayerContext } from './components/PlayerProvider';
-export type { PlayerProviderProps } from './components/PlayerProvider';
-export { bundlePromise } from './services/bundlePromise';
-export * from './components/hooks';
-export * from './components/TivioProvider';
-export * from './components/TivioWidget';
-export * from './components/TivioWidgetError';
-export * from './components/TvTivioProvider';
-export * from './components/TivioWidgetLoader';
-export * from './types/customPlayer.types';
-export * from './services/bundleLoader';
-export * from './services/pubSub';
-export * from './types/types';
-export { Disposer } from './types/common';
-export { Empty } from './types/common';
-export { Nullable } from './types/common';
-export * from './types/bundle.types';
-export { setUser } from './services/login';
-export { showGdprConsentPreferences } from './services/gdpr';
+import { ComponentType } from 'react';
+import { default as firebase_2 } from 'firebase';
+import type { default as firebase_3 } from 'firebase/app';
+import { FunctionComponentElement } from 'react';
+import { OrderByDirection } from '@firebase/firestore-types';
+import { default as React_2 } from 'react';
+import { WhereFilterOp } from '@firebase/firestore-types';
+
+declare type 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;
+};
+
+export declare type AdSource = {
+    new (uri: string, name: string, description: string, skipDelayMs: number | null, adDurationMs: number, trackingContext?: any, // internal Tivio types
+    adMarker?: any, // internal Tivio types
+    packInfo?: any, // internal Tivio types
+    provider?: any): AdSource;
+    description: string;
+    name: string;
+    uri: string;
+    durationMs: number;
+    skipDelayMs: number | null;
+    type: 'ad';
+    /**
+     * 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 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;
+    /**
+     * Total number of ads in ad break (ad break is a group of ads played right after each other)
+     */
+    totalCount: number;
+    secondsToEnd: number;
+    secondsToSkippable: number | null;
+};
+
+/**
+ * Index names in Algolia search engine.
+ *
+ * @public
+ */
+export declare enum ALGOLIA_INDEX_NAME {
+    VIDEOS = "videos",
+    VIDEOSDESC = "videos_created_desc",
+    TAGS = "tags",
+    TV_CHANNELS = "tvChannels",
+    USERS = "users"
+}
+
+declare interface Asset {
+    background: string;
+}
+
+declare type Assets = {
+    [assetName: string]: ScalableAsset;
+};
+
+declare type AuthOverlayPayload = {
+    prefilledData?: {
+        email: string;
+    };
+    /**
+     * "Goto" function (see router.utils.ts) to run after the overlay is closed. Null if no redirect is required.
+     * Defaults to homepage.
+     */
+    redirectAfterSubmit?: ((...args: any[]) => void) | null;
+};
+
+declare type AuthOverlayState = {
+    type: AuthOverlayType;
+    closeAuthOverlay: () => void;
+    openAuthOverlay: (type: AuthOverlayType, payload?: AuthOverlayPayload) => void;
+    payload?: AuthOverlayPayload | null;
+};
+
+declare type AuthOverlayType = 'login' | 'registration' | 'closed' | 'reset-password';
+
+declare interface AvailableSeason {
+    seasonNumber: number;
+}
+
+export declare type BadRequestError = Error & {
+    details?: {
+        reason?: 'DOES_NOT_EXIST' | 'EXPIRED' | 'ALREADY_USED';
+    };
+};
+
+export declare type BetOffer = {
+    betService: string;
+    league: string;
+    odds: {
+        winner: string;
+        rate: number;
+    }[];
+    sport: string;
+    opponent1: string;
+    opponent2: string;
+    time: Date;
+};
+
+/**
+ * rejects when bundle is not available
+ */
+export declare const bundlePromise: Promise<RemoteBundleState>;
+
+export declare type Channel = {
+    id: string;
+    name: string;
+    header: string;
+    headerLogo: string;
+    recentVideos: Video[];
+};
+
+declare interface Channel_2 {
+}
+
+export declare const ChannelsContext: React_2.Context<DataState<Channel_2>>;
+
+export declare type ChannelSource = {
+    new (uri: string, originalOptions: Record<string, any>, channelName: string, programName: string, programDescription: string, from: Date, to: Date): ChannelSource;
+    description: string;
+    name: string;
+    uri: string;
+    from: Date;
+    channelName: string;
+    to: Date;
+    type: 'channel';
+    watchWithoutAdsRecommendation: {
+        showPurchaseDialog: () => void;
+    } | null;
+};
+
+declare interface ChannelSource_2 {
+    type: 'ChannelSource';
+    uri: string;
+    originalOptions: any;
+    channelName: string;
+    programName: string;
+    programDescription: string;
+    from: Date;
+    to: Date;
+    poster?: string;
+}
+
+export declare interface ChannelSourcePojo {
+    type: 'ChannelSource';
+    uri: string;
+    originalOptions: any;
+    channelName: string;
+    programName: string;
+    programDescription: string;
+    from: Date;
+    to: Date;
+    poster?: string;
+}
+
+export declare type Chapter = any;
+
+export declare type Config = Pick<InternalConfig, 'bundleUrlOverride' | 'currency' | 'disableUnmounting' | 'capabilitiesOptions' | 'enable' | 'enableSentry' | 'ErrorComponent' | 'language' | 'LoaderComponent' | 'logger' | 'secret' | 'verbose' | 'forceCloudFnResolver'> & {
+    deviceCapabilities: PlayerCapability[] | 'auto';
+    /**
+     * @private
+     * Run HTML, CSS and JS feature support check
+     */
+    runFeatureSupportCheck?: boolean;
+};
+
+declare type CoverPadding = {
+    top?: number;
+    bottom?: number;
+    left?: number;
+    right?: number;
+};
+
+export declare const createPubSub: () => PubSub;
+
+/**
+ * Fetch & load CommonJS remote module.
+ */
+export declare const createRemotePackageLoader: () => (secret: string, conf: InternalConfig) => Promise<TivioBundle>;
+
+export declare const createUseRemoteBundle: () => (conf: InternalConfig) => RemoteBundleState;
+
+declare type CreateUserWithEmailAndPassword = (email: string, password: string, username?: string, referralToken?: string) => Promise<string | null>;
+
+export declare type Currency = 'CZK' | 'EUR' | 'USD';
+
+export declare enum CUSTOMER_BUILD {
+    OKTAGON = "OKTAGON",
+    JOJ = "JOJ",
+    MALL = "MALL",
+    GARAZ = "GARAZ",
+    U_KULATEHO_STOLU = "U_KULATEHO_STOLU",
+    INVESTOREES = "INVESTOREES"
+}
+
+declare interface DataState<T> {
+    data: {
+        [key: string]: HookData<T>;
+    };
+    setData: (key: string, data: HookData<T>) => void;
+}
+
+declare type DefaultOrderByField = 'created';
+
+declare type DetailedPrice = {
+    amount: number;
+    currency: Currency;
+    frequency?: MONETIZATION_FREQUENCY;
+};
+
+export declare type Disposer = () => void;
+
+declare type Disposer_2 = () => void;
+
+declare type DocumentOptions = Partial<{
+    lazyLoading: boolean;
+    subscribeOnChanges: boolean;
+}>;
+
+export declare type Empty = void | Promise<void> | undefined | Promise<undefined>;
+
+export declare type Events = {
+    'on-ready': RemoteBundleState;
+    'on-error': Error;
+};
+
+export declare type ExternalTvConfig = {
+    logo: string;
+};
+
+/**
+ * @throws if fetch fails
+ */
+export declare const fetchBundle: (secret: string, conf: InternalConfig) => 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>;
+
+export declare interface GenericOnCallError {
+    code: string;
+    message?: string;
+    details?: string[];
+}
+
+/**
+ * Share singleton instance
+ */
+export declare const getPubSub: () => PubSub;
+
+declare interface HookData<T> {
+    data: PaginationData<T> | null;
+    error: Error | null;
+    isLoading: boolean;
+}
+
+export declare type InputSource = AdSource | ChannelSource | VodTivioSource | VodExternalSource;
+
+export declare type InternalConfig = {
+    /**
+     * @private URL of remote code bundle to be fetched directly (without using resolver)
+     */
+    bundleUrlOverride?: string;
+    currency: Currency;
+    /**
+     * 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;
+    };
+    disableUnmounting?: boolean;
+    enable?: boolean;
+    enableSentry?: boolean;
+    ErrorComponent?: ComponentType<{
+        error: string | null;
+    }>;
+    fetchPackage: FetchPackage;
+    language?: LangCode;
+    LoaderComponent?: ComponentType;
+    logger?: Logger | null;
+    pubSub: PubSub;
+    /**
+     * @private URL of resolver. Resolver is a script used to fetch remove code bundle
+     */
+    resolverUrl: string;
+    sdkVersion: string;
+    secret: string | null;
+    verbose?: boolean;
+    /**
+     * @private
+     */
+    forceCloudFnResolver?: boolean;
+};
+
+declare interface IntroMarker {
+    marker: Marker;
+    skip: () => void;
+}
+
+declare type ItemsInRow = Tag | Video | TvChannel;
+
+/**
+ * Enum of all supported languages codes as in ISO 639-1
+ */
+export declare enum LangCode {
+    CS = "cs",
+    DE = "de",
+    EN = "en",
+    FR = "fr",
+    PL = "pl",
+    SK = "sk",
+    SP = "sp"
+}
+
+declare type LinkedVideo = {
+    video: Video;
+    type: 'CUT' | 'TRAILER' | 'BONUS' | 'CHILD';
+};
+
+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[];
+
+export declare type Marker = {
+    id: string;
+    type: string;
+    from: Date;
+    to: Date;
+    count?: number;
+    fromMs?: number;
+    toMs?: number;
+};
+
+export declare interface Monetization {
+    id: string;
+    price?: string | number;
+    type?: MonetizationType;
+    frequency?: MONETIZATION_FREQUENCY;
+    name?: string;
+    description?: string;
+    benefits?: Translation[];
+    localizedBenefits?: string[];
+}
+
+declare enum MONETIZATION_FREQUENCY {
+    ONE_TIME_PAYMENT = "ONE_TIME_PAYMENT",
+    DAILY = "DAILY",
+    WEEKLY = "WEEKLY",
+    MONTHLY = "MONTHLY",
+    ANNUALLY = "ANNUALLY"
+}
+
+declare type MonetizationType = 'advertisement' | 'transaction' | 'subscription';
+
+/**
+ * TODO: Duplicate, because we can't import types from core-js.
+ */
+export declare type NewVoucher = {
+    expirationDate: Date | number;
+};
+
+export declare type Nullable<T> = {
+    [P in keyof T]: T[P] | null;
+};
+
+declare interface OrderBy {
+    field: string;
+    directionStr?: OrderByDirection;
+}
+
+declare type PaginationData<T> = {
+    items: T[];
+    hasNextPage: boolean;
+    fetchMore: Function;
+};
+
+declare type PaginationInterface<Entity> = {
+    items: Entity[];
+    fetchMore: () => void;
+    hasNextPage?: boolean;
+    loading?: boolean;
+};
+
+declare type PaginationOptions = Partial<{
+    limit: number;
+    noLimit: boolean;
+}>;
+
+export declare enum PLATFORM {
+    MOBILE = "MOBILE",
+    WEB = "WEB",
+    TV = "TV"
+}
+
+export declare interface PlayerCapability {
+    codec: 'h264' | 'h265';
+    encryption: 'fairplay' | 'none' | 'playready' | 'widevine';
+    protocol: 'dash' | 'hls';
+}
+
+export declare interface PlayerInterface {
+    pause: () => void;
+    /**
+     * unpause
+     */
+    play: () => void;
+    /**
+     * @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;
+    /**
+     * Source to be passed to player.
+     *
+     * Depending on autoplay settings it should either start playing
+     * immediately or just be loaded by player and stay paused.
+     */
+    setSource: (source: InputSource | null) => void;
+    /**
+     * volume in [0,1]
+     */
+    setVolume?: (volume: number) => void;
+    mute?: () => void;
+    /**
+     * restore volume to previous value
+     */
+    unmute?: () => void;
+}
+
+export declare const PlayerProvider: ({ children, playerWrapperId, }: PlayerProviderProps) => FunctionComponentElement<PlayerProviderProps>;
+
+export declare type PlayerProviderProps = {
+    children: React_2.ReactNode;
+    playerWrapperId?: string;
+};
+
+declare type PlayerState = 'playing' | 'paused' | 'idle';
+
+export declare type PlayerWrapper = {
+    /**
+     * 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: InputSource | 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: InputSource | null;
+    events: {
+        isSupported: (even: string) => boolean;
+        addListener: <T = any>(event: string, cb: (value: T) => Empty) => void;
+        removeListener: <T = any>(event: string, cb: (value: T) => Empty) => void;
+        removeAllListeners: () => void;
+    };
+    /**
+     * 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: Error | 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;
+};
+
+export declare interface PubSub {
+    publish: <K extends keyof Events>(triggerName: K, payload: Events[K]) => Empty;
+    subscribe: <K extends keyof Events>(triggerName: K, onMessage: (data: Events[K]) => Empty) => Disposer;
+}
+
+export declare type Purchase = {
+    isPurchased: boolean;
+    monetizationId: string;
+    videoId: string;
+    status: string;
+    video: Video | null;
+};
+
+declare type Purchase_2 = {
+    id: string;
+    isPurchased: boolean;
+    monetizationRef: firebase_3.firestore.DocumentReference | null;
+    monetization: PurchaseMonetization | null;
+    monetizationId: string | null;
+    type: MonetizationType | null;
+    videoId: string | null;
+    status: PurchaseStatus | null;
+    video: Video | null;
+    videoRef: firebase_3.firestore.DocumentReference | null;
+    expirationDate: Date | null;
+    isExpired: boolean;
+    voucherId?: string;
+};
+
+declare type PurchaseMonetization = {
+    currency: Currency;
+    period: number;
+    price: number;
+    type: MonetizationType;
+    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;
+};
+
+declare enum PurchaseStatus {
+    NEW = "NEW",
+    PAID = "PAID",
+    CANCELLED = "CANCELLED",
+    ERROR = "ERROR"
+}
+
+export declare interface QerkoCancellationInfo {
+    purchaseId: string;
+    status: PurchaseStatus;
+}
+
+export declare interface QerkoData {
+    monetization: Monetization;
+    video?: Video;
+    onPurchase?: () => void;
+    onClose?: () => void;
+}
+
+export declare interface QerkoOverlayState {
+    data: QerkoData | null;
+    openQerkoOverlay: ((data: QerkoData) => void);
+    closeQerkoOverlay: () => void;
+}
+
+export declare interface QerkoPaymentInfo {
+    webPaymentGatewayLink: string;
+    gatewayUri: string;
+    paymentQRCodeUri: string;
+    purchaseId: string;
+    currency: string;
+    amount: number;
+    monetizationType: MonetizationType;
+    recovery?: boolean;
+    monetizationFrequency: MONETIZATION_FREQUENCY;
+}
+
+declare interface QerkoTransaction {
+    paymentInfo: QerkoPaymentInfo | null;
+    paymentError: string | null;
+    paymentStatus: string | null;
+    getPaymentInfo: () => Promise<void>;
+    voucherId?: string;
+}
+
+export declare type RemoteBundleState = {
+    config: InternalConfig;
+    error: string | null;
+    settings: Settings;
+    state: 'loading' | 'error' | 'ready';
+} & Nullable<TivioBundle>;
+
+export declare type RemoteProviderProps = {
+    disableUnmounting?: boolean;
+    language?: string;
+};
+
+export declare interface RouterOverrides {
+    goToVideoDetailPage: (videoId: string) => void;
+    goToSeriesDetailPage: (tagId: string) => void;
+    goToTagPage: (tagId: string) => void;
+    goToLoginScreen: () => void;
+    goBack: () => void;
+    goLivePlayer: (videoId: string) => void;
+    goVodPlayer: (tvChannelId: string) => void;
+}
+
+export declare interface RouterOverridesContextState {
+    routerOverrides: RouterOverrides;
+}
+
+declare interface Row {
+    id: string;
+    rowId: string;
+    name: string;
+    description?: string;
+    itemComponent: RowItemComponent;
+    rowComponent: RowComponent;
+    assets: Assets;
+    type: ScreenRowType;
+}
+
+export declare enum ROW_ITEM_TYPES {
+    VIDEO = "VIDEO",
+    TAG = "TAG",
+    TV_CHANNEL = "TV_CHANNEL"
+}
+
+declare enum RowComponent {
+    ROW = "ROW",
+    BANNER = "BANNER"
+}
+
+declare interface RowItem extends RowItemAssets {
+    itemType: ROW_ITEM_TYPES;
+    name?: string;
+    description?: string;
+    assets: Assets | null;
+}
+
+declare interface RowItemAssets {
+    landscape?: string | null;
+    portrait?: string | null;
+    circled?: string | null;
+    banner?: string | null;
+}
+
+declare enum RowItemComponent {
+    ROW_ITEM_PORTRAIT = "ROW_ITEM_PORTRAIT",
+    ROW_ITEM_LANDSCAPE = "ROW_ITEM_LANDSCAPE",
+    ROW_ITEM_CIRCLED = "ROW_ITEM_CIRCLED"
+}
+
+declare type ScalableAsset = {
+    '@1': Asset;
+    '@2'?: Asset;
+    '@3'?: Asset;
+};
+
+declare interface Screen_2 {
+    id: string;
+    name: string;
+    description?: string;
+    assets: Assets;
+    rows: Row[];
+}
+
+declare type ScreenOptions = Partial<{
+    language: LangCode;
+    initRows: boolean;
+}> & DocumentOptions;
+
+declare type ScreenRowType = 'filter' | 'custom' | 'continueToWatch' | 'favourites';
+
+export declare type Section = {
+    id: string;
+    name: string;
+    channel: Channel;
+    videos: Video[];
+};
+
+declare interface Section_2 {
+}
+
+export declare const SectionsContext: React_2.Context<DataState<Section_2>>;
+
+export declare type Settings = {
+    /**
+     * @deprecated TIV-994 in favour of setUser from libs/sdk-react/src/services/login.ts
+     */
+    setUser: (userId: string, userPayload: unknown) => Promise<void>;
+};
+
+/**
+ * Set user to sign in/out.
+ *
+ * Sign in - setUser('userID', { token: 'xxx' })
+ * Sign out - setUser(null)
+ */
+export declare const setUser: (userId: string | null, payload?: UserPayload | undefined) => Promise<void>;
+
+export declare const showGdprConsentPreferences: () => Promise<void>;
+
+declare type SubscribeToItemsInRow = (rowId: string, cb: (error: Error | null, data: PaginationInterface<ItemsInRow> | null) => void, options?: SubscribeToItemsInRowOptions) => Disposer_2;
+
+declare type SubscribeToItemsInRowOptions = Partial<{
+    fetchTags: boolean;
+}> & PaginationOptions;
+
+declare type SubscribeToRowsInScreen = (screenId: string, cb: (error: Error | null, data: PaginationInterface<Row> | null) => void, options?: PaginationOptions) => Disposer_2;
+
+declare type SubscribeToScreen = (screenId: string, cb: (error: Error | null, data: Screen_2 | null) => void, options?: ScreenOptions) => Disposer_2;
+
+declare type SubscribeToTaggedVideos = (tagIds: string[], cb: (error: Error | null, data: PaginationInterface<Video> | null) => void, options?: SubscribeToTaggedVideosOptions) => Disposer_2;
+
+declare type SubscribeToTaggedVideosOptions = SubscribeToItemsInRowOptions & {
+    orderBy?: (Omit<OrderBy, 'field'> & {
+        field: TaggedVideosOrderByField;
+    })[];
+    where?: WhereFilter[];
+};
+
+declare type SubscriptionInfo = {
+    type: 'subscription';
+    name: string;
+    benefits: string[];
+    frequency: string;
+};
+
+export declare interface SubscriptionOverlayData {
+    subscriptions?: Monetization[];
+    onPurchase?: () => void;
+    onClose?: () => void;
+}
+
+export declare type SubscriptionOverlayState = {
+    data: SubscriptionOverlayData | null;
+    closeSubscriptionOverlay: () => void;
+    openSubscriptionOverlay: (data: SubscriptionOverlayData) => void;
+};
+
+declare interface Tag extends RowItem {
+    id: string;
+    tagId: string;
+    type?: string | null;
+    metadata?: any[];
+    color?: string;
+    detailBanner?: string;
+    availableSeasons?: AvailableSeason[];
+    isFavorite: boolean;
+    addToFavorites: () => void;
+    removeFromFavorites: () => void;
+}
+
+declare type TaggedVideosOrderByField = 'seasonNumber' | 'episodeNumber' | 'contentType' | DefaultOrderByField;
+
+declare type TileProps = {
+    cover: string;
+    isLoading: boolean;
+    bottomLabel: string;
+    bottomLabelAreaHeight: number;
+    innerLabel: string;
+    duration: string;
+    price: string | null;
+    focused: boolean;
+    onClick?: () => void;
+    hoverable: boolean;
+    overlay: boolean;
+    coverPadding: CoverPadding;
+    variant: RowItemComponent;
+    coverWidth: number;
+    progress?: number;
+    time?: string;
+    logo?: string;
+    coverHeight: number;
+    /**
+     * Margin of inner TileContainer.
+     * Now used for backward compatibility for WebTileGrid. Consider to use it other way.
+     */
+    containerMargin?: number | string;
+};
+
+declare type TilePropsPartial = Partial<TileProps>;
+
+export declare interface TivioAuth {
+    changePassword: (newPassword: string) => Promise<void>;
+    changeUserPhoto(file: File): Promise<void>;
+    removeUserPhoto(): Promise<void>;
+    getPurchasedVodsWithInitializedVideos: () => Promise<Purchase_2[]>;
+    /**
+     * @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<void>;
+    initializeUser: () => Promise<void>;
+    signOut: () => Promise<void>;
+    /**
+     * Used for reset forgotten password by user
+     */
+    resetPassword: (email: string) => Promise<void>;
+    createFreePurchase: (monetizationId: string) => Promise<void>;
+}
+
+export declare type TivioBundle = {
+    components: TivioComponents;
+    getters: TivioGetters;
+    auth: TivioAuth;
+    hooks: TivioHooks;
+    init: (config: Config) => void | Promise<void>;
+    purchaseVideoWithQerko: (videoId: string, monetizationId: string, voucher?: {
+        expirationDate: Date;
+    }) => Promise<QerkoPaymentInfo>;
+    purchaseSubscriptionWithQerko: (monetizationId: string, voucher?: {
+        expirationDate: Date;
+    }) => Promise<QerkoPaymentInfo>;
+    cancelSubscriptionWithQerko: (subscriptionId: string) => Promise<QerkoCancellationInfo>;
+    setLanguage: (language: LangCode) => void;
+    setUser: (userId: string | null, userPayload?: UserPayload) => Promise<void>;
+    showConsentPreferences: () => void;
+    sources: TivioSources;
+    subscriptions: TivioSubscriptions;
+    internal: {
+        components: TivioInternalComponents;
+        hooks: TivioInternalHooks;
+        providers: TivioInternalProviders;
+    };
+};
+
+export declare type TivioBundleFile = {
+    Tivio: TivioBundle;
+};
+
+export declare type TivioComponents = {
+    AdIndicationButtonWeb: React_2.ReactNode;
+    Markers: React_2.ReactNode;
+    PlayerDataContext: React_2.ReactNode;
+    Provider: React_2.ComponentType<RemoteProviderProps>;
+    Recommendation: React_2.ReactNode;
+    SkipButtonWeb: React_2.ReactNode;
+    /**
+     * @deprecated will be removed in in @tivio/sdk-react@4
+     */
+    VideoAdBanner: React_2.ReactNode;
+    WebPlayer: React_2.ComponentType<WebPlayerProps>;
+    Widget: React_2.ComponentType<TivioWidgetProps>;
+    TvPlayer: React_2.ComponentType<WebPlayerProps>;
+    PlayerDataContextProvider: React_2.ComponentType<{
+        id: string;
+    }>;
+    SkipButtonTv: React_2.ComponentType<{
+        Button: React_2.ComponentType;
+        Label: React_2.ComponentType;
+        Container: React_2.ComponentType;
+        onStarted?: () => any;
+        onEnded?: () => any;
+    }>;
+    TvApp: React_2.ComponentType<TvAppProps>;
+    CustomerScreen: React_2.ComponentType<{
+        screenId: string;
+    }>;
+    WebTagScreen: React_2.ComponentType<{
+        tagId: string;
+        onError?: (error: Error) => void;
+    }>;
+    WebSearchScreen: React_2.ComponentType<{
+        searchQuery?: string;
+    }>;
+    WebRow: React_2.ComponentType<WebRowProps>;
+    WebTile: React_2.ComponentType<{
+        item?: Video | Tag;
+    } & TilePropsPartial>;
+    FeatureSupportCheck: React_2.ComponentType<{}>;
+};
+
+export declare const TivioContext: React_2.Context<RemoteBundleState | null>;
+
+export declare type TivioGetters = {
+    isTivioLoaded: (cb: (isLoaded: boolean) => void) => boolean;
+    isSignedIn: () => boolean;
+    /**
+     * Get channel by its id.
+     * @param channelId - channel id
+     * @returns {Promise<Channel | null>} channel or null if channel does not exists
+     */
+    getChannelById: (channelId: string) => Promise<Channel | null>;
+    /**
+     * Get (or create) player wrapper instance
+     * @param opt - player getter options
+     * @returns {PlayerWrapper} player wrapper instance
+     */
+    getPlayerWrapper: (opt: {
+        playerWrapperId?: string;
+    }) => PlayerWrapper;
+    getOrganizationScreens: () => Promise<Screen_2[]>;
+    getOrganizationSubscriptions: () => Promise<Monetization[] | undefined>;
+    /**
+     * Get section by its id.
+     * @param sectionId - section id
+     * @returns {Promise<{section: Section, channel: Channel} | null>} section and channel or null if channel or section does not exists
+     */
+    getSectionById: (sectionId: string) => Promise<Section | null>;
+    /**
+     * 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 widget by its id.
+     * @param widgetId - widget id
+     * @returns {Promise<Widget | null>} widget or null if widget does not exists
+     */
+    getWidgetById: (widgetId: string) => Promise<Widget | null>;
+    /**
+     * Get player capabilities based on user's browser and OS as resolved by Tivio.
+     * @returns PlayerCapability[]
+     */
+    getPlayerCapabilities: () => PlayerCapability[];
+};
+
+export declare type TivioHooks = {
+    useAd: () => [(AdSource | null)];
+    useAdSegment: () => AdSegment | null;
+    useCancelSubscription: UseCancelSubscription;
+    useItemsInRow: (rowId: string, options: PaginationOptions) => {
+        pagination: PaginationInterface<ItemsInRow> | null;
+        error: Error | null;
+    };
+    usePurchaseRecovery: () => {
+        purchaseRecoveryResult?: string;
+        loading: boolean;
+        error?: GenericOnCallError;
+        purchaseRecovery: (monetizationId: string) => void;
+    };
+    useRowsInScreen: (screenId: string, options: PaginationOptions) => {
+        pagination: PaginationInterface<Row> | null;
+        error: Error | null;
+    };
+    useTaggedVideos: (tagIds: string[], options: SubscribeToItemsInRowOptions) => {
+        pagination: PaginationInterface<Video> | null;
+        error: Error | null;
+    };
+    useSearch: UseSearch;
+    useVideo: (videoId: string) => {
+        data: Video | null;
+        error: string | null;
+    };
+    useVoucher: (voucherId: string) => any;
+    /**
+     * @deprecated will be removed in version
+     */
+    useLastVideoByWidgetId: (widgetId: string) => Video | null;
+    useWatchWithoutAdsOffer: () => {
+        canPurchaseWatchWithoutAds: boolean;
+        showPurchaseDialog: () => void;
+    };
+    useApplyInviteCode: () => {
+        applyInviteCodeResult?: boolean;
+        loading: boolean;
+        error?: GenericOnCallError;
+        applyInviteCode: (code: string) => void;
+        inviteCodeReset: () => void;
+    };
+};
+
+export declare type TivioInternalComponents = {
+    PrimaryButton: React_2.ComponentType;
+    WebLandingScreen: React_2.ComponentType<{
+        logo?: string;
+    }>;
+    WebVideoScreen: React_2.ComponentType<{
+        videoId: string;
+    }>;
+    WebSeriesDetailScreen: React_2.ComponentType<WebSeriesDetailScreenProps>;
+};
+
+export declare type TivioInternalHooks = {
+    useAuthOverlay: () => AuthOverlayState;
+    useSubscriptionsOverlay: () => SubscriptionOverlayState;
+    useQerkoOverlay: () => QerkoOverlayState;
+    usePurchasesWithVideos: () => {
+        purchases: Purchase_2[];
+    };
+    useOrganizationSubscriptions: () => {
+        subscriptions: Monetization[];
+    };
+    useIsMonetizationPurchased: () => {
+        isOneOfSubscriptionPurchased: (subscriptionIds: string[]) => boolean;
+    };
+    useReferralInfo: any;
+    useTvChannel: UseTvChannel;
+    useChannelSource: UseChannelSource;
+    useUser: () => {
+        user: User | null;
+        error: string | null;
+        isInitialized: boolean;
+    };
+};
+
+export declare type TivioInternalProviders = {
+    AppThemeProvider: React_2.ComponentType;
+    AuthOverlayContextProvider: React_2.ComponentType;
+    CustomerProvider: React_2.ComponentType<{
+        customer: CUSTOMER_BUILD;
+        platform: PLATFORM;
+        children: any;
+    }>;
+    ConfigProvider: React_2.ComponentType;
+    UserContextProvider: React_2.ComponentType;
+    SubscriptionOverlayContextProvider: React_2.ComponentType;
+    QerkoOverlayContextProvider: React_2.ComponentType;
+    PurchasesWithVideosContextProvider: React_2.ComponentType;
+    OrganizationSubscriptionsContextProvider: React_2.ComponentType;
+    RouterOverridesContextProvider: React_2.ComponentType<RouterOverridesContextState>;
+};
+
+export declare const TivioProvider: React_2.FC<TivioProviderProps>;
+
+export declare type TivioProviderProps = {
+    /**
+     * This prop must be set only once and not change value afterwards
+     */
+    conf: Config | undefined | null;
+    children: React_2.ReactNode;
+};
+
+export declare type TivioSources = {
+    AdSource: any;
+    ChannelSource: any;
+    VodExternalSource: any;
+    VodTivioSource: any;
+};
+
+export declare type TivioSubscriptions = {
+    subscribeToUser: (cb: (error: string | null, user: User | null) => void) => void;
+    /**
+     * Listen to widget changes.
+     * @param widgetId - widget id
+     * @param cb - callback on widget updates or on error
+     */
+    subscribeToWidget: (widgetId: string, cb: (error: Error | null, data: Widget | null, disposer?: Disposer) => void) => void;
+    /**
+     * Listen to channel changes.
+     * @param channelId - channel id
+     * @param cb - callback on channel updates or on error
+     */
+    subscribeToChannel: (channelId: string, cb: (error: Error | null, data: Channel | null) => void) => void;
+    /**
+     * Listen to section changes.
+     * @param sectionId - section id
+     * @param cb - callback on section updates or on error
+     */
+    subscribeToSection: (sectionId: string, cb: (error: Error | null, data: Section | 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) => void) => void;
+    /**
+     * Listen to videos in section changes.
+     * @param sectionId - section id
+     * @param cb - callback on videos change or error
+     * @param limit - videos count
+     */
+    subscribeToVideosInSection: (sectionId: string, cb: (error: null | Error, data: null | {
+        videos: Video[];
+        hasNextPage: boolean;
+    }, fetchMore: null | ((count?: number) => void), isLoading: boolean) => void, limit?: number) => void;
+    /**
+     * Listen to section in channel changes
+     * @param channelId - channel id
+     * @param cb - callback on sections change or error
+     * @param limit - sections count
+     */
+    subscribeToSectionsInChannel: (channelId: string, cb: (error: null | Error, data: null | {
+        sections: Section[];
+        hasNextPage: boolean;
+    }, fetchMore: null | ((count?: number) => void), isLoading: boolean) => void, limit?: number) => void;
+    /**
+     * Listen to channels in widget changes
+     * @param widgetId - widget id
+     * @param cb - callback on channels change or error
+     * @param limit - channels count
+     */
+    subscribeToChannelsInWidget: (widgetId: string, cb: (error: null | Error, data: null | {
+        channels: Channel[];
+        hasNextPage: boolean;
+    }, fetchMore: null | ((count?: number) => void), isLoading: boolean) => void, limit?: number) => void;
+    subscribeToScreen: SubscribeToScreen;
+    subscribeToItemsInRow: SubscribeToItemsInRow;
+    subscribeToRowsInScreen: SubscribeToRowsInScreen;
+    subscribeToTaggedVideos: SubscribeToTaggedVideos;
+    registerOverlayCallbacks: (callbacks: {
+        onShow: () => void;
+        onHide: () => void;
+    }) => void;
+};
+
+export declare const TivioWidget: React_2.ForwardRefExoticComponent<Pick<TivioWidgetProps, "id" | "onEnabled" | "onBlur"> & React_2.RefAttributes<TivioWidgetRef>>;
+
+export declare const TivioWidgetError: React_2.FC<TivioWidgetErrorProps>;
+
+declare type TivioWidgetErrorProps = {
+    error: string | null;
+};
+
+export declare const TivioWidgetLoader: React_2.FC;
+
+export declare interface TivioWidgetProps {
+    id: string;
+    ref: React_2.MutableRefObject<TivioWidgetRef>;
+    onEnabled?: (enabled: boolean) => any;
+    onBlur?: (event: {
+        key: string;
+        width: number;
+        x: number;
+    }) => any;
+}
+
+export declare interface TivioWidgetRef {
+    focus: (args: {
+        x?: number;
+    }) => void;
+    handleKey: (key: string) => ({
+        handled: boolean;
+        x: number;
+    });
+    unfocus: () => ({
+        x: number;
+    });
+}
+
+declare type TransactionInfo = {
+    type: 'transaction';
+    name: string;
+    videoId: string;
+    cover: string;
+    description: string;
+};
+
+/**
+ * Represents one string in every supported language mutation.
+ */
+export declare type Translation = {
+    [key in LangCode]: string;
+};
+
+declare type TvAppProps = {
+    customer: CUSTOMER_BUILD;
+};
+
+declare interface TvChannel extends RowItem {
+    name: string;
+    id: string;
+    path: string;
+    itemType: ROW_ITEM_TYPES;
+    country?: string;
+    filters: string[];
+    logo?: string;
+    hls: string;
+    dash: string;
+    purchasableMonetization: any | null;
+    price: number;
+}
+
+export declare const TvTivioProvider: React_2.FC<TivioProviderProps>;
+
+export declare const useAd: () => AdSource | null;
+
+export declare const useAdSegment: () => {
+    id: string;
+    remainingMs: number;
+    secondsToEnd: number;
+    secondsToSkippable: number | null;
+    canSeek: boolean;
+    canSkip: boolean;
+    isSkippable: boolean;
+    skip: () => any;
+} | null;
+
+/**
+ *  Is used to login user through different device in which user is already logged in.
+ *  (e.g. login in tv app through web app)
+ *
+ *  @return applyInviteCodeResult - true if code was applied successfully, false otherwise.
+ *          loading - loading state
+ *          error - error in case request failure
+ *          applyInviteCode - function to apply invite code
+ *          inviteCodeReset - function to reset to initial state
+ */
+export declare function useApplyInviteCode(): {
+    applyInviteCodeResult?: boolean | undefined;
+    loading: boolean;
+    error?: GenericOnCallError | undefined;
+    applyInviteCode: (code: string) => void;
+    inviteCodeReset: () => void;
+};
+
+export declare const useBetOffer: () => BetOffer | null;
+
+declare type UseCancelSubscription = (subscriptionId: string) => {
+    cancelSubscription: () => Promise<void>;
+    cancellationInfo: QerkoCancellationInfo | null;
+    error?: string | null;
+};
+
+export declare const useCancelSubscription: UseCancelSubscription;
+
+/**
+ * Use channel
+ * @param channelId - channel id
+ */
+export declare const useChannel: (channelId: string) => {
+    error: string | null;
+    data: Channel | null;
+};
+
+/**
+ * Use channels in widget
+ * @param widgetId - widget id
+ * @param [limit] - channels count, defaults to 10
+ */
+export declare const useChannelsInWidget: (widgetId: string, limit?: number) => {
+    error: Error | null;
+    data: PaginationData<Channel_2> | null;
+    isLoading: boolean;
+};
+
+declare type UseChannelSource = (tvChannelId: string) => {
+    source: ChannelSource_2 | null;
+    error: Error | null;
+};
+
+export declare const useCurrentMarker: () => Marker | null;
+
+export declare const useFreePurchase: () => {
+    purchase: (monetizationId: string) => Promise<void>;
+};
+
+export declare const useIntro: () => IntroMarker | null;
+
+export declare const useIsLoaded: () => {
+    isTivioLoaded: boolean;
+};
+
+export declare const useIsMonetizationPurchased: () => {
+    isOneOfSubscriptionPurchased: (subscriptionIds: string[]) => boolean;
+};
+
+/**
+ * Use row items
+ * @param rowId - row ID
+ * @param options - subscription options
+ */
+export declare const useItemsInRow: (rowId: string, options?: SubscribeToItemsInRowOptions) => {
+    pagination: PaginationInterface<ItemsInRow> | null;
+    error: Error | null;
+};
+
+/**
+ * @deprecated will be removed in v4
+ */
+export declare function useLastVideoByWidgetId(widgetId: string): Video | null;
+
+export declare const useMarkers: () => Marker[] | null;
+
+export declare const useOrganizationSubscriptions: () => {
+    subscriptions: Monetization[];
+};
+
+export declare type UsePlayerEvent = <T = any>(eventName: string) => T | null;
+
+export declare const usePlayerEvent: UsePlayerEvent;
+
+/**
+ * Is used to mark purchase in recovery state as PAID.
+ *
+ * @return purchaseRecoveryResult - message describing result of the recovery
+ *         loading - loading state
+ *         error - error in case request failure
+ *         purchaseRecovery - functions to execute purchase recovery
+ */
+export declare function usePurchaseRecovery(): {
+    purchaseRecoveryResult?: string | undefined;
+    loading: boolean;
+    error?: GenericOnCallError | undefined;
+    purchaseRecovery: (monetizationId: string) => void;
+};
+
+export declare const usePurchaseSubscription: (monetizationId: string, voucher?: NewVoucher | undefined) => QerkoTransaction;
+
+/**
+ * Return purchases with initialized video (purchases[i].video not null)
+ */
+export declare const usePurchasesWithVideos: () => {
+    purchases: Purchase_2[];
+};
+
+export declare type User = {
+    purchases: Purchase_2[];
+    allPurchases: Purchase_2[];
+    purchasedVods: Purchase_2[];
+    purchasedSubscriptions: Purchase_2[];
+    isPurchasesInitialized: boolean;
+    isSignedIn: boolean;
+    email?: string;
+    type?: UserType;
+    photoURL: string | null;
+    name?: string;
+    authUserId?: string;
+    favorites: any[];
+    watchedPositions: any[];
+};
+
+export declare const useRowsInScreen: (screenId: string, options?: PaginationOptions) => {
+    pagination: PaginationInterface<Row> | null;
+    error: Error | null;
+};
+
+export declare type UserPayload = Record<string, any>;
+
+declare enum UserType {
+    ORGANIZATION_USER = "ORGANIZATION_USER",
+    TIVIO_USER = "TIVIO_USER"
+}
+
+/**
+ * @deprecated
+ *
+ * Use app screen
+ * @param screenId - screen ID
+ * @param options - subscribe to screen options
+ */
+export declare const useScreen: (screenId: string, options?: ScreenOptions | undefined) => never;
+
+export declare const useScreens: () => {
+    screens: Screen_2[];
+};
+
+declare type UseSearch = <T extends ALGOLIA_INDEX_NAME>(indexName: T, options?: UseSearchOptions) => {
+    search: (query: string) => void;
+    pagination: PaginationInterface<UseSearchResult<T>> | null;
+    error: Error | null;
+    isLoading: boolean;
+    lastQuery: string;
+};
+
+/**
+ * Full text search that returns entities based on search query.
+ * @param indexName - index that search would be performed on ('videos', 'tags', etc.)
+ * @param options - pagination options
+ */
+export declare const useSearch: UseSearch;
+
+declare type UseSearchOptions = PaginationOptions & Partial<{
+    minQueryLength: number;
+}>;
+
+declare type UseSearchResult<T extends ALGOLIA_INDEX_NAME> = T extends ALGOLIA_INDEX_NAME.VIDEOS ? Video : T extends ALGOLIA_INDEX_NAME.TAGS ? Tag : T extends ALGOLIA_INDEX_NAME.TV_CHANNELS ? TvChannel : unknown;
+
+/**
+ * Use section
+ * @param sectionId - section id
+ */
+export declare const useSection: (sectionId: string) => {
+    error: string | null;
+    data: Section | null;
+};
+
+/**
+ * Use section in channel
+ * @param channelId - channel id
+ * @param [limit] - sections count, defaults to 10
+ */
+export declare const useSectionsInChannel: (channelId: string, limit?: number) => {
+    error: Error | null;
+    data: PaginationData<Section_2> | null;
+    isLoading: boolean;
+};
+
+export declare const useSeekState: () => boolean | null;
+
+/**
+ * Returns videos with given tag ids
+ * @param tagIds - tag ids
+ * @param options - subscription options
+ */
+export declare const useTaggedVideos: (tagIds: string[], options?: SubscribeToItemsInRowOptions) => {
+    pagination: PaginationInterface<Video> | null;
+    error: Error | null;
+};
+
+export declare const useTivioData: () => RemoteBundleState;
+
+export declare const useTivioReadyData: () => RemoteBundleState | null;
+
+export declare const useTransactionPayment: (videoId: string, monetizationId: string, voucher?: NewVoucher | undefined) => QerkoTransaction;
+
+declare type UseTvChannel = (tvChannelId: string) => {
+    tvChannel: TvChannel | null;
+    error: Error | null;
+    loading: boolean;
+};
+
+export declare const useUser: () => {
+    user: User | null;
+    error: string | null;
+    isInitialized: boolean;
+};
+
+/**
+ * Use video
+ * @param videoId - video id
+ */
+export declare const useVideo: (videoId?: string | undefined) => {
+    data: Video | null;
+    error: string | null;
+};
+
+/**
+ * Use videos in section
+ * @param sectionId - section id
+ * @param [limit] - videos count, defaults to 10
+ */
+export declare const useVideosInSection: (sectionId?: string | undefined, limit?: number) => {
+    error: Error | null;
+    data: PaginationData<Video> | null;
+    isLoading: boolean;
+};
+
+export declare const useVoucher: (voucherId: string) => {
+    activate: (() => Promise<void>) | null;
+    voucher: Voucher | null;
+    /**
+     * You can check error.details if you need to know error type when you want your own error messages
+     * (can be one of "DOES_NOT_EXIST", "EXPIRED" and "ALREADY_USED").
+     */
+    error: Error | BadRequestError | null;
+    /**
+     * True if voucher has been successfully activated in current session.
+     */
+    activationSuccess: boolean;
+};
+
+export declare const useWatchWithoutAdsOffer: () => {
+    canPurchaseWatchWithoutAds: boolean;
+    showPurchaseDialog: () => void;
+};
+
+/**
+ * Use widget
+ * @param widgetId - widget id
+ */
+export declare const useWidget: (widgetId: string) => {
+    error: string;
+    widget: Widget | null;
+};
+
+export declare interface Video extends RowItem {
+    id: string;
+    /**
+     * @deprecated use assets instead
+     */
+    cover: string | null;
+    created: Date;
+    sectionId: string | null;
+    channelId: string | null;
+    /**
+     * seconds
+     */
+    duration: number;
+    path: string;
+    tags: Tag[];
+    image: string | null;
+    isPlayable: boolean;
+    monetizations: Monetization[];
+    monetization: Monetization | undefined;
+    transactionId?: string;
+    transaction: Monetization | undefined;
+    subscriptions: Monetization[];
+    subscriptionIds: string[];
+    isPlaylist: boolean;
+    name: string;
+    description?: string;
+    price: number | null;
+    detailedPrice: DetailedPrice | null;
+    uri: string;
+    url: string;
+    adMonetizationId?: string;
+    from?: Date;
+    to?: Date;
+    detailBanner?: string;
+    linkedVideosRaw: any[];
+    linkedVideos: LinkedVideo[];
+    purchasableMonetization: any | null;
+    contentType: VideoContentType | null;
+    year?: number;
+    episodeNumber?: number;
+    seasonNumber?: number;
+    getTagsOfType: (type: string) => Tag[];
+    loadLinkedVideos: () => any;
+    getLinkedVideos: (type: any) => any;
+    trailer: Video | null;
+    watchPosition: number | null;
+    isFavorite: boolean;
+    addToFavorites: () => void;
+    removeFromFavorites: () => void;
+    availability: VideoAvailabilityField | null;
+}
+
+declare type VideoAvailabilityField = {
+    from: firebase_2.firestore.Timestamp;
+    to: firebase_2.firestore.Timestamp | null;
+    manual: boolean;
+};
+
+declare enum VideoContentType {
+    /**
+     * Default video content type
+     */
+    VIDEO = "VIDEO",
+    FILM = "FILM",
+    SERIES = "SERIES"
+}
+
+declare type VideoPath = string;
+
+export declare const VideosContext: React_2.Context<DataState<Video>>;
+
+export declare type VodExternalSource = {
+    new (uri: string, monetizationId: string, name: string, description: string, originalOptions: Record<string, any>): VodTivioSource;
+    type: 'vod_external';
+    description: string;
+    name: string;
+    uri: string;
+};
+
+export declare type VodTivioSource = {
+    new (uri: string, videoId: string, name: string, description: string, adMonetizationId?: string): VodTivioSource;
+    type: 'vod_tivio';
+    description: string;
+    name: string;
+    uri: string;
+};
+
+export declare interface VodTivioSourcePojo {
+    type: 'VodTivioSource';
+    description: string;
+    path: string;
+    name: string;
+    uri: string;
+    poster?: string;
+    adMonetizationId?: string;
+}
+
+/**
+ * TODO: Should be in core-js, we can't import types from it, though.
+ */
+declare type Voucher = {
+    activate: () => void;
+    isUsed: boolean;
+    isExpired: boolean;
+    status: 'NEW' | 'USED';
+    voucherInfo: SubscriptionInfo | TransactionInfo;
+};
+
+export declare interface WebPlayerProps {
+    id: string;
+    source?: VodTivioSourcePojo | ChannelSourcePojo | VideoPath | null;
+    onEnded?: () => any;
+    /**
+     * If this function is specified, then "Back" button is shown in top right corner.
+     */
+    onBack?: () => void;
+    className?: string;
+    /**
+     * default false
+     *
+     * If you choose `autoplay` make sure that autoplay is allowed in the specific situation.
+     * In some cases it may not be allowed, e.g. before the user interacted with the site, and the video
+     * will stay paused.
+     *
+     * Source: https://developer.mozilla.org/en-US/docs/Web/Media/Autoplay_guide
+     */
+    autoplay?: boolean;
+    /**
+     * default false
+     */
+    canReplay?: boolean;
+    /**
+     * default false
+     */
+    showMarkers?: boolean;
+    /**
+     * number[] is array of keyboard event.which numeric codes
+     * (see https://keycode.info/)
+     */
+    customShortcuts?: Partial<{
+        toggleFullscreen: number[];
+        togglePause: number[];
+        toggleMute: number[];
+        jumpForward: number[];
+        jumpBack: number[];
+        volumeUp: number[];
+        volumeDown: number[];
+    }>;
+    /**
+     * default true
+     */
+    enableKeyboardShortcuts?: boolean;
+    onProgress?: (event: React_2.ChangeEvent<HTMLVideoElement>) => void;
+    /**
+     * @deprecated this callback is never called. Will be removed in @tivio/sdk-react version 4
+     */
+    onPlayerControllerCreated?: (playerController: any) => void;
+}
+
+declare type WebRowProps = {
+    items?: ItemsInRow[];
+    variant?: RowItemComponent;
+    rowName?: string;
+    fetchMore?: () => void;
+    onTileClick?: (item: ItemsInRow) => void;
+};
+
+declare type WebSeriesDetailScreenProps = {
+    tagId: string;
+};
+
+declare interface WhereFilter {
+    field: string;
+    operator: WhereFilterOp;
+    value: any;
+}
+
+export declare type Widget = {
+    id: string;
+    channels: Channel[];
+    isEnabled: boolean | null;
+    name: string | null;
+    recentVideos: Video[] | null;
+    widgetId: string | null;
+    lastVideo: Video | null;
+};
+
+export declare function withPlayerContext(id: string): <P>(WrappedComponent: React_2.ComponentType<P>) => (props: P) => JSX.Element;
+
+export { }