import { ContextManager, Context } from '../context';
import { Observable } from '../observable';
/**
 * LoadContext exposes to components and behaviors key moments during the initialization of the experience,
 * and allows them to register long-running processes that should take place on any loading screen.
 *
 * There are several related, yet distinct, moments during initializatin that may be useful. In each case a `Promise`
 * and an `Observable<boolean>` are exposed for use in components and behaviors.
 *
 * - `constructed` occurs when the root component's constructor (and thus any recursive children) has finished.
 *   This often takes place very soon after page load - when the experience's `<script>` has initialized. It's unlikely
 *   that the experience is ready to run as assets and other dependencies may still be being downloaded. If the
 *   experience features a splash page, this moment will almost certainly occur before the user taps on the
 *   launch button.
 *
 * - `launched` occurs when the user taps on a splash screen's 'launch' button or, in the case that there's no launch
 *   button, after construction. It's unlikely that the experience is ready to run as assets and other dependencies may
 *   still be being downloaded. This moment is useful for showing permission dialogs to the user since it occurs after
 *   they have indicated that they wish to proceed with the experience and is concurrent with any asset loading.
 *
 * - `started` occurs once both the loading is complete, and the user has tapped on a 'launch' button (if it exists).
 *   It's the moment where any loading screen will be hidden and the experience starts from the perspective of
 *   the user. Use this moment to start any audio, video or animation.
 *
 * - `loaded` occurs once all 'loadable' processes have completed (e.g. the downloading of assets). Since asset loading
 *   starts as soon as the root component is constructed, this moment may occur before (or after) the user has tapped
 *   on any 'launch' button.
 *
 * @zcontext */
export declare class LoadContext extends Context {
    /**
     * Observable indicating whether the root component's construction is complete.
     * This is typically set to true immediately after the root component and its children are constructed.
     * @zui
     */
    readonly isConstructed: Observable<boolean, never>;
    /**
     * Observable indicating whether all loadable processes have completed.
     * This is true when all assets and dependencies required for the experience are fully loaded.
     * @zui
     */
    readonly isLoaded: Observable<boolean, never>;
    /**
     * Observable indicating whether the experience has started.
     * This becomes true at the point where the experience transitions from loading to active interaction.
     * @zui
     */
    readonly isStarted: Observable<boolean, never>;
    /**
     * Observable indicating whether the experience has been launched.
     * This is set to true typically when the user interacts with a splash screen or an initial launch button.
     * @zui
     */
    readonly isLaunched: Observable<boolean, never>;
    /**
     * Observable representing the progress percentage of loadable processes.
     * This provides a numerical value representing the completion percentage of all loading operations.
     * @zui
     */
    readonly progressPercent: Observable<number, never>;
    private _startedResolved;
    readonly started: Promise<void>;
    private _constructedResolved;
    readonly constructed: Promise<void>;
    private _launchedResolved;
    readonly launched: Promise<void>;
    private _loadables;
    private _startWhenLoaded;
    private _totalLoadables;
    private _loadedCount;
    /**
     * Start the experience.
     */
    start(): void;
    /**
     * Called when the root component's constructor (and thus any recursive children) has finished.
     */
    constructionComplete(): void;
    /**
     * Called when the user taps on a splash screen's 'launch' button or, in the case that there's no launch
     */
    launch(): void;
    private _update;
    /**
     * Start the experience when all loadables have completed.
     */
    startWhenLoaded(): void;
    /**
     * Register a loadable process.
     */
    registerLoadable(p: Promise<any>): void;
}
/**
 * Returns an observable that indicates whether the experience is loaded.
 */
export declare function useIsLoaded(mgr: ContextManager): Observable<boolean, never>;
/**
 * Returns a value that indicates whether the experience is loaded.
 */
export declare function isLoaded(mgr: ContextManager): boolean;
/**
 * Returns an observable that indicates whether the experience is started.
 */
export declare function useIsStarted(mgr: ContextManager): Observable<boolean, never>;
/**
 * Returns a value that indicates whether the experience is started.
 */
export declare function isStarted(mgr: ContextManager): boolean;
/**
 * Returns an observable that indicates whether the experience is constructed.
 */
export declare function useIsConstructed(mgr: ContextManager): Observable<boolean, never>;
/**
 * Returns a value that indicates whether the experience is constructed.
 */
export declare function isConstructed(mgr: ContextManager): boolean;
/**
 * Returns an observable that indicates whether the experience is launched.
 */
export declare function useIsLaunched(mgr: ContextManager): Observable<boolean, never>;
/**
 * Returns a value that indicates whether the experience is launched.
 */
export declare function isLaunched(mgr: ContextManager): boolean;
/**
 * Returns an observable that indicates the percentage of loadables that have completed.
 */
export declare function useLoadPercent(mgr: ContextManager): Observable<number, never>;
/**
 * Register a loadable process.
 */
export declare function registerLoadable(mgr: ContextManager, p: Promise<any>): void;
/**
 * Starts the experience.
 */
export declare function start(mgr: ContextManager): void;
/**
 * Launches the experience.
 */
export declare function launch(mgr: ContextManager): void;
/**
 * Starts the experience when all loadables have completed.
 */
export declare function startWhenLoaded(mgr: ContextManager): void;
/**
 * Returns a promise that resolves when the experience has started.
 */
export declare function started(mgr: ContextManager): Promise<void>;
/**
 *  Returns a promise that resolves when the root component's constructor (and thus any recursive children) has finished.
 */
export declare function constructed(mgr: ContextManager): Promise<void>;
/**
 * Returns a promise that resolves when the user taps on a splash screen's 'launch' button or, in the case that there's no launch
 * button, after construction.
 */
export declare function launched(mgr: ContextManager): Promise<void>;
/**
 * Marks the root component's constructor (and thus any recursive children) as finished.
 */
export declare function constructionComplete(mgr: ContextManager): void;