export declare class LiteYTEmbed extends HTMLElement {
    private domRefFrame;
    private domRefImg;
    private domRefPlayButton;
    private domRefConsentClose;
    private static isPreconnected;
    private isIframeLoaded;
    private observer;
    private listeners;
    /** Click-triggered check; may open the consent UI. Wired from the app entry. */
    static consentGate?: () => boolean;
    /** Passive check for autoload/intersection triggers — never prompts. */
    static consentReady?: () => boolean;
    constructor();
    static get observedAttributes(): string[];
    connectedCallback(): void;
    disconnectedCallback(): void;
    get videoId(): string;
    set videoId(id: string);
    get playlistId(): string;
    set playlistId(id: string);
    get videoTitle(): string;
    set videoTitle(title: string);
    get videoPlay(): string;
    set videoPlay(name: string);
    get videoStartAt(): string;
    set videoStartAt(time: string);
    get autoLoad(): boolean;
    set autoLoad(value: boolean);
    get autoPlay(): boolean;
    set autoPlay(value: boolean);
    get noCookie(): boolean;
    get posterQuality(): string;
    get posterLoading(): HTMLImageElement['loading'];
    get params(): string;
    set params(opts: string);
    /**
     * Define our shadowDOM for the component
     */
    private setupDom;
    /**
     * Parse our attributes and fire up some placeholders
     */
    private setupComponent;
    /**
     * Lifecycle method that we use to listen for attribute changes
     */
    attributeChangedCallback(name: string, oldVal: unknown, newVal: unknown): void;
    /**
     * Inject the iframe into the component body
     */
    private addIframe;
    private hasCustomPoster;
    /**
     * Setup the placeholder image for the component
     */
    private initImagePlaceholder;
    /**
     * Setup the Intersection Observer to load the iframe when scrolled into view
     */
    private initIntersectionObserver;
    /**
     * This is a terrible hack to attempt to get YouTube Short-like autoplay on
     * mobile viewports. It's this way because:
     * 1. YouTube's Iframe embed does not offer determinism when loading
     * 2. Attempting to use onYouTubeIframeAPIReady() does not work in 99% of
     *    cases
     * 3. You can _technically_ load the Frame API library and do more advanced
     *    things, but I don't want to burn the thread of the wire with its
     *    shenanigans since this an edge case.
     */
    private attemptShortAutoPlay;
    /**
     * A hacky attr check and viewport peek to see if we're going to try to enable
     * a more friendly YouTube Short style loading
     */
    private isYouTubeShort;
    /**
     * Add a <link rel={preload | preconnect} ...> to the head
     */
    private static addPrefetch;
    /**
     * Begin preconnecting to warm up the iframe load. Since the embed's network
     * requests load within its iframe, preload/prefetch'ing them outside the
     * iframe will only cause double-downloads. So, the best we can do is warm up
     * a few connections to origins that are in the critical path.
     */
    private static warmConnections;
}
/**
 * Register the <lite-youtube> custom element. Safe to call multiple times.
 * @param tagName - optional custom tag name (defaults to `lite-youtube`)
 */
export declare function defineLiteYouTube(tagName?: string): void;
declare global {
    interface HTMLElementTagNameMap {
        'lite-youtube': LiteYTEmbed;
    }
    interface Window {
        liteYouTubeNonce: string;
        liteYouTubeIsPreconnected: boolean;
    }
}
//# sourceMappingURL=lite-youtube.d.ts.map