@tivio/sdk-react 3.5.0 → 3.5.1

package/dist/info.d.ts

@@ -0,0 +1,2 @@
+declare const logInfo: () => void;
+export { logInfo };

package/dist/services/bundleLoader.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2021, nangu.TV, a.s. All rights reserved.
+ * nangu.TV, a.s PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+import type { InternalConfig, RemoteBundleState, TivioBundle } from '../types/bundle.types';
+/**
+ * @throws if fetch fails
+ */
+declare const fetchBundle: (secret: string, conf: InternalConfig) => Promise<string>;
+/**
+ * Fetch & load CommonJS remote module.
+ */
+declare const createRemotePackageLoader: () => (secret: string, conf: InternalConfig) => Promise<TivioBundle>;
+declare const createUseRemoteBundle: () => (conf: InternalConfig) => RemoteBundleState;
+export { fetchBundle, createRemotePackageLoader, createUseRemoteBundle, };

package/dist/services/bundlePromise.d.ts

@@ -0,0 +1,7 @@
+import { TivioBundle } from '../types/bundle.types';
+import type { RemoteBundleState } from '../types/bundle.types';
+export declare let tivioBundle: TivioBundle | null;
+/**
+ * rejects when bundle is not available
+ */
+export declare const bundlePromise: Promise<RemoteBundleState>;

package/dist/services/dependencyResolver.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2021, nangu.TV, a.s. All rights reserved.
+ * nangu.TV, a.s PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+import * as materialUiCore from '@material-ui/core';
+import * as materialUiIcons from '@material-ui/icons';
+import * as dayjs from 'dayjs';
+import firebase from 'firebase/app';
+import 'firebase/auth';
+import 'firebase/firestore';
+import * as formik from 'formik';
+import * as i18Next from 'i18next';
+import * as mobx from 'mobx';
+import * as mobxReact from 'mobx-react';
+import * as react from 'react';
+import * as reactDom from 'react-dom';
+import * as reactI18Next from 'react-i18next';
+import * as reactRouterDom from 'react-router-dom';
+import * as reactSpring from 'react-spring';
+import * as reactVirtualized from 'react-virtualized';
+import * as styledComponents from 'styled-components';
+import * as yup from 'yup';
+export declare type SharedDependency = typeof react | typeof reactDom | typeof mobx | typeof styledComponents | typeof firebase | typeof materialUiCore | typeof materialUiIcons | typeof formik | typeof i18Next | typeof reactI18Next | typeof reactRouterDom | typeof reactVirtualized | typeof reactSpring | typeof yup | typeof dayjs | typeof mobxReact | null;
+export declare const resolveShared: (name: string) => SharedDependency;

package/dist/services/gdpr.d.ts

@@ -0,0 +1 @@
+export declare const showGdprConsentPreferences: () => Promise<void>;

package/dist/services/localFetch/coreReactDomDist.d.ts

@@ -0,0 +1 @@
+export declare const loadBundleFromDist: () => import("../../types/bundle.types").TivioBundle;

package/dist/services/localFetch/none.d.ts

@@ -0,0 +1 @@
+export declare const loadBundleFromDist: () => void;

package/dist/services/logger.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2021, nangu.TV, a.s. All rights reserved.
+ * nangu.TV, a.s PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+export declare type LoggerArgs = any[];
+export 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;
+}
+export declare type LoggerConf = {
+    isConsoleEnabled: boolean;
+    isSentryEnabled?: boolean;
+};
+export declare type Severity = 'warn' | 'error' | 'info' | 'debug';
+/**
+ * Factory
+ **/
+export declare const createLogger: (conf: LoggerConf) => Logger;

package/dist/services/login.d.ts

@@ -0,0 +1,9 @@
+import type { UserPayload } from '../types/bundle.types';
+/**
+ * Set user to sign in/out.
+ *
+ * Sign in - setUser('userID', { token: 'xxx' })
+ * Sign out - setUser(null)
+ */
+declare const setUser: (userId: string | null, payload?: UserPayload | undefined) => Promise<void>;
+export { setUser };

package/dist/services/packageLoader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copyright (c) 2021, nangu.TV, a.s. All rights reserved.
+ * nangu.TV, a.s PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+export declare type FetchPackage = (url: string) => Promise<string>;
+export declare const fetchPackage: FetchPackage;

package/dist/services/pubSub.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) 2021, nangu.TV, a.s. All rights reserved.
+ * nangu.TV, a.s PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+/**
+ * Export Tivio Events API
+ */
+import { PubSub } from '../types/bundle.types';
+export declare const createPubSub: () => PubSub;
+/**
+ * Share singleton instance
+ */
+export declare const getPubSub: () => PubSub;

package/dist/services/sentry.d.ts

@@ -0,0 +1,4 @@
+import * as _Sentry from '@sentry/browser';
+export declare let Sentry: null | typeof _Sentry;
+export declare const disableSentry: () => void;
+export declare const initSentry: () => void;

package/dist/services/settings.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) 2021, nangu.TV, a.s. All rights reserved.
+ * nangu.TV, a.s PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+/**
+ * @deprecated TIV-994 in favour of setUser from libs/sdk-react/src/services/login.ts
+ */
+export declare const createSettings: () => {
+    /**
+     * @deprecated TIV-994 in favour of setUser from libs/sdk-react/src/services/login.ts
+     */
+    setUser: (userId: string, userPayload: unknown) => Promise<void>;
+};

package/dist/types/bundle.types.d.ts

@@ -0,0 +1,444 @@
+import { Currency, ItemsInRow, PaginationInterface, PaginationOptions, QerkoCancellationInfo, Row, SubscribeToItemsInRowOptions, SubscribeToTaggedVideos, Tag, TilePropsPartial, UseCancelSubscription, CUSTOMER_BUILD, PLATFORM, WebRowProps, WebSeriesDetailScreenProps, AuthOverlayState, CreateUserWithEmailAndPassword, UseChannelSource } from '@tivio/common';
+import { ComponentType } from 'react';
+import { Logger } from '../services/logger';
+import { FetchPackage } from '../services/packageLoader';
+import { Disposer, Empty, Nullable } from './common';
+import { Channel, LangCode, RemoteProviderProps, Section, TivioSources, TivioWidgetProps, WebPlayerProps, Widget } from './types';
+import type { AdSource, PlayerWrapper } from './customPlayer.types';
+import type { Monetization, Purchase, QerkoPaymentInfo, Screen, SubscribeToItemsInRow, SubscribeToRowsInScreen, SubscribeToScreen, TvAppProps, User, UseSearch, UseTvChannel, Video } from '@tivio/common';
+import type React from 'react';
+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>;
+};
+interface PlayerCapability {
+    codec: 'h264' | 'h265';
+    encryption: 'fairplay' | 'none' | 'playready' | 'widevine';
+    protocol: 'dash' | 'hls';
+}
+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 type Events = {
+    'on-ready': RemoteBundleState;
+    'on-error': Error;
+};
+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 interface GenericOnCallError {
+    code: string;
+    message?: string;
+    details?: string[];
+}
+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 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;
+};
+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[]>;
+    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[];
+};
+interface TivioAuth {
+    changePassword: (newPassword: string) => Promise<void>;
+    changeUserPhoto(file: File): Promise<void>;
+    removeUserPhoto(): Promise<void>;
+    getPurchasedVodsWithInitializedVideos: () => Promise<Purchase[]>;
+    /**
+     * @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 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 interface RouterOverridesContextState {
+    routerOverrides: RouterOverrides;
+}
+declare type TivioComponents = {
+    AdIndicationButtonWeb: React.ReactNode;
+    Markers: React.ReactNode;
+    PlayerDataContext: React.ReactNode;
+    Provider: React.ComponentType<RemoteProviderProps>;
+    Recommendation: React.ReactNode;
+    SkipButtonWeb: React.ReactNode;
+    /**
+     * @deprecated will be removed in in @tivio/sdk-react@4
+     */
+    VideoAdBanner: React.ReactNode;
+    WebPlayer: React.ComponentType<WebPlayerProps>;
+    Widget: React.ComponentType<TivioWidgetProps>;
+    TvPlayer: React.ComponentType<WebPlayerProps>;
+    PlayerDataContextProvider: React.ComponentType<{
+        id: string;
+    }>;
+    SkipButtonTv: React.ComponentType<{
+        Button: React.ComponentType;
+        Label: React.ComponentType;
+        Container: React.ComponentType;
+        onStarted?: () => any;
+        onEnded?: () => any;
+    }>;
+    TvApp: React.ComponentType<TvAppProps>;
+    CustomerScreen: React.ComponentType<{
+        screenId: string;
+    }>;
+    WebTagScreen: React.ComponentType<{
+        tagId: string;
+        onError?: (error: Error) => void;
+    }>;
+    WebSearchScreen: React.ComponentType<{
+        searchQuery?: string;
+    }>;
+    WebRow: React.ComponentType<WebRowProps>;
+    WebTile: React.ComponentType<{
+        item?: Video | Tag;
+    } & TilePropsPartial>;
+    FeatureSupportCheck: React.ComponentType<{}>;
+};
+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;
+};
+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 UserPayload = Record<string, any>;
+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;
+    };
+};
+declare type TivioInternalComponents = {
+    PrimaryButton: React.ComponentType;
+    WebLandingScreen: React.ComponentType<{
+        logo?: string;
+    }>;
+    WebVideoScreen: React.ComponentType<{
+        videoId: string;
+    }>;
+    WebSeriesDetailScreen: React.ComponentType<WebSeriesDetailScreenProps>;
+};
+declare type TivioInternalHooks = {
+    useAuthOverlay: () => AuthOverlayState;
+    useSubscriptionsOverlay: () => SubscriptionOverlayState;
+    useQerkoOverlay: () => QerkoOverlayState;
+    usePurchasesWithVideos: () => {
+        purchases: Purchase[];
+    };
+    useOrganizationSubscriptions: () => {
+        subscriptions: Monetization[];
+    };
+    useIsMonetizationPurchased: () => {
+        isOneOfSubscriptionPurchased: (subscriptionIds: string[]) => boolean;
+    };
+    useReferralInfo: any;
+    useTvChannel: UseTvChannel;
+    useChannelSource: UseChannelSource;
+    useUser: () => {
+        user: User | null;
+        error: string | null;
+        isInitialized: boolean;
+    };
+};
+declare type TivioInternalProviders = {
+    AppThemeProvider: React.ComponentType;
+    AuthOverlayContextProvider: React.ComponentType;
+    CustomerProvider: React.ComponentType<{
+        customer: CUSTOMER_BUILD;
+        platform: PLATFORM;
+        children: any;
+    }>;
+    ConfigProvider: React.ComponentType;
+    UserContextProvider: React.ComponentType;
+    SubscriptionOverlayContextProvider: React.ComponentType;
+    QerkoOverlayContextProvider: React.ComponentType;
+    PurchasesWithVideosContextProvider: React.ComponentType;
+    OrganizationSubscriptionsContextProvider: React.ComponentType;
+    RouterOverridesContextProvider: React.ComponentType<RouterOverridesContextState>;
+};
+declare type TivioBundleFile = {
+    Tivio: TivioBundle;
+};
+interface SubscriptionOverlayData {
+    subscriptions?: Monetization[];
+    onPurchase?: () => void;
+    onClose?: () => void;
+}
+declare type SubscriptionOverlayState = {
+    data: SubscriptionOverlayData | null;
+    closeSubscriptionOverlay: () => void;
+    openSubscriptionOverlay: (data: SubscriptionOverlayData) => void;
+};
+interface QerkoData {
+    monetization: Monetization;
+    video?: Video;
+    onPurchase?: () => void;
+    onClose?: () => void;
+}
+interface QerkoOverlayState {
+    data: QerkoData | null;
+    openQerkoOverlay: ((data: QerkoData) => void);
+    closeQerkoOverlay: () => void;
+}
+declare type RemoteBundleState = {
+    config: InternalConfig;
+    error: string | null;
+    settings: Settings;
+    state: 'loading' | 'error' | 'ready';
+} & Nullable<TivioBundle>;
+/**
+ * TODO: Duplicate, because we can't import types from core-js.
+ */
+declare type NewVoucher = {
+    expirationDate: Date | number;
+};
+export type { RemoteBundleState, Config, Settings, InternalConfig, TivioBundle, TivioBundleFile, TivioHooks, TivioComponents, TivioAuth, TivioGetters, TivioSubscriptions, TivioInternalComponents, TivioInternalHooks, TivioInternalProviders, Events, PubSub, PlayerCapability, Currency, SubscriptionOverlayData, SubscriptionOverlayState, QerkoData, QerkoOverlayState, NewVoucher, };

package/dist/types/common.d.ts

@@ -0,0 +1,6 @@
+declare type Nullable<T> = {
+    [P in keyof T]: T[P] | null;
+};
+declare type Empty = void | Promise<void> | undefined | Promise<undefined>;
+declare type Disposer = () => void;
+export { Disposer, Empty, Nullable, };