import { CSSResult } from 'lit';

import { ObjectType } from 'arktype/internal/variants/object.ts';
import { PropertyValues } from 'lit';
import type { SerializedError } from '@reduxjs/toolkit';
import type shaka from 'shaka-player';
import { TemplateResult } from 'lit';

export declare interface Ad {
    sessionId: string;
    id: string;
    /** @internal */
    companion?: Companion;
    adFormat: AdFormat | `${AdFormat}`;
    duration?: number;
    positionIndex: number;
    breakIndex: number;
    breakName: AdBreakName | `${AdBreakName}`;
    mimetype: string;
    /** @internal */
    maxDuration?: number;
    totalAds: number;
    /** @internal */
    externalId: string;
    /** @internal */
    lineItemId: string;
    /** @internal */
    waterfallIndex?: number;
    /** @internal */
    waterfallLength?: number;
    adUrl?: string;
    nonLinearWidth?: number;
    nonLinearHeight?: number;
    title?: string;
    advertiserName?: string;
    width?: number;
    height?: number;
    adSystem?: string;
    universalAdIds?: {
        id: string;
        registry: string;
    }[];
    creativeId?: string;
    skippable: boolean;
    clickThroughUrl?: string;
}

/** Name of ad break - when the ad appears, `OVERLAY` is deprecated */
export declare enum AdBreakName {
    PREROLL = "preroll",
    MIDROLL = "midroll",
    POSTROLL = "postroll",
    /**
     * TODO: OVERLAY can be deleted when everyone upgraded to latest turbo-event-tracker (>2.3.1)
     * @internal
     * @deprecated use {@link AdFormat} instead
     */
    OVERLAY = "overlay"
}

/** @interface */
declare type AdConfig = typeof AdConfigSchema.infer;

/**
 * Ad configuration
 */
declare const AdConfigSchema: ObjectType<    {
enable: boolean;
player: "ads-sdk" | "ima";
palSdk: boolean;
autoPauseWhenInvisible: boolean;
maxRedirectCount: number;
videoLoadTimeout: number;
vastLoadTimeout: number;
maxDuration?: number | undefined;
bidding: boolean;
prebidTimeout: number;
apsTimeout: number;
intensity: number;
imaUi: boolean;
customClickButton: boolean;
maxWaterfallLength: number;
pauseButton: boolean;
tagConfig?: string | {
name?: string | undefined;
maxDuration?: number | undefined;
maxFallbackAttempts?: number | undefined;
lineItems: {
id?: string | undefined;
url: string;
externalId?: string | undefined;
errorPixels?: string[] | undefined;
}[];
}[] | {
id?: string | undefined;
url: string;
externalId?: string | undefined;
errorPixels?: string[] | undefined;
} | undefined;
}, {}>;

/**
 * A broad error shape accepted by AD_ERROR events.
 * Any `Error` with a `name` and `code` satisfies this contract,
 * so domain-specific errors can flow through without normalisation
 * while preserving their origin.
 */
export declare interface AdError extends Error {
    name: string;
    message: string;
    code: string;
}

/** Format of the ad - how it is presented */
export declare enum AdFormat {
    LINEAR = "linear",
    OVERLAY = "overlay",
    CUTIN = "cutin",
    PAUSE = "pause"
}

declare type AdPlayer = new () => IBaseAdPlayerElement;

declare type AdPlayerLoader = () => Promise<{
    default: AdPlayer;
}>;

declare type AdPlayerMap = {
    ima: AdPlayerLoader;
} & {
    [key: string]: AdPlayerLoader | undefined;
};

declare const ALLOWED_UI_ACTIONS: readonly ['play', 'pause', 'openEpg', 'startAgeSetup', 'forgotPin', 'upgradeToHigherTier', 'register', 'login'];

/** @interface */
declare type AnalyticsConfig = typeof AnalyticsConfigSchema.infer;

/**
 * Analytics configuration
 */
declare const AnalyticsConfigSchema: ObjectType<    {
scriptUrl?: string | undefined;
}, {}>;

/**
 * An additional API script definition that should be executed for this media-item.
 *
 * @example
 * ```
 * {
 *   name: 'some-name',
 *   url: 'https://content-owner.com/tracking/script.js',
 *   conditions: [
 *     { startMethods: ['click-to-play'], muted: false, requiredVendors: [967], requiredPurposes: [1], probability: 1 },
 *     { startMethods: ['autoplay-scroll'], muted: undefined, requiredVendors: undefined, requiredPurposes: undefined, probability: 1 } // undefined = no filtering
 *   ]
 * }
 * ```
 */
declare interface ApiScript {
    /** Name of the API script that should be exposed to tracking */
    name: string;
    /** URL of the API script that should be executed. Must implement {@link ConnectIntegration}. */
    url: string;
    /**
     * Conditions under which the API script should be executed. Undefined means always.
     */
    conditions?: {
        startMethods?: StartMethod[];
        muted?: boolean | undefined;
        requiredVendors?: number[];
        requiredPurposes?: number[];
        probability: number;
    }[];
}

declare interface Article {
    title: string;
    description: string;
    language: string;
    publishedTime?: string;
    top: number;
    left: number;
}

/**
 * Represents an audio track.
 */
export declare interface AudioTrack extends MediaTrack {
    /** The type of audio track. */
    kind: 'main' | string;
}

/**
 * A collection of audio tracks with selection support.
 * A selected track is available when track info is exposed; otherwise null.
 *
 * **Note:** Audio tracks are available after the {@link IntegrationElement.ready | integration.ready} promise resolves.
 *
 * The list is iterable and can be converted to an array:
 * @example
 * ```ts
 * for (const track of integration.audioTracks) { console.log(track); }
 * const tracks = Array.from(integration.audioTracks);
 * ```
 */
export declare interface AudioTrackList extends MediaTrackList<AudioTrack> {
    /** The currently selected audio track, or `null` if unavailable. */
    readonly selected: AudioTrack | null;
    /**
     * Selects an audio track.
     * @param trackOrId - The track or track ID to select.
     */
    select(trackOrId: AudioTrack | string): void;
}

declare class BaseMediaError<T extends string = string> extends Error {
    code: T;
    name: string;
    constructor(message: string, code: T);
}

/**
 * Base Shaka configurator applied to every source.
 *
 * Contains default retry parameters (optimized settings coordinated with
 * Wolfgang Dworzak), streaming defaults and DRM configuration derived from
 * the context's source data. Provider-specific configurators should
 * extend this class so that the defaults are always included.
 */
declare class BaseShakaConfigurator implements ShakaConfigurator {
    #private;
    getPlayerConfig(context: ShakaSourceContext): Record<string, unknown>;
    getNetworkFilters(_context: ShakaSourceContext): ShakaNetworkFilters;
}

declare type BrowserType = 'safari-ios' | 'safari-webview' | 'safari-ios-chrome' | 'safari-ios-firefox' | 'safari-ios-opera' | 'samsung' | 'edge' | 'chrome' | 'firefox' | 'opera' | 'safari' | 'android-webview' | 'unknown';

export declare interface Channel {
    /** Human-readable channel title shown in the player UI */
    name?: string;
    /** Stable machine-facing code used for lookups or analytics */
    code?: string;
    /** Provider-specific identifier when it differs from `code` */
    id?: string;
    /** Canonical playback or landing URL clients should open */
    url?: string;
    /** Square channel-logo URL (ideally 96x96) used wherever icons appear */
    logo?: string;
}

declare interface Companion {
    start: number;
    end: number;
    renderingMode: string;
    companions: {
        id: number | null;
        html: string;
        width: number;
        height: number;
    }[];
}

/**
 * Inject an implementation into a concrete integration instance to customise config loading.
 *
 * @example
 * ```ts
 * class MyIntegration extends IntegrationElement {
 *   constructor() {
 *     super({
 *       config: {
 *         async fetchConfig({ integrationId }) {
 *           return fetch(`/my-proxy/${integrationId}`).then(r => r.json());
 *         },
 *       },
 *     });
 *   }
 * }
 * ```
 */
declare interface ConfigAdapter {
    /**
     * Fetch the player configuration for the given integration ID.
     * Called once per player initialisation.
     */
    fetchConfig(params: {
        integrationId: string;
        env?: string | null;
    }): Promise<PlayerConfigInput | undefined>;
    /**
     * Optional, tenant-specific. Merges context-derived adjustments into the
     * resolved config (never replaces). The `context` is the opportunistic
     * context produced by the media provider during resolution; it may be
     * absent, in which case a tenant may fetch it itself.
     */
    refineConfig?(config: PlayerConfig): Promise<PlayerConfig>;
    /**
     * Optional. Returns the styles URL pattern for the given environment.
     * `{id}` in the returned string is replaced with the integration ID at load time.
     * When provided, this takes precedence over any statically configured styles URL.
     */
    getStylesUrl?(env: string | null): string | undefined;
    /**
     * Optional. Called by the integration element after the internal
     * {@link MediaResolver} is created, for adapters that need to
     * resolve media context during {@link refineConfig}.
     */
    setContextResolver?(registry: MediaResolver): void;
}

/**
 * Describes the contract that an external API tracking script must implement so that it can be
 * imported and executed by the integration. The API script must be hosted on the remote server
 * with CORS enabled.
 *
 * @example
 * ```ts
 * import { IntegrationEvent } from '@turbo-player/integration-web-component';
 * export const connectIntegration: ConnectIntegration = (
 *   integration,
 *   // userId will be undefined when no consent is given
 *   { userCountryCode, userId, integrationEnvironment }
 * ) => {
 *   integration.addEventListener(IntegrationEvent.CONTENT_PLAY, () => {
 *     console.log('play', integration.content);
 *   });
 * };
 * ```
 *
 * @example
 * ```js
 * export const connectIntegration = (
 *   integration,
 *   // userId will be undefined when no consent is given
 *   { userCountryCode, userId, integrationEnvironment }
 * ) => {
 *   const { IntegrationEvent } = integration.constructor;
 *   integration.addEventListener(IntegrationEvent.CONTENT_PLAY, () => {
 *     console.log('play', integration.content);
 *   });
 * };
 * ```
 */
export declare type ConnectIntegration = (integration: IntegrationElement, context: {
    userCountryCode?: string;
    userId?: string;
    integrationEnvironment?: string;
}, options?: {
    warnCallback?: (error: Error) => void;
}) => (() => void) | undefined;

export declare interface Consent {
    gdprApplies: boolean;
    consentString?: string;
    /** @internal */
    cacheFriendlyConsentString?: string;
    /** @internal */
    tcfVersion?: TcfVersion;
    cmpId?: number;
    policyVersion?: number;
    vendorListVersion?: number;
    hasPurpose1Consent?: boolean;
    vendorConsents?: Record<number, boolean>;
    vendorLegitimateInterests?: Record<number, boolean>;
    purposeConsents?: Record<number, boolean>;
    purposeLegitimateInterests?: Record<number, boolean>;
    specialFeatureOptins?: Record<number, boolean>;
    lastUpdated?: number;
    publisherRestrictions?: Record<string, {
        purpose: number;
        isAllowed: boolean;
        isConsentRequired: boolean;
        isLegitimateInterestRequired: boolean;
    }[]>;
    pubPurposeConsents?: Record<number, boolean>;
    pubPurposeLegitimateInterests?: Record<number, boolean>;
    ready: boolean;
    addtlConsent?: string;
}

declare interface ConsentAdapter {
    getGvlId?(): number | undefined;
}

/**
 * Playback metrics for the current content item.
 * Updated continuously as playback progresses.
 */
export declare interface ContentMetrics {
    /** Seconds content was playing while viewable for the current content item. */
    contentViewableTime: number;
    /** Seconds content was playing while not viewable for the current content item. */
    contentNonviewableTime: number;
    /** Seconds content was playing while audible for the current content item. */
    contentAudibleTime: number;
    /** Seconds content was playing while not audible for the current content item. */
    contentNonaudibleTime: number;
    /** Total seconds content was playing for the current content item. */
    contentTotalTime: number;
    /** Seconds ads were playing while viewable for the current content item. */
    adViewableTime: number;
    /** Seconds ads were playing while not viewable for the current content item. */
    adNonviewableTime: number;
    /** Seconds ads were playing while audible for the current content item. */
    adAudibleTime: number;
    /** Seconds ads were playing while not audible for the current content item. */
    adNonaudibleTime: number;
    /** Total seconds ads were playing for the current content item. */
    adTotalTime: number;
    /** Time in ms from initiating playback to first Ad or Content Begin for the current content item. */
    timeToPlay: number | undefined;
    /** Whether an ad was active when the user first unmuted. Only set if the player was unmuted. */
    adActiveWhenUnmuted?: boolean;
    /** The reason the player was first unmuted. Only set if the player was unmuted. */
    unmuteReason?: 'document-click' | 'tap-to-unmute';
}

export declare enum ContentStopReason {
    CLEAR_PLAYLIST = "clearPlaylist",
    SELECT_PLAYLIST_ITEM = "selectPlaylistItem",
    ENDED = "ended",
    CONTENT_ERROR = "contentError",
    API_STOP = "apiStop",
    LIVESTREAM_STOP = "livestreamStop",
    LIVESTREAM_NOT_STARTED = "livestreamNotStarted",
    PAGE_HIDE = "pageHide",
    BEFORE_UNLOAD = "beforeUnload"
}

declare interface Context {
    integrationVersion: string;
}

/**
 * Server-derived context for the resolved integration + content.
 * Use `extra` for additional tenant-specific signals.
 * @inline
 */
declare interface ContextConfig {
    userCountryCode?: string;
    deviceType?: string;
    publisherId?: string;
    publisherCountryCode?: string;
    partnerId?: string;
    partnerName?: string;
    productName?: string;
    productFormat?: string;
    extra?: Record<string, unknown>;
}

export declare function createIntegrationClient(config: IntegrationConfig): {
    /**
     * Returns the custom element name for the configured component.
     */
    getComponentName: () => string;
    /**
     * Returns the CSS URL for a given integration using the configured settings.
     */
    getCssUrl: (integrationId: string) => string;
    /**
     * Loads the integration custom element using the configured settings.
     */
    loadComponent: () => void;
    /**
     * Loads the variant CSS for the given integration ID using the configured settings.
     */
    loadStyles: (integrationId: string, doc?: Document | ShadowRoot) => void;
    /**
     * Returns the {@link HostContext} singleton from the loaded integration.
     */
    getHostContext: () => Promise<HostContext>;
};

export declare interface CustomMarker extends Omit<Marker, 'name'> {
    /** {@inheritDoc Marker.name} */
    name: string;
}

declare interface Datetime {
    hourOfDay: number;
    dayOfMonth: number;
    dayOfWeek: number;
}

/**
 * Development-only flags — gated to allowed domains and not forwarded to production.
 * Set via the inline config, the `?turboConfig=` URL parameter, or `localStorage` (debug mode).
 * @inline
 */
declare interface DevelopmentFlags {
    [key: string]: unknown;
    /** Enable debug mode. Can also be set via the `?turboDebug=true` URL parameter. */
    debug?: boolean;
    /** Target the stage environment instead of production. */
    environment?: 'stage';
    /** Final-layer config override — applied on top of defaults, remote, and inline config. */
    configOverrides?: PlayerConfigInput;
    /** Override the styles URL. */
    stylesUrl?: string;
}

declare interface Device {
    browserType?: BrowserType;
    browserLanguage: string;
    osVersion?: string;
    osType: OsType;
    type: DeviceType;
    runtimeEnvironment: RuntimeEnvironment;
    isTouchDevice?: boolean;
    viewport: {
        width: number;
        height: number;
    };
}

/**
 * Identifier names for device IDs that can be passed via {@link HostContextData.deviceId}.
 */
export declare enum DeviceIdName {
    /** Android Advertising ID (Google) */
    AAID = "aaid",
    /** Amazon Fire OS Advertising ID */
    AFAI = "afai",
    /** Android App Set ID — scope: app */
    ASIA = "asia",
    /** Android App Set ID — scope: developer */
    ASID = "asid",
    /** Tizen Identifier for Advertising (Samsung) */
    TIFA = "tifa",
    /** VIDAA Advertising ID (Hisense) */
    VAID = "vaid",
    /** Apple Identifier for Advertisers */
    IDFA = "idfa",
    /** Apple Identifier for Vendors */
    IDFV = "idfv",
    /** LG Unique Device ID */
    LGUDID = "lgudid",
    /** Microsoft Advertising ID */
    MSAI = "msai",
    /** Huawei Open Advertising ID */
    OAID = "oaid",
    /** PlayStation Advertising ID */
    PSNAI = "psnai",
    /** Roku Identifier for Advertising */
    RIDA = "rida",
    /** Vizio Advertising ID */
    VIDA = "vida",
    /** TitanOS Advertising ID (Walmart) */
    WAID = "waid"
}

declare type DeviceType = 'connectedtv' | 'desktop' | 'mobile' | 'settopbox' | 'tablet';

/** @interface */
declare type DockConfig = typeof DockConfigSchema.infer;

/**
 * Dock (formerly sticky) configuration
 */
declare const DockConfigSchema: ObjectType<    {
enable: boolean;
position: "bottom" | "bottomLeft" | "bottomRight" | "left" | "right" | "stickyTop" | "stickyTopExpanded" | "top" | "topLeft" | "topRight";
top: string;
right: string;
bottom: string;
left: string;
allowAdClose: boolean;
snapTop: string;
targetSelector?: string | undefined;
}, {}>;

export declare enum DockPosition {
    TOP = "top",
    BOTTOM = "bottom",
    LEFT = "left",
    RIGHT = "right",
    BOTTOM_LEFT = "bottomLeft",
    BOTTOM_RIGHT = "bottomRight",
    TOP_LEFT = "topLeft",
    TOP_RIGHT = "topRight",
    STICKY_TOP = "stickyTop",
    STICKY_TOP_EXPANDED = "stickyTopExpanded"
}

/**
 * Generic DRM fields for a single DRM system.
 */
declare interface DrmSourceData {
    /** {@inheritDoc SourceMediaItemDrm.drmSystem} */
    drmSystem?: DrmSystem;
    /** {@inheritDoc SourceMediaItemDrm.licenseUrl} */
    licenseUrl?: string;
    /** {@inheritDoc SourceMediaItemDrm.certificateUrl} */
    certificateUrl?: string;
    /** {@inheritDoc SourceMediaItemDrm.token} */
    token?: string;
}

declare type DrmSupport = ReadonlySet<DrmSystem>;

/**
 * Standard EME key system identifiers for the DRM systems supported by the player.
 *
 * Set by the content service after DRM-support detection and source
 * selection so that the video element only needs to know *which* DRM
 * system is in use — without license URIs, tokens or certificates.
 */
export declare enum DrmSystem {
    FAIRPLAY = "com.apple.fps",
    WIDEVINE = "com.widevine.alpha",
    PLAYREADY = "com.microsoft.playready"
}

/**
 * A dynamic content ES module must export a `create` function matching this
 * interface. Sources of this type are identified by the
 * {@link Mimetype.DYNAMIC_CONTENT} mimetype.
 *
 * The player dynamically `import()`s the module and awaits the promise
 * returned by `create()` before starting playback. The resolved object's
 * `destroy` is called when the player unloads the content.
 *
 * The module runs in the embedding page's realm — `window` and `document`
 * are the page's globals. `container` is an element rendered inside a
 * dedicated shadow root, so DOM and CSS appended to it are isolated in both
 * directions.
 *
 * When a TCF consent string is available it is appended as the `consent`
 * query parameter to the module URL; read it via
 * `new URL(import.meta.url).searchParams.get('consent')`.
 *
 * @example The module itself
 * ```js
 * export async function create({ mediaElement, container }) {
 *   // render into container, listen to mediaElement events …
 *   return { destroy() { /* tear down *\/ } };
 * }
 * ```
 *
 * @example Attaching the module to an integration
 *
 * Dynamic content is delivered as a regular media item source whose
 * `mimetype` is `application/x-turbo-dynamic-content` and whose `src` points
 * to the ES module URL. The simplest way to wire it up is via
 * {@link ExternalMediaItemElement}. The media item's `duration` (in seconds)
 * controls playback length — the player‑supplied `mediaElement` reports it as
 * its duration.
 *
 * ```html
 * <my-integration
 *   integration-id="YOUR_INTEGRATION_ID"
 * >
 *   <external-media-item>
 *     <script type="application/external-media-item+json">
 *       {
 *         "id": "my-dynamic-content",
 *         "title": "My Dynamic Content",
 *         "poster": "POSTER_URL",
 *         "duration": 15,
 *         "sources": [
 *           {
 *             "src": "https://example.com/my-dynamic-content.js",
 *             "mimetype": "application/x-turbo-dynamic-content"
 *           }
 *         ]
 *       }
 *     </script>
 *   </external-media-item>
 * </my-integration>
 * ```
 */
export declare interface DynamicContent {
    create(context: {
        /**
         * The player's media element, proxied so that listeners added via
         * `addEventListener()` are removed automatically on destroy. Listeners
         * attached to other objects, or via handler properties (`onplay = ...`),
         * are not cleaned up automatically.
         */
        mediaElement: HTMLMediaElement;
        /**
         * Element to render into. Lives inside its own shadow root, so DOM and
         * CSS appended here are isolated from the embedding page and the player
         * UI in both directions. Sized to the player viewport — use
         * `getBoundingClientRect()` or a `ResizeObserver`, not `window.innerWidth`.
         */
        container: HTMLElement;
    }): Promise<{
        /** Tear down: remove DOM, cancel animations, close audio contexts, etc. */
        destroy(): void;
    }>;
}

/** @interface */
declare type EarlyRecommendationsConfig = typeof EarlyRecommendationsConfigSchema.infer;

/**
 * Early recommendations configuration
 */
declare const EarlyRecommendationsConfigSchema: ObjectType<    {
enable: boolean;
showAfterSeconds: number;
minimumContentDurationSeconds: number;
buttonCountdownSeconds: number;
maximumVisibility: number;
}, {}>;

export declare enum Endscreen {
    CONTINUE = "continue",
    NONE = "none"
}

declare interface EnvironmentState {
    device: Device;
    page: Page;
    article: Article;
    context: Context;
    datetime: Datetime;
    otherIntegrations: OtherIntegrations;
    allowDocking: boolean;
    enableSingleDockMode: boolean;
}

export declare interface EpgEntry {
    startDate: number;
    endDate: number;
    name: string;
    title?: string;
    poster?: string;
    currentProgram?: boolean;
}

/** @interface */
declare type Experiment = typeof ExperimentSchema.infer;

/**
 * A single experiment definition.
 *
 * Mirrors the experiment configuration used by the CloudFront Function
 * to roll A/B experiment assignments.
 *
 * @see turbo-platform-infrastructure/.../config-viewer-request.js
 * @see packages/integration/src/integration/experiments.ts
 */
declare const ExperimentSchema: ObjectType<    {
name: string;
enabled: boolean;
type: "integration";
participantPercentage: number;
variants: {
[x: string]: {
weight: number;
};
};
persist: boolean;
exclusive: boolean;
}, {}>;

export declare interface ExtendedVideoPlaybackQuality extends VideoPlaybackQuality {
    bitrate: number;
    liveLatency: number;
    throughput: number;
    bytes: number;
    bandwidth: number;
    width: number;
    height: number;
}

/** @ignore */
export declare const EXTERNAL_PLAYER_NAME = "turbo-player";

/**
 * Legacy publisher-facing context object for static page/app context and
 * publisher-supplied user ids. Replaced by {@link HostContextData}; accepted
 * on the integration element for backward compatibility only.
 *
 * @deprecated Use {@link HostContextData} via {@link IntegrationElement.hostContext} instead.
 */
export declare interface ExtraContext {
    /** {@link HostContextData.presentationalContext} */
    presentationalContext?: 'curated-list' | 'discovery-page';
    /** {@link HostContextData.appVersion} */
    appVersion?: string;
    /** {@link HostContextData.appName} */
    appName?: string;
    /** {@link HostContextData.appBundleId} */
    appBundleId?: string;
    /** {@link HostContextData.appStoreId} */
    appStoreId?: string;
    /** {@link HostContextData.appStoreUrl} */
    appStoreUrl?: string;
    /** {@link HostContextData.b2bContext} */
    b2bContext?: string;
    /** {@link HostContextData.deviceId} */
    deviceId?: {
        id: string;
        name: DeviceIdName | `${DeviceIdName}`;
    };
    /**
     * User ids to expose. Each entry is translated to a static
     * `hostContextData.userIds` registration.
     */
    userIds?: {
        id: string;
        name: UserIdName | `${UserIdName}`;
        ext?: Record<string, unknown>;
    }[];
}

/**
 * Global context singleton shared by every integration element on the page.
 *
 * @example JavaScript
 * ```ts
 * await customElements.whenDefined('my-integration');
 * const integration = document.querySelector('my-integration');
 * const { hostContext } = integration.constructor;
 *
 * hostContext.set({
 *   appVersion: '2.3.0',
 *   deviceId: { id: '...', name: 'idfa' },
 *   providers: { 'my-provider': async () => ({ token: await myAuth.getFreshToken() }) },
 *   userIds: { netId: async ({ consent }) => consent ? { id: await getNetId() } : null },
 * });
 * ```
 *
 * @example React
 * ```tsx
 * <Integration
 *   tagName="my-integration"
 *   moduleUrl="https://example.com/integration/1/integration.js"
 *   integrationId="YOUR_INTEGRATION_ID"
 *   hostContextData={{
 *     appVersion: '2.3.0',
 *     userIds: { netId: async ({ consent }) => consent ? { id: await getNetId() } : null },
 *   }}
 * />
 * ```
 */
export declare interface HostContext {
    /** Merge context data. Static fields are replaced; `providers` and `userIds` are merged per-name. */
    set(data: HostContextData): void;
    /** Read a static value. Returns `undefined` when not set. */
    get<K extends Exclude<keyof HostContextData, 'providers' | 'userIds'>>(key: K): HostContextData[K] | undefined;
    /** Whether a static value has been set. */
    has(key: Exclude<keyof HostContextData, 'providers' | 'userIds'>): boolean;
    /** Whether a user-id resolver has been registered. */
    hasUserId(name: string): boolean;
}

/**
 * Data object accepted by {@link HostContext.set}.
 *
 * - **Static fields** — last write wins.
 * - **`providers`** — merged per-name; pass `null` to remove.
 * - **`userIds`** — merged per-name; pass `null` to remove.
 */
export declare interface HostContextData {
    /**
     * Presentational context of the integration.
     * Omit when not applicable.
     */
    presentationalContext?: 'curated-list' | 'discovery-page';
    /** Deployed version of the app or website. */
    appVersion?: string;
    /** Name of the app or website project. */
    appName?: string;
    /** Bundle id — required for iOS apps. */
    appBundleId?: string;
    /**
     * App store id — required for apps.
     * {@link https://iabtechlab.com/wp-content/uploads/2020/08/IAB-Tech-Lab-OTT-store-assigned-App-Identification-Guidelines-2020.pdf IAB Tech Lab App Identification Guidelines}
     */
    appStoreId?: string;
    /**
     * App store URL — required for apps.
     * {@link https://iabtechlab.com/wp-content/uploads/2020/08/IAB-Tech-Lab-OTT-store-assigned-App-Identification-Guidelines-2020.pdf IAB Tech Lab App Identification Guidelines}
     */
    appStoreUrl?: string;
    /** Business-to-business context identifier. */
    b2bContext?: string;
    /** Device id — required for app environments. Use a `ppid` user id when no device id is available. */
    deviceId?: {
        id: string;
        name: DeviceIdName | `${DeviceIdName}`;
    };
    /**
     * Media-provider resolvers keyed by provider name. Merged per-name; pass `null` to remove.
     *
     * @example
     * ```ts
     * hostContext.set({
     *   providers: { myProvider: async () => ({ token: await myAuth.getFreshToken() }) },
     * });
     * ```
     */
    providers?: {
        [providerName: string]: ((context: {
            consent?: Consent;
            environment?: string;
        }) => MediaProviderContext | Promise<MediaProviderContext>) | null;
    };
    /**
     * User-id resolvers keyed by {@link HostContextUserIdKey}. Merged per-name; pass `null` to remove.
     * Each entry may be a static value or a sync/async resolver that receives `{ consent, environment }`.
     *
     * Resolvers are invoked fresh each time the player needs user IDs, so they always reflect the
     * current consent state. Return `null` or `undefined` if the value isn't available yet; call
     * `hostContext.set()` again once it is — because entries are merged per-name, the replacement
     * is picked up on the next resolution.
     *
     * @example
     * ```ts
     * hostContext.set({
     *   userIds: {
     *     ppid: { id: 'abc-…' },                       // static
     *     netId: () => ({ id: window.netId }),         // sync resolver
     *     liverampId: async ({ consent }) => {         // async, consent-aware
     *       if (!consent?.vendorConsents[97]) return null;
     *       return { id: await ats.getEnvelope() };
     *     },
     *   },
     * });
     *
     * // Once an async SDK resolves, re-register as a static value so the next
     * // resolution picks it up immediately instead of calling the resolver again.
     * ats.retrieveEnvelope().then((envelope) => {
     *   if (envelope) hostContext.set({ userIds: { liverampId: { id: envelope } } });
     * });
     * ```
     */
    userIds?: HostContextUserIds;
}

/** Static (non-registry) keys of {@link HostContextData}. */
declare type HostContextStaticKey = Exclude<keyof HostContextData, 'providers' | 'userIds'>;

/** Snapshot of every static value currently held in the shared context. */
declare type HostContextStaticSnapshot = {
    [K in HostContextStaticKey]?: HostContextData[K];
};

/**
 * Publisher-facing shape of a user ID entry.
 *
 * Internal ortb2 metadata (`atype`, `gvlId`) is applied centrally by the consumer.
 * `source` may be overridden by the resolver; pass `''` to suppress the EID entirely.
 */
export declare interface HostContextUserIdDefinition {
    id: string;
    /** Optional ortb2 `ext` payload merged into the resulting EID. */
    ext?: Record<string, unknown>;
    /** Optional ortb2 EID `source` override. Pass `''` to keep the id internal-only. */
    source?: string;
    /**
     * Additional UIDs for the same EID source (ortb2 `uids[1..]`).
     * The `atype` for each entry is inherited from the registry, matching the
     * primary uid. Useful when an id vendor returns multiple IDs per source
     * (e.g. Prebid.js EIDs with more than one uid).
     */
    additionalUids?: {
        id: string;
        ext?: Record<string, unknown>;
    }[];
}

/**
 * Allowed keys for {@link HostContextData.userIds}.
 *
 * Includes well-known ids (`netId`, `ppid`, …) for autocomplete, plus any string
 * for internal resolvers. Unknown names are silently ignored by the consumer.
 */
export declare type HostContextUserIdKey = UserIdName | `${UserIdName}` | (string & {});

export declare type HostContextUserIdResolver = (context: {
    consent?: Consent;
    environment?: string;
}) => HostContextUserIdDefinition | null | undefined | Promise<HostContextUserIdDefinition | null | undefined>;

/**
 * User-id resolver map accepted by {@link HostContextData.userIds}.
 *
 * Each entry is either a static {@link HostContextUserIdDefinition} or a
 * {@link HostContextUserIdResolver} function. Pass `null` to remove a previously
 * registered entry.
 */
export declare type HostContextUserIds = {
    [name in HostContextUserIdKey]?: HostContextUserIdDefinition | HostContextUserIdResolver | null;
};

declare interface IBaseAdPlayerElement extends HTMLElement {
    OmidPartnerName: string;
    OmidPartnerVersion: string;
    adPlayerType: string;
    volume: number;
    muted: boolean;
    adActive: string;
    /** Mirrors `state.ui.userInteracting`; used to defer transient ad overlays (e.g. pause ads) while a popup is open. */
    userInteracting: boolean;
    readonly paused: boolean | undefined;
    readonly supportsFullscreen: boolean;
    readonly isCustomPlaybackUsed: boolean;
    readonly adSchedulingMode: 'internal' | 'external';
    /**
     * A DOM element that receives ad click events, enabling custom UI for ad click-throughs.
     *
     * Enable via `ad.enableCustomClickButton` configuration.
     *
     * When enabled, this element can be positioned in the UI layer (e.g., inside an advertiser button)
     * to receive trusted click events that trigger the ad click-through URL and tracking.
     *
     * **IMA:** Only works on mobile browsers. The element must be passed during
     * AdDisplayContainer initialization, which is the only way IMA allows custom click handling.
     *
     * **ads-sdk:** Works on all browsers.
     *
     * @returns The click element if enabled and in use, otherwise `null`.
     */
    readonly customClickElement: HTMLElement | null;
    activate(): void;
    setup(params: MonetizationParams): Promise<void>;
    start(): Promise<void>;
    play(): Promise<void>;
    pause(): void | Promise<void>;
    stop(): void;
    requestAds(adRequestParams: MonetizationAdRequestParams, pod: VastPod | null): Promise<unknown>;
    requestVideoFullscreen(): Promise<void>;
}

declare abstract class IBaseMediaProvider {
    static providerName: string;
    providerName: string;
    protected _params: MediaProviderParams;
    protected _hostContext: InternalHostContext;
    protected _integrationElement: Element;
    protected _window: Window;
    context?: ContextConfig;
    constructor(window: Window, { hostContext, integrationElement }: {
        hostContext: InternalHostContext;
        integrationElement: Element;
    });
    setParams(params: MediaProviderParams): void;
    getRecommendations(_mediaItem: MediaItemResolved, _signal: AbortSignal): Promise<Awaited<ReturnType<IBaseMediaProvider['resolve']>>>;
    abstract resolve(items: MediaItemReference[], signal: AbortSignal): Promise<(MediaItem & {
        originalId: string;
    })[]>;
    abstract getSources(mediaItem: MediaItemResolved, signal: AbortSignal, onTerminated: (error: MediaItemError, reload?: boolean) => void, context: {
        getDrmSupport: () => Promise<DrmSupport>;
        getNonceString: () => Promise<string>;
        getUserIds: () => Promise<Record<string, UserId>>;
        getConsent: () => Promise<Consent>;
        getPin: () => string | undefined;
    }): Promise<ProviderSourceOutput[]>;
}

/**
 * Name of the shadow-DOM `<slot>` that the inline player-config `<script>`
 * tag is routed into. Also used as the slot's `id` and as the value the
 * integration element stamps onto the script's `slot` attribute, so all four
 * call-sites stay in sync via this single constant.
 *
 * @internal
 */
export declare const INLINE_PLAYER_CONFIG_SLOT_NAME = "inline-player-config";

export declare type IntegrationConfig = {
    /**
     * The URL to the integration module (JavaScript file).
     * When provided, the integration component is loaded automatically via {@link loadComponent}.
     */
    moduleUrl?: string;
    /**
     * The custom element tag name for the integration component.
     * This is required and must be a valid Web Component tag name (e.g., "glomex-integration").
     */
    tagName: string;
    /**
     * CSS URL pattern for the integration styles.
     * - If `undefined`: the CSS URL is derived from `moduleUrl` as `{origin}/config/{id}/styles.css`,
     *   enabling CSS preloading before the integration JS has finished loading.
     * - If `false`: CSS preloading is explicitly disabled. The element will still load its own CSS
     *   internally via its `serviceConfig` — no override is passed.
     * - If a string: that URL is used for both the `<link>` preload and as a `serviceConfig` override.
     *   The string can contain an `{id}` placeholder which gets replaced with the integration ID.
     */
    stylesUrl?: string | false;
};

export declare abstract class IntegrationElement extends HTMLElement implements IntegrationProperties {
    #private;
    static MarkerType: typeof MarkerType;
    static KnownMarkerName: typeof KnownMarkerName;
    static PlaybackMode: typeof PlaybackMode;
    static Mimetype: typeof Mimetype;
    static PresentationMode: typeof PresentationMode;
    static IntegrationEvent: typeof IntegrationEvent;
    /**
     * The {@link HostContext} singleton for the concrete element class this
     * is accessed on. Lazily created on first access.
     *
     * @example
     * ```ts
     * await customElements.whenDefined('my-integration');
     * customElements.get('my-integration')?.hostContext.set({ appName: 'my-app' });
     * ```
     */
    static get hostContext(): HostContext;
    /**
     * Instance-level alias for {@link IntegrationElement.hostContext} on the
     * concrete subclass. Safe to call from constructors.
     */
    get hostContext(): HostContext;
    /** @internal */
    private _store?;
    /** @internal */
    private _api?;
    /**
     * {@inheritDoc IntegrationProperties.integrationId}
     * @attribute integration-id
     */
    integrationId?: string;
    /**
     * {@inheritDoc IntegrationProperties.index}
     * @attribute index
     */
    index?: number;
    /**
     * {@inheritDoc IntegrationProperties.hidden}
     * @attribute {on|off} hidden
     */
    hidden: boolean;
    /**
     * {@inheritDoc IntegrationProperties.topLevelIframe}
     * @attribute top-level-iframe
     */
    topLevelIframe: boolean;
    /**
     * {@inheritDoc IntegrationProperties.placement}
     * @attribute placement
     */
    placement?: string;
    variant?: string;
    /**
     * {@inheritDoc IntegrationProperties.crossorigin}
     * @attribute crossorigin
     */
    crossorigin?: IntegrationProperties['crossorigin'];
    /**
     * {@inheritDoc IntegrationProperties.userLanguage}
     * @attribute user-language
     */
    userLanguage?: string;
    /** @internal */
    origin: string;
    /**
     * Allows the publisher to provide a tracking parameter (UTM source) that is attached to some links.
     * @attribute utm-source
     * @internal
     */
    utmSource?: string;
    /**
     * Allows the publisher to provide a campaign-related tracking parameter (UTM campaign) that is attached to some links.
     * @attribute utm-campaign
     * @internal
     */
    utmCampaign?: string;
    /**
     * {@inheritDoc IntegrationProperties.schain}
     * @attribute schain
     */
    schain?: string;
    /**
     * Optional callback function invoked when the integration fails to load an advertisement.
     * The callback receives an object with a `reason` property that explains why no ad was loaded.
     * It must be defined before the element gets attached to the DOM.
     */
    passback?: (payload: {
        reason: string;
    }) => void;
    /**
     * {@inheritDoc IntegrationProperties.extraContext}
     */
    extraContext?: ExtraContext;
    /** @internal */
    _poster?: string;
    /** @internal */
    _teaser: boolean;
    /** @internal */
    _enableImaSdk: boolean;
    /** @internal */
    _variantTagName?: string;
    /** @internal */
    _adPlayerTagName?: string;
    /** @internal */
    _variantAvailable: boolean;
    /** @internal */
    private _showPlayerUi;
    /** @internal */
    private _userInteracting;
    /** @internal */
    private _addJsonLd;
    /** @internal */
    private _preload;
    /** @internal */
    private _integrationSessionId;
    /** @internal */
    _content?: MediaItemResolved;
    /** @internal */
    private _variantId?;
    /** @internal */
    _source?: SourceSelected;
    /** @internal */
    private _playlist?;
    /** @internal */
    private _consent?;
    /** @internal */
    private _page?;
    /** @internal */
    private _contentPlaybackTime;
    /** @internal */
    private _playbackStartMethod;
    /** @internal */
    private _currentAd?;
    /** @internal */
    private _epgEntries?;
    /** @internal */
    private _currentEpgEntry?;
    /** @internal */
    private _presentationMode;
    /** @internal */
    private _muted;
    /** @internal */
    private _volume;
    /** @internal */
    private _playbackRate;
    /** @internal */
    private _currentTime;
    /** @internal */
    private _duration;
    /** @internal */
    private _seeking;
    /** @internal */
    private _buffering;
    /** @internal */
    private _wallClockTime;
    /** @internal */
    private _paused;
    /** @internal */
    private _ended;
    /** @internal */
    private _adCurrentTime;
    /** @internal */
    private _adDuration;
    /** @internal */
    private _adPaused?;
    /** @internal */
    private _adMuted?;
    /** @internal */
    private _adVolume?;
    /** @internal */
    private _seekRange;
    /** @internal */
    private _config?;
    /** @internal */
    private _metrics;
    /**
     * TODO: can be removed when everyone uses new integration API. It gets ssigned via script.ts
     * @internal
     */
    player?: IntegrationElement;
    /**
     * Resolves when the integration API is available (e.g. setting volume, play, pause, etc.).
     * Alternatively to `element.addEventListener(IntegrationEvent.READY, () => {...})`
     */
    ready: Promise<void>;
    /** @internal */
    constructor({ mediaProviders, config, consent, 
        /**
        * Default user-id resolver maps for this tenant. Each map is merged in
        * order; keys already registered on `hostContext` by the publisher are
        * skipped so tenant defaults never override explicit publisher values.
        */
        userResolvers, 
        /**
        * Additional tenant-specific variants merged on top of the base variants.
        * Tenant-supplied entries take precedence over base entries with the same key.
        */
        variants, adPlayers, monetization, allowedDevelopmentDomains, defaultDevelopmentFlags, ldJsonAdapter, playerUiTagName, version }?: {
        mediaProviders?: Record<string, ProviderModuleLoader>;
        config?: ConfigAdapter;
        consent?: ConsentAdapter;
        userResolvers?: HostContextUserIds[];
        variants?: VariantLoaderMap;
        adPlayers?: AdPlayerMap;
        monetization?: MonetizationAdapter;
        allowedDevelopmentDomains?: string[];
        defaultDevelopmentFlags?: Partial<DevelopmentFlags>;
        ldJsonAdapter?: LdJsonAdapter;
        playerUiTagName?: string;
        version?: string;
    });
    /** @internal */
    updated(changedProperties: PropertyValues<this>): void;
    /** @internal */
    connectedCallback(): Promise<void>;
    /** @internal */
    disconnectedCallback(): void;
    /**
     * Initiates playback of the media content.
     * @param options.startMethod - The method used to start playback (defaults to CLICK)
     */
    play(options?: {
        startMethod: Exclude<StartMethod, StartMethod.PRE_CLICK>;
    }): Promise<void>;
    /**
     * Pauses the current media playback.
     */
    pause(): Promise<void>;
    /**
     * Snapshots current video frame. Requires {@link crossorigin} to be set to `anonymous`.
     */
    getCurrentVideoFrame(): Promise<ImageBitmap>;
    /**
     * Returns the current playback time (in seconds) of the media.
     */
    get currentTime(): number;
    /**
     * Returns the current extended playback quality.
     */
    getVideoPlaybackQuality(): {
        droppedVideoFrames: number;
        totalVideoFrames: number;
        creationTime: number;
        corruptedVideoFrames: number;
        bitrate: number;
        liveLatency: number;
        throughput: number;
        bytes: number;
        bandwidth: number;
        width: number;
        height: number;
    } | undefined;
    /**
     * Returns the current session ID.
     */
    get sessionId(): string;
    /**
     * Returns the current wall clock time (UNIX timestamp in seconds). Useful for livestreams.
     */
    get wallClockTime(): number;
    /**
     * Seeks the media to the specified time, updating the current playback time.
     *
     * To set an initial start time, use {@link MediaItem.resumePosition} on the media item.
     *
     * @param time - The time (in seconds) to seek to.
     */
    set currentTime(time: number);
    /**
     * Retrieves the total duration (in seconds) of the current media content.
     */
    get duration(): number;
    /**
     * Retrieves the seekable range of the current media content.
     * For VoD content, this typically represents the full duration (0 to duration).
     * For live streams, this represents the DVR window that can be seeked to.
     * The `start` and `end` properties are `undefined` if the seek range is not yet available.
     */
    get seekRange(): SeekRange;
    /**
     * Indicates whether the media playback is currently muted.
     */
    get muted(): boolean;
    /**
     * Mutes or unmutes the media playback.
     * @param value - A boolean value indicating whether to mute the media playback.
     */
    set muted(value: boolean);
    /**
     * Returns the current volume level of the media playback (0-1).
     */
    get volume(): number;
    /**
     * Sets the media playback volume to the specified level.
     * @param value - The volume level to be set (0-1).
     */
    set volume(value: number);
    /**
     * Returns the current playback speed.
     */
    get playbackRate(): number;
    /**
     * Sets the playback speed.
     * @param value - The playback speed to be set (e.g. 0.5, 1, 1.5, 2).
     */
    set playbackRate(value: number);
    /**
     * Returns `true` if the media playback is currently paused; otherwise, returns `false`.
     */
    get paused(): boolean;
    /**
     * Indicates whether the media playback has ended.
     */
    get ended(): boolean;
    /**
     * Indicates whether the media is currently in a seeking state.
     */
    get seeking(): boolean;
    /**
     * Indicates whether the media is currently in a buffering state.
     */
    get buffering(): boolean;
    /**
     * Retrieves the current presentation mode of the media player.
     * This mode may affect how the media is displayed.
     */
    get presentationMode(): PresentationMode;
    /**
     * Returns whether the ad playback is muted. If no ad is currently active, this value is `undefined`.
     */
    get adMuted(): boolean | undefined;
    /**
     * Retrieves the volume level for the ad playback. If no ad is currently active, this value is `undefined`.
     */
    get adVolume(): number | undefined;
    /**
     * Returns the current playback time (in seconds) for the ad content. If no ad is currently active, this value is `NaN`.
     */
    get adCurrentTime(): number;
    /**
     * Retrieves the total duration (in seconds) of the ad content. If no ad is currently active, this value is `NaN`.
     */
    get adDuration(): number;
    /**
     * Indicates whether the ad playback is currently paused. If no ad is currently active, this value is `undefined`.
     */
    get adPaused(): boolean | undefined;
    /**
     * Retrieves the currently selected content item.
     */
    get content(): MediaItemResolved | undefined;
    /**
     * Retrieves the EPG entries, if available.
     */
    get epgEntries(): EpgEntry[] | undefined;
    /**
     * Retrieves the current EPG entry, if available.
     */
    get currentEpgEntry(): EpgEntry | undefined;
    /**
     * Retrieves the currently selected source.
     */
    get source(): SourceSelected | undefined;
    /**
     * Retrieves the current playlist.
     */
    get playlist(): MediaItemResolved[] | undefined;
    /**
     * Provides access to the user's consent information.
     */
    get consent(): Consent | undefined;
    /**
     * Retrieves information about the detected page.
     */
    get page(): Page | undefined;
    /**
     * Retrieves the playback time (in seconds) of the current content.
     */
    get contentPlaybackTime(): number;
    /**
     * Retrieves details about the currently selected ad, if any.
     */
    get currentAd(): Ad | undefined;
    /**
     * The method used to start the current playback session.
     * Available as soon as play is requested, before any ads run.
     *
     * Only available because player-feedback-tracking requires this value early
     *
     * @internal
     */
    get playbackStartMethod(): StartMethod;
    /** Version of the integration */
    get version(): string;
    /**
     * Retrieves the resolved player configuration.
     * Available after the {@link ready} promise resolves.
     *
     * @useDeclaredType
     */
    get config(): PlayerConfig | undefined;
    /**
     * Playback metrics for the current content item.
     * Updated continuously as playback progresses.
     */
    get metrics(): ContentMetrics;
    /**
     * Sets the presentation mode of the media player to the specified mode. This mode affects how the integration gets displayed
     * (e.g. inline, dock, lightbox, fullscreen).
     *
     * @param {PresentationMode} mode - The presentation mode to set.
     * @param {Object} [options] - Optional configuration.
     * @param {boolean} [options.byUser=false] - Indicates if the change was initiated by a user action.
     */
    setPresentationMode(mode: PresentationMode | `${PresentationMode}`, { byUser }?: {
        byUser?: boolean | undefined;
    }): Promise<void>;
    /**
     * Exits the current presentation mode.
     *
     * @param {Object} [options] - Optional configuration.
     * @param {boolean} [options.byUser=false] - Indicates if the change was initiated by a user action.
     */
    exitCurrentPresentationMode({ byUser }?: {
        byUser?: boolean;
    }): Promise<void>;
    /**
     * Returns the audio track list.
     * You can use this to listen to audio track changes via `audioTracks.addEventListener('change', ...)`.
     *
     * **Note:** Audio tracks are available after the {@link ready | integration.ready} promise resolves.
     * @example
     * ```ts
     * await integration.ready;
     * for (const track of integration.audioTracks) { console.log(track); }
     * const tracks = Array.from(integration.audioTracks);
     * ```
     *
     * Use the `select()` method to change the active audio track:
     * @example
     * ```ts
     * integration.audioTracks?.select(trackId);
     * ```
     */
    get audioTracks(): AudioTrackList | undefined;
    /**
     * Returns the text track list.
     * You can use this to listen to text track changes via `textTracks.addEventListener('change', ...)`.
     *
     * **Note:** Text tracks are available after the {@link ready | integration.ready} promise resolves.
     * @example
     * ```ts
     * await integration.ready;
     * for (const track of integration.textTracks) { console.log(track); }
     * const tracks = Array.from(integration.textTracks);
     * ```
     *
     * Use the `select()` method to change the active text track, or pass `undefined` to disable:
     * @example
     * ```ts
     * integration.textTracks?.select(trackId);
     * integration.textTracks?.select(undefined); // disable text tracks
     * ```
     */
    get textTracks(): TextTrackList_2 | undefined;
    /**
     * Returns the video track list.
     * You can use this to listen to video track changes via `videoTracks.addEventListener('change', ...)`.
     *
     * **Note:** Video tracks are available after the {@link ready | integration.ready} promise resolves.
     * @example
     * ```ts
     * await integration.ready;
     * for (const track of integration.videoTracks) { console.log(track); }
     * const tracks = Array.from(integration.videoTracks);
     * ```
     *
     * Use the `select()` method to change the active video track, or pass `'auto'` for automatic quality selection:
     * @example
     * ```ts
     * integration.videoTracks?.select(trackId);
     * integration.videoTracks?.select('auto'); // enable ABR
     * ```
     */
    get videoTracks(): VideoTrackList | undefined;
    /** @internal */
    private _onIntegrationClick;
    /** @internal */
    static styles: CSSResult;
    /** @internal */
    render(): TemplateResult | undefined;
}

/**
 * Map of events that are dispatched by the {@link IntegrationElement}. The {@link IntegrationElement} provides
 * getters to read {@link IntegrationElement#consent consent}, {@link IntegrationElement#content content}, {@link IntegrationElement#page page}, {@link IntegrationElement#currentTime currentTime}, ... state from.
 *
 * @see {@link IntegrationEvent} for all event types as constants
 *
 * @example
 *
 * ```js
 * // using strings
 * integration.addEventListener('ready', () => {});
 * // using constants
 * const tagName = 'my-integration';
 * await window.customElements.whenDefined(tagName);
 * const integration = document.querySelector(tagName);
 * if (integration) {
 *   const { IntegrationEvent } = integration.constructor;
 *   integration?.addEventListener(IntegrationEvent.CONTENT_START, () => {});
 * }
 * ```
 */
export declare interface IntegrationElementEventMap {
    /**
     * @inheritdoc IntegrationEvent.READY
     * @eventProperty
     */
    [IntegrationEvent.READY]: CustomEvent<void>;
    /**
     * Fired once when the integration is created. Contains session-level context.
     * @eventProperty
     */
    [IntegrationEvent.INTEGRATION_CREATE]: CustomEvent<{
        userId: string | undefined;
        otherIntegrationsCount: number;
        createdAt: number;
        environment: 'prod' | 'stage';
        positionInArticle: PositionInArticle;
    }>;
    /**
     * @inheritdoc IntegrationEvent.INTEGRATION_ABORT
     * @eventProperty
     */
    [IntegrationEvent.INTEGRATION_ABORT]: CustomEvent<{
        error: SerializedError;
    }>;
    /**
     * @inheritdoc IntegrationEvent.INTEGRATION_AD_AVAILABLE
     * @eventProperty
     */
    [IntegrationEvent.INTEGRATION_AD_AVAILABLE]: CustomEvent<void>;
    /**
     * @inheritdoc IntegrationEvent.INTEGRATION_PASSBACK
     * @eventProperty
     */
    [IntegrationEvent.INTEGRATION_PASSBACK]: CustomEvent<{
        reason: string;
    }>;
    /**
     * @inheritdoc IntegrationEvent.INTEGRATION_IMPRESSION
     * @eventProperty
     */
    [IntegrationEvent.INTEGRATION_IMPRESSION]: CustomEvent<void>;
    /**
     * @inheritdoc IntegrationEvent.USER_UPDATE_CONSENT
     * @eventProperty
     */
    [IntegrationEvent.USER_UPDATE_CONSENT]: CustomEvent<void>;
    /**
     * @inheritdoc IntegrationEvent.PLAYLIST_UPDATE
     * @eventProperty
     */
    [IntegrationEvent.PLAYLIST_UPDATE]: CustomEvent<void>;
    /**
     * @inheritdoc IntegrationEvent.PLAYER_SET_PRESENTATION_MODE
     * @eventProperty
     */
    [IntegrationEvent.PLAYER_SET_PRESENTATION_MODE]: CustomEvent<{
        mode: PresentationMode;
        previousMode: PresentationMode;
    }>;
    /**
     * @inheritdoc IntegrationEvent.CONTENT_SELECT
     * @eventProperty
     */
    [IntegrationEvent.CONTENT_SELECT]: CustomEvent<{
        sessionId: string;
        source: SourceSelected;
    }>;
    /**
     * @inheritdoc IntegrationEvent.CONTENT_PROGRAM_CHANGED
     * @eventProperty
     */
    [IntegrationEvent.CONTENT_PROGRAM_CHANGED]: CustomEvent<EpgEntry | undefined>;
    /**
     * @inheritdoc IntegrationEvent.CONTENT_START
     * @eventProperty
     */
    [IntegrationEvent.CONTENT_START]: CustomEvent<{
        startMethod: StartMethod;
        mutedOnStart: boolean;
        enabledApiScript: string | undefined;
    }>;
    /**
     * @inheritdoc IntegrationEvent.CONTENT_IMPRESSION
     * @eventProperty
     */
    [IntegrationEvent.CONTENT_IMPRESSION]: CustomEvent<void>;
    /**
     * @inheritdoc IntegrationEvent.CONTENT_BUFFERING_START
     * @eventProperty
     */
    [IntegrationEvent.CONTENT_BUFFERING_START]: CustomEvent<void>;
    /**
     * @inheritdoc IntegrationEvent.CONTENT_BUFFERING_END
     * @eventProperty
     */
    [IntegrationEvent.CONTENT_BUFFERING_END]: CustomEvent<void>;
    /**
     * @inheritdoc IntegrationEvent.CONTENT_STOP
     * @eventProperty
     */
    [IntegrationEvent.CONTENT_STOP]: CustomEvent<{
        reason: ContentStopReason;
    }>;
    /**
     * @inheritdoc IntegrationEvent.CONTENT_SUSPEND
     * @eventProperty
     */
    [IntegrationEvent.CONTENT_SUSPEND]: CustomEvent<void>;
    /**
     * @inheritdoc IntegrationEvent.CONTENT_ERROR
     * @eventProperty
     */
    [IntegrationEvent.CONTENT_ERROR]: CustomEvent<{
        error: SerializedError;
        recoverable: boolean;
    }>;
    /**
     * @inheritdoc IntegrationEvent.CONTENT_API_SCRIPT_WARN
     * @eventProperty
     */
    [IntegrationEvent.CONTENT_API_SCRIPT_WARN]: CustomEvent<{
        error: Error;
    }>;
    /**
     * @inheritdoc IntegrationEvent.CONTENT_MARKER_REACHED
     * @eventProperty
     */
    [IntegrationEvent.CONTENT_MARKER_REACHED]: CustomEvent<{
        markerName: string;
        markerData: unknown;
    }>;
    /**
     * @inheritdoc IntegrationEvent.TEASER_IMPRESSION
     * @eventProperty
     */
    [IntegrationEvent.TEASER_IMPRESSION]: CustomEvent<{
        teaserContentId: string;
        teaserEnvironment: TeaserEnvironment | (string & {});
    }>;
    /**
     * @inheritdoc IntegrationEvent.TEASER_CLICK
     * @eventProperty
     */
    [IntegrationEvent.TEASER_CLICK]: CustomEvent<{
        teaserContentId: string;
        teaserEnvironment: TeaserEnvironment | (string & {});
    }>;
    /**
     * @inheritdoc IntegrationEvent.CONTENT_TIME_UPDATE
     * @eventProperty
     */
    [IntegrationEvent.CONTENT_TIME_UPDATE]: CustomEvent<void> | HTMLElementEventMap['timeupdate'];
    /**
     * @inheritdoc IntegrationEvent.CONTENT_SEEKING
     * @eventProperty
     */
    [IntegrationEvent.CONTENT_SEEKING]: CustomEvent<void> | HTMLElementEventMap['seeking'];
    /**
     * @inheritdoc IntegrationEvent.CONTENT_SEEKED
     * @eventProperty
     */
    [IntegrationEvent.CONTENT_SEEKED]: CustomEvent<void> | HTMLElementEventMap['seeked'];
    /**
     * @inheritdoc IntegrationEvent.CONTENT_PLAY
     * @eventProperty
     */
    [IntegrationEvent.CONTENT_PLAY]: CustomEvent<void> | HTMLElementEventMap['play'];
    /**
     * @inheritdoc IntegrationEvent.CONTENT_PAUSE
     * @eventProperty
     */
    [IntegrationEvent.CONTENT_PAUSE]: CustomEvent<void> | HTMLElementEventMap['pause'];
    /**
     * @inheritdoc IntegrationEvent.CONTENT_VOLUME_CHANGE
     * @eventProperty
     */
    [IntegrationEvent.CONTENT_VOLUME_CHANGE]: CustomEvent<void> | HTMLElementEventMap['volumechange'];
    /**
     * @inheritdoc IntegrationEvent.CONTENT_RATECHANGE
     * @eventProperty
     */
    [IntegrationEvent.CONTENT_RATECHANGE]: CustomEvent<void> | HTMLElementEventMap['ratechange'];
    /**
     * @inheritdoc IntegrationEvent.CONTENT_ENDED
     * @eventProperty
     */
    [IntegrationEvent.CONTENT_ENDED]: CustomEvent<void> | HTMLElementEventMap['ended'];
    /**
     * @inheritdoc IntegrationEvent.AD_BREAK_REQUEST
     * @eventProperty
     */
    [IntegrationEvent.AD_BREAK_REQUEST]: CustomEvent<{
        name: string;
        index: number;
        plannedSlotCount: number;
        plannedAdRequestCount: number;
    }>;
    /**
     * @inheritdoc IntegrationEvent.AD_BREAK_REQUEST_ERROR
     * @eventProperty
     */
    [IntegrationEvent.AD_BREAK_REQUEST_ERROR]: CustomEvent<{
        name: string;
        index: number;
        error: Error & {
            code?: string;
        };
    }>;
    /**
     * @inheritdoc IntegrationEvent.AD_LOADED
     * @eventProperty
     */
    [IntegrationEvent.AD_LOADED]: CustomEvent<void>;
    /**
     * @inheritdoc IntegrationEvent.AD_IMPRESSION
     * @eventProperty
     */
    [IntegrationEvent.AD_IMPRESSION]: CustomEvent<void>;
    /**
     * @inheritdoc IntegrationEvent.AD_BUFFERING_START
     * @eventProperty
     */
    [IntegrationEvent.AD_BUFFERING_START]: CustomEvent<void>;
    /**
     * @inheritdoc IntegrationEvent.AD_BUFFERING_END
     * @eventProperty
     */
    [IntegrationEvent.AD_BUFFERING_END]: CustomEvent<void>;
    /**
     * @inheritdoc IntegrationEvent.AD_TIME_UPDATE
     * @eventProperty
     */
    [IntegrationEvent.AD_TIME_UPDATE]: CustomEvent<void>;
    /**
     * @inheritdoc IntegrationEvent.AD_VOLUME_CHANGE
     * @eventProperty
     */
    [IntegrationEvent.AD_VOLUME_CHANGE]: CustomEvent<void>;
    /**
     * @inheritdoc IntegrationEvent.AD_PAUSED
     * @eventProperty
     */
    [IntegrationEvent.AD_PAUSED]: CustomEvent<void>;
    /**
     * @inheritdoc IntegrationEvent.AD_RESUMED
     * @eventProperty
     */
    [IntegrationEvent.AD_RESUMED]: CustomEvent<void>;
    /**
     * @inheritdoc IntegrationEvent.AD_CLICK
     * @eventProperty
     */
    [IntegrationEvent.AD_CLICK]: CustomEvent<void>;
    /**
     * @inheritdoc IntegrationEvent.AD_SKIPPED
     * @eventProperty
     */
    [IntegrationEvent.AD_SKIPPED]: CustomEvent<void>;
    /**
     * @inheritdoc IntegrationEvent.AD_COMPLETE
     * @eventProperty
     */
    [IntegrationEvent.AD_COMPLETE]: CustomEvent<void>;
    /**
     * @inheritdoc IntegrationEvent.AD_VIEWABLE_50_BY_2
     * @eventProperty
     */
    [IntegrationEvent.AD_VIEWABLE_50_BY_2]: CustomEvent<void>;
    /**
     * @inheritdoc IntegrationEvent.AD_VIEWABLE_100_BY_15
     * @eventProperty
     */
    [IntegrationEvent.AD_VIEWABLE_100_BY_15]: CustomEvent<void>;
    /**
     * @inheritdoc IntegrationEvent.AD_ERROR
     * @eventProperty
     */
    [IntegrationEvent.AD_ERROR]: CustomEvent<{
        error: AdError;
    }>;
    /**
     * @inheritdoc IntegrationEvent.UI_INTERACTION
     * @eventProperty
     */
    [IntegrationEvent.UI_INTERACTION]: CustomEvent<{
        action: UiAction;
    }>;
}

/**
 * Constants for all events dispatched by the {@link IntegrationElement}.
 *
 * @see {@link IntegrationElementEventMap} for a full list of event types and their payloads
 */
export declare enum IntegrationEvent {
    /**
     * When the integration got initialized.
     * @eventProperty
     */
    READY = "ready",
    /**
     * When the integration is created.
     * @eventProperty
     */
    INTEGRATION_CREATE = "integrationcreate",
    /**
     * When the integration got aborted because of a configuration / authorization error.
     * It is not triggered when the content errors.
     * @eventProperty
     */
    INTEGRATION_ABORT = "integrationabort",
    /**
     * When an ad is available.
     * @eventProperty
     */
    INTEGRATION_AD_AVAILABLE = "integrationadavailable",
    /**
     * When a passback is triggered because of no content or no ad. Only available when {@link IntegrationElement#passback} is set.
     * @eventProperty
     */
    INTEGRATION_PASSBACK = "integrationpassback",
    /**
     * When the integration became visible/viewable in the viewport.
     * @eventProperty
     */
    INTEGRATION_IMPRESSION = "integrationimpression",
    /**
     * When the user's consent got updated.
     * See {@link IntegrationElement#consent} to get the current consent.
     * @eventProperty
     */
    USER_UPDATE_CONSENT = "userupdateconsent",
    /**
     * When the playlist is updated (e.g. new media item got added). See {@link IntegrationElement#playlist} to get the current playlist items.
     * @eventProperty
     */
    PLAYLIST_UPDATE = "playlistupdate",
    /**
     * When the player's presentation mode got changed.
     * @eventProperty
     */
    PLAYER_SET_PRESENTATION_MODE = "playersetpresentationmode",
    /**
     * When content got selected. See {@link IntegrationElement#content} to get the current content.
     * @eventProperty
     */
    CONTENT_SELECT = "contentselect",
    /**
     * When the current EPG program changed. The event detail contains the current EPG entry, if any.
     * See {@link IntegrationElement#currentEpgEntry} to get the current program from the element.
     * @eventProperty
     */
    CONTENT_PROGRAM_CHANGED = "contentprogramchanged",
    /**
     * When content started initially (e.g. before ad break).
     * @eventProperty
     */
    CONTENT_START = "contentstart",
    /**
     * When the first frame of the content got played back.
     * @eventProperty
     */
    CONTENT_IMPRESSION = "contentimpression",
    /**
     * When content buffering started.
     * @eventProperty
     */
    CONTENT_BUFFERING_START = "contentbufferingstart",
    /**
     * When content buffering ended.
     * @eventProperty
     */
    CONTENT_BUFFERING_END = "contentbufferingend",
    /**
     * When content got stopped (e.g. loading another content or it ended normally). The reason is provided in the payload.
     * It gets triggered after a potential postroll.
     * @eventProperty
     */
    CONTENT_STOP = "contentstop",
    /**
     * When content playback is suspended due to a recoverable error (e.g. network error, PIN required).
     * The session is not over — playback may resume after a reload.
     * @eventProperty
     */
    CONTENT_SUSPEND = "contentsuspend",
    /**
     * When a content error occurs upon loading or playing the content.
     * @eventProperty
     */
    CONTENT_ERROR = "contenterror",
    /**
     * When an external API script reports a warning via its `warnCallback`.
     * @eventProperty
     */
    CONTENT_API_SCRIPT_WARN = "contentapiscriptwarn",
    /**
     * When a marker is reached. See {@link MediaItem#markers} how to define own markers.
     * @eventProperty
     */
    CONTENT_MARKER_REACHED = "contentmarkerreached",
    /**
     * When a teaser impression occurred.
     * @eventProperty
     */
    TEASER_IMPRESSION = "teaserimpression",
    /**
     * When a teaser was clicked.
     * @eventProperty
     */
    TEASER_CLICK = "teaserclick",
    /**
     * When the content's time updates. This is equal to {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/timeupdate_event HTMLMediaElement.timeupdate}.
     * See {@link IntegrationElement#currentTime} to get the current time.
     * @eventProperty
     */
    CONTENT_TIME_UPDATE = "timeupdate",
    /**
     * When the content is seeking. This is equal to {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/seeking_event HTMLMediaElement.seeking}.
     * See {@link IntegrationElement#seeking} to get the current seeking state.
     * @eventProperty
     */
    CONTENT_SEEKING = "seeking",
    /**
     * When the content has seeked. This is equal to {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/seeked_event HTMLMediaElement.seeked}.
     * @eventProperty
     */
    CONTENT_SEEKED = "seeked",
    /**
     * When the content switches from paused to playing. This is equal to {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/play_event HTMLMediaElement.play}.
     * @eventProperty
     */
    CONTENT_PLAY = "play",
    /**
     * When the content switches from playing to paused. This is equal to {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/pause_event HTMLMediaElement.pause}.
     * @eventProperty
     */
    CONTENT_PAUSE = "pause",
    /**
     * When the content's volume changes. This is equal to {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/volumechange_event HTMLMediaElement.volumechange}.
     * See {@link IntegrationElement#volume} to get the current volume.
     * @eventProperty
     */
    CONTENT_VOLUME_CHANGE = "volumechange",
    /**
     * When the content playback rate changes. This is equal to {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/ratechange_event HTMLMediaElement.ratechange}.
     * See {@link IntegrationElement#playbackRate} to get the current playback rate.
     * @eventProperty
     */
    CONTENT_RATECHANGE = "ratechange",
    /**
     * When the content reached its end. This is equal to {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/ended_event HTMLMediaElement.ended}.
     * See {@link IntegrationElement#ended} to check if the content ended.
     * @eventProperty
     */
    CONTENT_ENDED = "ended",
    /**
     * When an ad break gets requested
     * @eventProperty
     */
    AD_BREAK_REQUEST = "adbreakrequest",
    /**
     * When an ad break request fails
     * @eventProperty
     */
    AD_BREAK_REQUEST_ERROR = "adbreakrequesterror",
    /**
     * When an ad is loaded.
     * See {@link IntegrationElement#currentAd} to get the loaded ad.
     * @eventProperty
     */
    AD_LOADED = "adloaded",
    /**
     * When the first frame of the ad got played back.
     * See {@link IntegrationElement#currentAd} to get the current ad.
     * @eventProperty
     */
    AD_IMPRESSION = "adimpression",
    /**
     * When the ad started buffering.
     * @eventProperty
     */
    AD_BUFFERING_START = "adbufferingstart",
    /**
     * When the ad stopped buffering.
     * @eventProperty
     */
    AD_BUFFERING_END = "adbufferingend",
    /**
     * When the ad's time updates.
     * @eventProperty
     */
    AD_TIME_UPDATE = "adtimeupdate",
    /**
     * When the ad's volume changes.
     * See {@link IntegrationElement#adVolume} to get the current volume.
     * @eventProperty
     */
    AD_VOLUME_CHANGE = "advolumechange",
    /**
     * When the ad paused.
     * @eventProperty
     */
    AD_PAUSED = "adpaused",
    /**
     * When the ad resumed.
     * @eventProperty
     */
    AD_RESUMED = "adresumed",
    /**
     * When the ad was clicked.
     * @eventProperty
     */
    AD_CLICK = "adclick",
    /**
     * When the ad was skipped.
     * @eventProperty
     */
    AD_SKIPPED = "adskipped",
    /**
     * When the ad completed.
     * @eventProperty
     */
    AD_COMPLETE = "adcomplete",
    /**
     * When an ad has been viewable for 50% of its area for at least 2 seconds.
     * @eventProperty
     */
    AD_VIEWABLE_50_BY_2 = "adviewable50by2",
    /**
     * When an ad has been viewable for 100% of its area for at least 15 seconds, or when 50% of the ad duration is reached.
     * @eventProperty
     */
    AD_VIEWABLE_100_BY_15 = "adviewable100by15",
    /**
     * When a non-fatal ad error occurs during playback or setup (not triggered when ad loading fails).
     * @eventProperty
     */
    AD_ERROR = "aderror",
    /**
     * When the user interacted with the UI (e.g. play, pause, seek, etc.). The specific action is provided in the payload.
     * @eventProperty
     */
    UI_INTERACTION = "uiinteraction"
}

/**
 * Properties that can be set on the integration element.
 */
export declare interface IntegrationProperties {
    /**
     * The identifier for this integration. This value is used to determine the configuration and behavior of the integration.
     */
    integrationId?: string;
    /**
     * Determines the index of the media item within the playlist that should be or is currently selected.
     *
     * This property can be used to:
     * - **Switch between media items**: Set this property to navigate to a different item in the playlist (zero-based index).
     * - **Get the current playlist index**: Read this property to determine which media item is currently active in the playlist.
     */
    index?: number;
    /**
     * Hides the integration element when set to `true`.
     */
    hidden?: boolean;
    /**
     * An optional flag that can mark the integration as if it is running in a top-level window context. Useful when the embedded iframe represents an article, which contains this integration.
     */
    topLevelIframe?: boolean;
    /**
     * Allows the publisher to provide an optional placement attribute, which supplies additional contextual information for enhanced analytics tracking.
     * This can be a simple string or a stringified JSON object. If it is a stringified JSON object, its contents are forwarded as `placementDetail`. If the object contains a property key `name`, its value will be tracked for the placement attribute.
     */
    placement?: string;
    env?: 'stage';
    variant?: string;
    /**
     * The {@link https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Attributes/crossorigin crossorigin attribute}
     * is used to define the CORS (Cross-Origin Resource Sharing) policy for the video element.
     * Defaults to `anonymous`. If set to `none` (non-standard value) it won't require CORS headers
     * for the loaded media files, though text-tracks from foreign origins then cannot be loaded.
     */
    crossorigin?: '' | 'anonymous' | 'use-credentials' | 'none';
    /**
     * Preferred language for the current user.
     * When provided, this value is used for the UI instead of the browser language detected in the environment.
     * Accepts a BCP 47 language tag (e.g. "de", "en-US").
     */
    userLanguage?: string;
    /**
     * Supply chain (schain) information provided by the integrating party (e.g. meta-publisher).
     * Must be set as an IAB serialized string (e.g. `"1.0,1!exchange.com,123,1"`).
     * Supply chain nodes provided here are extended with the relevant downstream nodes.
     */
    schain?: string;
    /** {@inheritDoc ExtraContext} */
    extraContext?: ExtraContext;
}

/** @internal */
export declare const INTERNAL_PREFIX = "turbo";

declare interface InternalHostContext extends HostContext {
    /**
     * Resolve a media-provider context. Returns `undefined` when no resolver is registered.
     * @internal
     */
    getProvider<T extends MediaProviderContext = MediaProviderContext>(providerName: string, context?: {
        consent?: Consent;
        environment?: string;
    }): Promise<T | undefined>;
    /** @internal */
    getProviderNames(): readonly string[];
    /** @internal */
    hasProvider(providerName: string): boolean;
    /**
     * Resolve a single user id by name, applying the full pipeline: purpose-1
     * consent check, registry gate, vendor consent gate, resolver invocation,
     * PPID validation, and ortb2 enrichment.
     *
     * Returns the enriched {@link UserId} when all gates pass, or `undefined`
     * when the id is absent, ungated, or invalid.
     * @internal
     */
    getUserId(name: string, context?: {
        consent?: Consent;
        environment?: string;
    }): Promise<UserId | undefined>;
    /**
     * Resolve all registered user-id resolvers in parallel, apply registry
     * enrichment (ortb2 `atype`, `gvlId`, default `source`) and consent gating,
     * then return the pre-baked map. Entries whose name is unknown to the
     * registry, or whose required vendor consent is absent, are omitted.
     * @internal
     */
    getUserIds(context?: {
        consent?: Consent;
        environment?: string;
        /**
         * Optional abort signal. When the signal fires (e.g. via
         * `AbortSignal.timeout(ms)`) the call returns immediately with whatever
         * resolvers have already settled — slow or hanging resolvers are abandoned.
         */
        signal?: AbortSignal;
    }): Promise<Record<string, UserId>>;
    /** @internal */
    getUserIdNames(): readonly string[];
    /** @internal */
    hasUserId(name: string): boolean;
    /** @internal */
    snapshotStatic(): HostContextStaticSnapshot;
    /**
     * Subscribe to static-value changes. Called immediately with the current snapshot, then after
     * each mutating `set()`. Returns an unsubscribe function.
     * @internal
     */
    subscribeStatic(listener: (snapshot: HostContextStaticSnapshot) => void): () => void;
}

export declare enum KnownMarkerName {
    PREROLL = "preroll",
    MIDROLL = "midroll",
    POSTROLL = "postroll",
    FIRST_QUARTILE = "contentFirstQuartile",
    MIDPOINT = "contentMidpoint",
    THIRD_QUARTILE = "contentThirdQuartile",
    COMPLETE = "contentComplete",
    STILL_INTERESTING = "stillInteresting",
    REQUEST_RECOMMENDATIONS = "requestRecommendations"
}

declare interface LdJsonAdapter {
    getEmbedUrl?: (content: MediaItemResolved) => string | undefined;
    getProvider?: (content: MediaItemResolved) => LdJsonOrganization | undefined;
}

declare interface LdJsonOrganization {
    '@type': 'Organization';
    name: string;
    logo?: {
        '@type': 'ImageObject';
        url: string;
        width?: number;
        height?: number;
    };
}

export declare function loadComponent(tagName: string, url: string): void;

export declare function loadStyles(integrationId: string, url?: string, doc?: Document | ShadowRoot): void;

/**
 * Known markers that the integration interprets.
 */
export declare interface Marker {
    /** Name of the marker */
    name: KnownMarkerName;
    /** Type of the marker */
    type: MarkerType;
    /**
     * Threshold for the marker:
     * - {@link MarkerType.TIME_IN_SECONDS}: seconds (use negative values to calculate position from end of content, e.g., -10 means 10 seconds before the end; only valid for VoD content)
     * - {@link MarkerType.PERCENT}: percent as fraction (0-1)
     * - {@link MarkerType.TIME_IN_SECONDS_RECURRING}: seconds
     */
    threshold: number;
    /** Whether the marker should reference watch time instead of current time. Livestreams always use watch time. */
    useWatchTime?: boolean;
}

export declare enum MarkerType {
    /** Triggers by time in seconds */
    TIME_IN_SECONDS = "time",
    /** Triggers by percentage (only works when media item has a {@link MediaItem#duration duration}) */
    PERCENT = "percent",
    /** Recurringly triggers by time in seconds (e.g. every 60 seconds) */
    TIME_IN_SECONDS_RECURRING = "timeRecurring"
}

/**
 * Represents the input description of a media asset for the player.
 *
 * A minimal playable `MediaItem` requires only a source — every other field is optional.
 * Additional fields can be supplied to support analytics, monetization, UI enhancements, and other use cases.
 * In general, the richer the metadata, the more likely the `MediaItem` can satisfy all integration requirements.
 *
 * Alternatively, a {@link MediaItemReference} can be passed to the player instead of a
 * full `MediaItem`. A reference carries only an `id` and a `provider`, letting the player
 * resolve the complete media item from that provider by ID.
 *
 * When the player processes a `MediaItem` (or a resolved {@link MediaItemReference}) it
 * produces a {@link MediaItemResolved} — an expanded version where missing fields are
 * filled with defaults (e.g. `id`, `language`, `aspectRatio`) and additional data is
 * derived automatically.
 */
export declare interface MediaItem {
    /**
     * Unique identifier of the media item.
     */
    id?: string;
    /**
     * Additional ids that identify the media item in other systems
     */
    additionalIds?: {
        originId?: string;
        externalId?: string;
    };
    /**
     * Poster image of the media item.
     */
    poster?: string;
    /**
     * Sources of the media item.
     */
    sources?: Partial<SourceMediaItem>[];
    /**
     * Array of text tracks for subtitles, captions, etc.
     * These tracks apply to the whole media item, not to individual sources.
     *
     * Note: This is only useful for progressive sources or when the adaptive stream
     * (HLS/DASH) does not deliver the text tracks / subtitles within the manifest.
     */
    textTracks?: MediaItemTextTrack[];
    /**
     * Title of the media item.
     */
    title?: string;
    /**
     * Duration of the media item in seconds. Not defined when livestream.
     */
    duration?: number;
    /**
     * Position (in seconds) at which playback should resume.
     * Applied automatically when the media item is loaded.
     */
    resumePosition?: number;
    /**
     * Description of the media item.
     */
    description?: string;
    /**
     * Language of the media item. 2-letter ISO language code.
     *
     * @defaultValue `de` (German)
     */
    language?: string;
    /**
     * IAB categories (as {@link iabCategoryTaxonomy}) of the media item. Used for monetization.
     */
    iabCategories?: string[];
    /**
     * IAB category taxonomy used for {@link iabCategories} ({@link https://github.com/InteractiveAdvertisingBureau/AdCOM/blob/main/AdCOM%20v1.0%20FINAL.md#list_categorytaxonomies see IAB spec for details})
     * @defaultValue `9` for IAB Tech Lab Content Taxonomy 3.1
     */
    iabCategoryTaxonomy?: number;
    /**
     * Aspect ratio of the media item. Useful when vertical variants are used.
     *
     * @defaultValue `16:9`
     */
    aspectRatio?: string;
    /**
     * Minimum age to watch the media item. Shows a minimum age indicator in the UI.
     *
     * @defaultValue `0` (no minimum age)
     */
    minimumAge?: number;
    /**
     * Release date of the media item. Unix timestamp in milliseconds.
     * Useful for JSON-LD generation.
     */
    releaseDate?: number;
    /**
     * Original TV air date of the media item. Unix timestamp in milliseconds.
     * Used for analytics (e.g. Comscore dateOfTVAiring).
     */
    tvAirDate?: number;
    /**
     * Time when the media item expires. Unix timestamp in milliseconds.
     * Useful for JSON-LD generation.
     */
    endDate?: number;
    /**
     * Whether the media item has product placements. Shows a product placement indicator in the UI.
     */
    hasProductPlacement?: boolean;
    /**
     * Channel (or often referred to as brand) of the media item.
     */
    channel?: Channel;
    /**
     * Markers control ad breaks and custom time-based events during playback.
     *
     * **⚠️ Important:** When providing custom markers, the default PREROLL is **not** added automatically.
     * You must explicitly include a PREROLL marker if you want ads to play.
     *
     * **Reserved marker names:** Only `PREROLL`, `MIDROLL`, and `POSTROLL` from {@link KnownMarkerName}
     * can be used for ad markers. All other `KnownMarkerName` values are reserved for internal use.
     * Use custom string names (e.g., `'halfwayPoint'`) for your own markers.
     *
     * **Listening for custom markers:** When a custom marker is reached, the player dispatches
     * an {@link IntegrationEvent.CONTENT_MARKER_REACHED} event. Listen for this event to react
     * to your custom markers:
     *
     * ```js
     * player.addEventListener('contentmarkerreached', (event) => {
     *   const { markerName, markerData } = event.detail;
     *   if (markerName === 'showEndCreditsOverlay') {
     *     // Show your overlay
     *   }
     * });
     * ```
     *
     * @example
     * // Default: pre-roll ads only (same as omitting markers)
     * markers: [{ name: KnownMarkerName.PREROLL, type: MarkerType.TIME_IN_SECONDS, threshold: 0 }]
     *
     * @example
     * // Pre-roll + mid-roll at 60 seconds
     * markers: [
     *   { name: KnownMarkerName.PREROLL, type: MarkerType.TIME_IN_SECONDS, threshold: 0 },
     *   { name: KnownMarkerName.MIDROLL, type: MarkerType.TIME_IN_SECONDS, threshold: 60 }
     * ]
     *
     * @example
     * // Custom marker at 50% of content
     * markers: [
     *   { name: KnownMarkerName.PREROLL, type: MarkerType.TIME_IN_SECONDS, threshold: 0 },
     *   { name: 'halfwayPoint', type: MarkerType.PERCENT, threshold: 0.5 }
     * ]
     *
     * @example
     * // Custom marker 15 seconds before end (e.g., for end credits overlay)
     * markers: [
     *   { name: KnownMarkerName.PREROLL, type: MarkerType.TIME_IN_SECONDS, threshold: 0 },
     *   { name: 'showEndCreditsOverlay', type: MarkerType.TIME_IN_SECONDS, threshold: -15 }
     * ]
     *
     * @defaultValue `[{ name: KnownMarkerName.PREROLL, type: MarkerType.TIME_IN_SECONDS, threshold: 0 }]`
     */
    markers?: (Marker | CustomMarker)[];
    /**
     * In which country can this media item be played (e.g. `['de', 'at']`)? Useful for
     * JSON-LD generation.
     *
     * @defaultValue `['all']` (worldwide)
     */
    regionsAllowed?: string[];
    /**
     * Mark this media item as a recommendation.
     */
    isRecommendation?: boolean;
    /**
     * JSON-LD `contentUrl` that allows search engines to crawl the media source.
     * You should only allow known crawlers ({@link https://developers.google.com/search/docs/crawling-indexing/verifying-googlebot?hl=en how to verify Googlebot & Crawler})
     * to access those media sources.
     */
    seoContentUrl?: string;
    /**
     * Additional teaser options that improve the loading experience and enable additional
     * integration variants.
     */
    teaser?: {
        /** Image of the first frame of the media item. Used for initially showing the first frame of the media item. */
        firstFrame?: string;
        /** {@link https://blurha.sh/ Blurhash} of the first frame of the media item. Used for coloring the background. */
        firstFrameBlurHash?: string | null;
        /** Blurred version of the first frame of the media item. Used to show something early while loading. */
        firstFrameBlurred?: string;
        /** {@link https://blurha.sh/ Blurhash} of the poster of the media item. Used for coloring the background. */
        posterBlurHash?: string | null;
        /** Blurred version of the poster of the media item. Used to show something early while loading. */
        posterBlurred?: string;
        /** Teaser video URL which is used for previewing the media item for some integrations. */
        video?: string;
    };
    /**
     * Additional labels for this media item.
     */
    labels?: {
        id: string;
        name: string;
    }[];
    /** Genre of the media item (e.g. `Documentary`) */
    genre?: string;
    /**
     * Editorial program type of the media item describing what kind of content it is.
     *
     * @example ProgramType.MOVIE
     * @example ProgramType.SERIES
     */
    programType?: ProgramType | `${ProgramType}`;
    /** Content owner id and name of the media item */
    contentOwner?: {
        id?: string;
        name: string;
    };
    /**
     * Additional details to show for the age rating (e.g. `['Alcohol']`) next to the minimum age.
     */
    ageRatingDetails?: string[];
    /** Keywords of the media item */
    keywords?: string[];
    /** Logo of the media item in size 220x90 (e.g. for shows, movies, sports events etc.) */
    logo?: string;
    /** Alt text for the logo of the media item */
    logoAltText?: string;
    /** Accent color of the media item that is shown behind the logo */
    logoAccentColor?: string;
    /** Show (often referred to as series, format or tv-show) the media item belongs to */
    show?: {
        id?: string;
        name: string;
        episodeNumber?: number;
        seasonNumber?: number;
    };
    /** Competition the media item belongs to */
    competition?: {
        id?: string;
        name?: string;
    };
    /** Compilation the media item belongs to */
    compilation?: {
        id?: string;
        name?: string;
    };
    /** The live on demand channel (livestream using a VoD playlist, often called ODC) the media item belongs to */
    liveOnDemandChannel?: {
        id?: string;
        name?: string;
    };
    /** Category id and name of the media item */
    category?: {
        id?: string;
        name: string;
    };
    /** Error information if the media item is not available upfront. */
    error?: MediaItemError;
    /**
     * Internal definition of experiments.
     * @ignore
     */
    experiments?: Experiment[];
    /**
     * Additional content branding
     */
    branding?: {
        /** @ignore */
        backgroundColor?: string;
        /** @ignore */
        cutInZoomAssetUrl?: string;
        /** @ignore */
        cutInZoomHideTimeout?: number;
        /** Logo that should appear in the corner */
        logoUrl?: string;
        /** Optional link target for the logo */
        logoLinkUrl?: string;
    };
    /** Livestream details */
    livestream?: {
        /** UTC start time of the event livestream in milliseconds. Must not be passed for 24/7 livestreams. */
        startTime: number;
        /** UTC end time of the event livestream in milliseconds. Must not be passed for 24/7 livestreams. */
        endTime?: number;
        /** EPG entries containing UTC start and end times in milliseconds. Can be used for timeshift functionality (e.g., jump markers within the DVR window).*/
        epgEntries?: {
            /** UTC start time of the livestream program in milliseconds */
            startDate: number;
            /** UTC end time of the livestream program in milliseconds */
            endDate: number;
            /** Show (series, format or program) name */
            name: string;
            /** Title of the livestream program */
            title?: string;
            /** Poster image URL of the livestream program */
            poster?: string;
        }[];
    };
    /**
     * An additional API script definition that should be executed for this media-item.
     * @ignore
     */
    apiScript?: ApiScript;
    /**
     * Indicates the source from which additional metadata was derived (e.g., "my-source").
     */
    metadataSource?: string;
    /**
     * Name of actors appearing in the given media item
     *
     * @example ["Cate Blanchett", "Leonardo DiCaprio"]
     */
    actors?: string[];
    /**
     * Links to related content (e.g., a news article or blog post).
     */
    links?: {
        type: 'article';
        url: string;
        caption: string;
    }[];
    /**
     * Tracking metadata for third-party analytics providers.
     */
    tracking?: {
        /** Nielsen Digital Analytics (Germany) key/value pairs. */
        nielsenDe?: Record<string, string>;
    };
    /**
     * Per-resolution recommendations cursor. The value can be either a single
     * video id or a playlist id, both fed back into `resolve(...)` to obtain
     * the next set of items. Replaces the provider's stateful `nextPlaylistId`.
     * @ignore
     */
    nextId?: string;
}

/**
 * Abstract definition of a media item web component that can be used as a child of the {@link IntegrationElement}.
 *
 * @example of a custom media item
 *
 * It is possible to create more complex media items that query an own API.
 *
 * ```html
 * <script>
 *   class CustomMediaItemElement extends HTMLElement {
 *     get data() {
 *       return fetch(`https://api.example.com/media/${this.id}`)
 *       .then(response => response.json())
 *       .then((body) => ({
 *         id: this.id,
 *         provider: 'external',
 *         item: {
 *           id: this.id,
 *           sources: body.sources,
 *           duration: body.duration,
 *           poster: body.poster,
 *           title: body.title
 *         }
 *       }));
 *     }
 *   }
 *   window.customElements.define('custom-media-item', CustomMediaItemElement);
 * </script>
 * <my-integration
 *   integration-id="YOUR_INTEGRATION_ID"
 * >
 *   <custom-media-item id="API_CONTENT_ID"></custom-media-item>
 * </my-integration>
 * ```
 *
 * @example of a custom media item that returns multiple items
 *
 * The `data` getter can also return an array of {@link MediaItemReference} objects
 * to define a playlist from a single element.
 *
 * ```html
 * <script>
 *   class CustomPlaylistElement extends HTMLElement {
 *     get data() {
 *       return fetch(`https://api.example.com/playlist/${this.id}`)
 *       .then(response => response.json())
 *       .then((body) => body.items.map((item) => ({
 *         id: item.id,
 *         provider: 'external',
 *         item: {
 *           id: item.id,
 *           sources: item.sources,
 *           duration: item.duration,
 *           poster: item.poster,
 *           title: item.title
 *         }
 *       })));
 *     }
 *   }
 *   window.customElements.define('custom-playlist', CustomPlaylistElement);
 * </script>
 * <my-integration
 *   integration-id="YOUR_INTEGRATION_ID"
 * >
 *   <custom-playlist id="API_PLAYLIST_ID"></custom-playlist>
 * </my-integration>
 * ```
 */
export declare abstract class MediaItemElement extends HTMLElement {
    /**
     * The content ID used by the provider to look up the media item.
     * @attribute id
     */
    id: string;
    /**
     * The environment to use for the provider.
     * @attribute {stage|prod} environment
     * @defaultValue 'prod'
     */
    environment?: 'stage' | 'prod';
    /** @internal */
    static get observedAttributes(): string[];
    /** @internal */
    attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
    /**
     * Parses inline JSON from a child `<script>` element with the appropriate media item type.
     * @internal
     */
    protected parseInlineMediaItem(): MediaItemReference[] | Partial<MediaItem>[] | MediaItemReference | Partial<MediaItem> | undefined;
    abstract get data(): MediaItemReference | MediaItemReference[] | Promise<MediaItemReference | MediaItemReference[]>;
}

/**
 * Error known before the media item gets loaded.
 */
export declare class MediaItemError extends BaseMediaError<MediaItemErrorCode> {
    name: string;
}

export declare enum MediaItemErrorCode {
    NOT_FOUND = "NotFound",
    NOT_AVAILABLE = "NotAvailable",
    GEOBLOCKED = "Geoblocked",
    YOUTH_PROTECTED = "YouthProtected",
    TERMINATED = "Terminated",
    EXPIRED = "Expired",
    LOGIN_REQUIRED = "LoginRequired",
    HIGHER_TIER_ACCOUNT_REQUIRED = "HigherTierAccountRequired",
    VPN_DETECTED = "VpnDetected",
    AGE_VERIFICATION_REQUIRED = "AgeVerificationRequired",
    PIN_REQUIRED = "PinRequired",
    INVALID_PIN = "InvalidPin",
    GENERIC = "Generic"
}

/**
 * Describes how to fetch a media item from a given provider.
 *
 * The provider resolves the media item by its {@link id}. When an {@link item}
 * is supplied, its handling is provider-specific: a provider may merge its fields
 * into resolved metadata, or use it directly and skip metadata resolution.
 */
export declare interface MediaItemReference {
    /** Media item ID used by the provider to look up the content. */
    id: string;
    /** Provider that is responsible for resolving this media item. */
    provider: string;
    /**
     * Target environment for the provider request.
     * @defaultValue 'prod'
     */
    environment?: 'stage' | 'prod';
    /**
     * Optional partial media item whose properties are merged on top of the
     * data returned by the provider, allowing individual fields to be overridden.
     *
     * **Required** when the provider is `external`, since there is no remote
     * source to fetch the media item from.
     */
    item?: MediaItem;
    /** Whether to observe stream termination independent of business model. */
    forceObserveTermination?: boolean;
}

/**
 * Represents a {@link MediaItem} after it has been resolved by the player.
 *
 * When a {@link MediaItem} is passed to the player, it is expanded into a
 * `MediaItemResolved`: fields that were omitted receive sensible defaults
 * (e.g. `id`, `language`, `aspectRatio`), and additional fields such as
 * `originalId`, `provider`, and `ppsj` are derived automatically.
 *
 * As a result, several properties that are optional on {@link MediaItem}
 * become required here.
 */
export declare interface MediaItemResolved extends Omit<MediaItem, 'id' | 'sources' | 'title' | 'regionsAllowed' | 'aspectRatio' | 'minimumAge' | 'iabCategoryTaxonomy' | 'language'> {
    id: NonNullable<MediaItem['id']>;
    sources: ((SourceMediaItem & {
        id: string;
        mimetype: Mimetype;
    }) | SourceMediaItemWithToken)[];
    title: NonNullable<MediaItem['title']>;
    regionsAllowed: NonNullable<MediaItem['regionsAllowed']>;
    /**
     * An internal marker for the used playlist. It is automatically filled.
     * @ignore
     */
    playlistId: string;
    aspectRatio: NonNullable<MediaItem['aspectRatio']>;
    minimumAge: NonNullable<MediaItem['minimumAge']>;
    iabCategoryTaxonomy: NonNullable<MediaItem['iabCategoryTaxonomy']>;
    language: NonNullable<MediaItem['language']>;
    /**
     * Mark this media item to allow teaser experiments.
     * @ignore
     */
    allowTeaserExperiments: boolean;
    /**
     * Will be automatically filled based on {@link MediaItem#minimumAge} and {@link MediaItem#iabCategories}.
     * @ignore
     */
    ppsj?: string;
    /**
     * Indicates the provider of the media item.
     */
    provider: string;
    /**
     * The original {@link MediaItemReference} that produced this resolved item.
     * Preserved so that re-resolution (e.g. playlist-item updates) can pass it
     * back to the provider.
     *
     * @ignore
     */
    _referenceItem?: MediaItemReference;
}

/**
 * Text track definition for a media item.
 * Based on {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLTrackElement | HTMLTrackElement}.
 */
export declare interface MediaItemTextTrack {
    /**
     * Unique identifier for the track.
     */
    id?: string;
    /**
     * The kind of text track.
     */
    kind: 'subtitles' | 'captions' | 'descriptions' | 'chapters' | 'metadata';
    /**
     * URL of the track file (e.g., WebVTT file).
     */
    src: string;
    /**
     * Language of the track text data (BCP 47 language tag).
     */
    srclang: string;
    /**
     * Human-readable title of the track.
     */
    label: string;
    /**
     * Whether the track should be enabled by default.
     */
    default?: boolean;
}

/**
 * Network error when a request fails due to connectivity issues.
 * Shaka Player network errors have codes in the 1000-1999 range
 * while HTMLMediaElement errors with 2 and 4 are considered network errors.
 */
export declare class MediaNetworkError extends BaseMediaError {
    name: string;
}

/**
 * Error after loading the media item.
 */
export declare class MediaPlaybackError extends BaseMediaError {
    name: string;
}

/** Context returned by a media-provider resolver. `token` is required; any extra fields are allowed. */
export declare interface MediaProviderContext {
    token: string;
    [key: string]: unknown;
}

/**
 * Error while fetching metadata of the media item.
 */
export declare class MediaProviderError extends BaseMediaError<MediaProviderErrorCode> {
    name: string;
}

export declare enum MediaProviderErrorCode {
    NOT_FOUND = "NotFound",
    FORBIDDEN = "Forbidden",
    HIDDEN = "Hidden",
    NO_CONTENT = "NoContent",
    GENERIC = "Generic"
}

/** Data available at setup() time — integration identity and environment ready. */
declare interface MediaProviderParams {
    page: Page;
    article: EnvironmentState['article'];
    device: EnvironmentState['device'];
    network: {
        userCountryCode: string;
    };
    integration: {
        id: string;
        version: string;
        sessionId: string;
        environment: 'prod' | 'stage';
        positionInArticle: PositionInArticle;
        origin: string;
        externalSchain?: string;
        randomSlot?: number;
        placement?: string;
        placementDetail?: Record<string, unknown> & {
            name?: string;
        };
        hostContext?: HostContextStaticSnapshot;
        adPlayerType?: string;
    };
    config: {
        developmentFlags?: DevelopmentFlags;
    };
}

declare class MediaResolver {
    #private;
    constructor(window: Window, { integrationElement, hostContext }: {
        integrationElement: Element;
        hostContext: InternalHostContext;
    });
    setParams(params: MediaProviderParams): void;
    register(name: string, loader: ProviderModuleLoader): void;
    resolve(items: MediaItemReference[], signal: AbortSignal, options?: {
        timeoutMs?: number;
    }): Promise<MediaItemResolved[]>;
    getSources: (mediaItem: MediaItemResolved, signal: AbortSignal, onTerminated: Parameters<IBaseMediaProvider['getSources']>[2], context: Parameters<IBaseMediaProvider['getSources']>[3]) => Promise<SourceNormalized[]>;
    /**
     * A {@link ContextConfig} produced by any provider during the latest {@link resolve}.
     *
     * When multiple providers set `context`, the returned value depends on provider
     * registration order.
     */
    getResolvedContext(): ContextConfig | undefined;
    createShakaConfigurator(providerName: string): Promise<BaseShakaConfigurator>;
    getRecommendations(mediaItem: MediaItemResolved, signal: AbortSignal): Promise<{
        additionalIds?: {
            originId?: string;
            externalId?: string;
        };
        poster?: string;
        textTracks?: MediaItemTextTrack[];
        duration?: number;
        resumePosition?: number;
        description?: string;
        iabCategories?: string[];
        releaseDate?: number;
        tvAirDate?: number;
        endDate?: number;
        hasProductPlacement?: boolean;
        channel?: Channel;
        isRecommendation?: boolean;
        seoContentUrl?: string;
        teaser?: {
            firstFrame?: string;
            firstFrameBlurHash?: string | null;
            firstFrameBlurred?: string;
            posterBlurHash?: string | null;
            posterBlurred?: string;
            video?: string;
        };
        labels?: {
            id: string;
            name: string;
        }[];
        genre?: string;
        programType?: ProgramType | `${ProgramType}`;
        contentOwner?: {
            id?: string;
            name: string;
        };
        ageRatingDetails?: string[];
        keywords?: string[];
        logo?: string;
        logoAltText?: string;
        logoAccentColor?: string;
        show?: {
            id?: string;
            name: string;
            episodeNumber?: number;
            seasonNumber?: number;
        };
        competition?: {
            id?: string;
            name?: string;
        };
        compilation?: {
            id?: string;
            name?: string;
        };
        liveOnDemandChannel?: {
            id?: string;
            name?: string;
        };
        category?: {
            id?: string;
            name: string;
        };
        error?: MediaItemError;
        experiments?: Experiment[];
        branding?: {
            backgroundColor?: string;
            cutInZoomAssetUrl?: string;
            cutInZoomHideTimeout?: number;
            logoUrl?: string;
            logoLinkUrl?: string;
        };
        livestream?: {
            startTime: number;
            endTime?: number;
            epgEntries?: {
                startDate: number;
                endDate: number;
                name: string;
                title?: string;
                poster?: string;
            }[];
        };
        apiScript?: ApiScript;
        metadataSource?: string;
        actors?: string[];
        links?: {
            type: 'article';
            url: string;
            caption: string;
        }[];
        tracking?: {
            nielsenDe?: Record<string, string>;
        };
        nextId?: string;
        regionsAllowed: string[];
        playlistId: string;
        aspectRatio: string;
        minimumAge: number;
        iabCategoryTaxonomy: number;
        language: string;
        markers: {
            name: KnownMarkerName;
            type: MarkerType;
            threshold: number;
        }[] | (CustomMarker | Marker)[];
        allowTeaserExperiments: boolean;
        id: string;
        title: string;
        provider: string;
        sources: (SourceMediaItem & {
            id: string;
            mimetype: Mimetype;
        })[];
        ppsj: string;
        _referenceItem?: MediaItemReference | undefined;
    }[]>;
}

/**
 * Base interface for all media track types.
 * Provides common properties shared by audio, video, and text tracks.
 */
declare interface MediaTrack {
    /** Unique identifier for the track. */
    id: string;
    /** The type or category of the track. */
    kind: string;
    /** Human-readable label for the track. */
    label: string;
    /** BCP 47 language tag (e.g., "en", "de", "es"). */
    language: string;
}

/**
 * Base interface for track list collections.
 * Extends EventTarget to support track change events and is iterable.
 *
 * @typeParam T - The specific track type this list contains.
 */
declare interface MediaTrackList<T extends MediaTrack> extends EventTarget, Iterable<T> {
    /** The number of tracks in the list. */
    readonly length: number;
    /**
     * Returns the track with the specified ID.
     * @param id - The track ID to search for.
     * @returns The matching track, or `null` if not found.
     */
    getTrackById(id: string): T | null;
    /**
     * Adds an event listener for track list changes.
     * @param type - The event type: `'trackschange'` (track list changed) or `'change'` (selection changed).
     * @param listener - The callback function.
     * @param options - Optional event listener options.
     */
    addEventListener(type: 'trackschange' | 'change', listener: EventListener, options?: boolean | AddEventListenerOptions): void;
}

export declare enum Mimetype {
    HLS = "application/vnd.apple.mpegurl",
    HLS_LEGACY = "application/x-mpegURL",
    DASH = "application/dash+xml",
    MP4 = "video/mp4",
    OGG = "video/ogg",
    WEBM = "video/webm",
    MP3 = "audio/mp3",
    AAC = "audio/aac",
    WAV = "audio/wav",
    OGG_AUDIO = "audio/ogg",
    MPEG_AUDIO = "audio/mpeg",
    /** Used for sources backed by a {@link DynamicContent} ES module. */
    DYNAMIC_CONTENT = "application/x-turbo-dynamic-content",
    /** Deprecated. Use `application/x-joyn-source` instead. */
    JOYN = "application/x-joyn-source"
}

declare interface MonetizationAdapter {
    /**
     * Called on every consent/config change. May be called multiple times. Use this to load external
     * dependencies such as prebid.js or bid-system configuration. Return early if
     * `params.monetization.enabled` is false.
     */
    setup?(params: MonetizationParams): Promise<void>;
    /**
     * Called once per ad break. Run your auction here and return the pod to
     * play, or null to suppress the break entirely.
     */
    getVastPod?(params: MonetizationAdRequestParams, signal: AbortSignal): Promise<VastPod | null>;
}

/** Data available at getVastPod() time — extends MonetizationParams with per-break context. */
declare interface MonetizationAdRequestParams extends MonetizationParams {
    user: {
        ids: UserState['ids'];
        idsAsEids: UserIdAsEid[];
    };
    content: MediaItemResolved | undefined;
    source: SourceSelected;
    pod: {
        breakName: string;
        breakIndex: number;
        requestTime?: number;
    };
    player: {
        width: number;
        height: number;
        contentStartCount: number;
        playlistIndex: number;
        palSdkNonce?: string;
        audioTrackLanguage?: string;
        muted: boolean;
        volume: number;
        startMethod: StartMethod;
        duration?: number;
        startTime?: number;
        videoQuality?: {
            width: number;
            height: number;
            bitrate: number;
        };
        presentationMode: PresentationMode;
    };
}

/** Data available at setup() time — consent granted, config ready. */
declare interface MonetizationParams extends MediaProviderParams {
    consent: Consent;
    user: {
        ids: {
            ppid?: UserState['ids']['ppid'];
        };
    };
    config: PlayerConfig & {
        ad: PlayerConfig['ad'] & {
            omidPartnerName?: string;
            omidPartnerVersion?: string;
        };
    };
    monetization: {
        enabled: boolean;
    };
}

/**
 * Normalizes a {@link MediaItem} or {@link MediaItemReference} into a
 * {@link MediaItemReference}.
 *
 * @ignore
 *
 * If the input already has a `provider` it is returned as-is.
 * Otherwise the provider is detected from the media item's sources.
 */
export declare function normalizeMediaItem(input: MediaItemReference | MediaItem): MediaItemReference;

/** @internal */
export declare enum Origin {
    DEFAULT = "turbo-integration",
    SCRIPT = "turbo-script",
    IFRAME = "turbo-iframe",
    FULLPAGE = "turbo-fullpage",
    AMP_VIDEO_IFRAME = "turbo-amp-video-iframe",
    AMP_IFRAME = "turbo-amp-iframe"
}

declare type OsType = 'windows' | 'macos' | 'ios' | 'ipados' | 'android' | 'fireos' | 'chromeos' | 'linux' | 'unix' | 'tvos' | 'tizen' | 'webos' | 'roku' | 'playstation' | 'xbox' | 'visionos' | 'harmonyos' | 'kaios' | 'unknown';

declare interface OtherInstance {
    presentationMode: string;
    muted: boolean;
    paused: boolean;
    playlistId?: string;
    integrationId?: string;
}

declare interface OtherIntegrations {
    [key: string]: OtherInstance;
}

/** @interface */
declare type OtherPlayersConfig = typeof OtherPlayersConfigSchema.infer;

/**
 * Other players configuration (how this player interacts with other players on page)
 */
declare const OtherPlayersConfigSchema: ObjectType<    {
pauseOnOtherPlay: boolean;
pauseOnOtherPlayWhenMuted: boolean;
singleDockMode: boolean;
}, {}>;

export declare interface Page {
    url: string;
    searchParams: Record<string, string>;
    utm?: {
        source?: string;
        medium?: string;
        campaign?: string;
        content?: string;
        term?: string;
    };
    apexDomain: string;
    hostname: string;
    pathSegment1?: string;
    pathSegment2?: string;
    pathSegment3?: string;
    referrer: string;
    /** @internal */
    width: number;
    /** @internal */
    height: number;
    /** @internal */
    visibilityState: DocumentVisibilityState;
    /** @internal */
    persisted: boolean;
}

/**
 * Partial ad config
 */
declare const PartialAdConfigSchema: ObjectType<    {
enable?: boolean | undefined;
player?: "ads-sdk" | "ima" | undefined;
palSdk?: boolean | undefined;
autoPauseWhenInvisible?: boolean | undefined;
maxRedirectCount?: number | undefined;
videoLoadTimeout?: number | undefined;
vastLoadTimeout?: number | undefined;
maxDuration?: number | undefined;
bidding?: boolean | undefined;
prebidTimeout?: number | undefined;
apsTimeout?: number | undefined;
intensity?: number | undefined;
imaUi?: boolean | undefined;
customClickButton?: boolean | undefined;
maxWaterfallLength?: number | undefined;
pauseButton?: boolean | undefined;
tagConfig?: string | {
name?: string | undefined;
maxDuration?: number | undefined;
maxFallbackAttempts?: number | undefined;
lineItems: {
id?: string | undefined;
url: string;
externalId?: string | undefined;
errorPixels?: string[] | undefined;
}[];
}[] | {
id?: string | undefined;
url: string;
externalId?: string | undefined;
errorPixels?: string[] | undefined;
} | undefined;
}, {}>;

/**
 * Partial analytics config
 */
declare const PartialAnalyticsConfigSchema: ObjectType<    {
scriptUrl?: string | undefined;
}, {}>;

/**
 * Partial dock config
 */
declare const PartialDockConfigSchema: ObjectType<    {
enable?: boolean | undefined;
position?: "bottom" | "bottomLeft" | "bottomRight" | "left" | "right" | "stickyTop" | "stickyTopExpanded" | "top" | "topLeft" | "topRight" | undefined;
top?: string | undefined;
right?: string | undefined;
bottom?: string | undefined;
left?: string | undefined;
allowAdClose?: boolean | undefined;
snapTop?: string | undefined;
targetSelector?: string | undefined;
}, {}>;

/**
 * Partial early recommendations config
 */
declare const PartialEarlyRecommendationsConfigSchema: ObjectType<    {
enable?: boolean | undefined;
showAfterSeconds?: number | undefined;
minimumContentDurationSeconds?: number | undefined;
buttonCountdownSeconds?: number | undefined;
maximumVisibility?: number | undefined;
}, {}>;

/**
 * Partial other players config
 */
declare const PartialOtherPlayersConfigSchema: ObjectType<    {
pauseOnOtherPlay?: boolean | undefined;
pauseOnOtherPlayWhenMuted?: boolean | undefined;
singleDockMode?: boolean | undefined;
}, {}>;

/**
 * Partial playback config
 */
declare const PartialPlaybackConfigSchema: ObjectType<    {
startBehavior?: "click-to-play" | "scroll-out-to-play" | "scroll-out-to-play-when-ad" | "scroll-to-play" | "scroll-to-play-when-ad" | "scroll-to-play-with-out-to-play-fallback" | "scroll-to-play-with-silent-fallback" | "silent-scroll-to-play" | "silent-scroll-to-play-when-ad" | undefined;
autoplayVolume?: number | undefined;
anyClickUnmute?: boolean | undefined;
playOnVisibility?: number | undefined;
noConsentNoAutoplay?: boolean | undefined;
initialPlaybackRate?: number | undefined;
initialAutoplayPlaybackRate?: number | undefined;
restoreMediaPreferences?: boolean | undefined;
preload?: "auto" | "metadata" | "none" | undefined;
}, {}>;

/**
 * Partial playlist config
 */
declare const PartialPlaylistConfigSchema: ObjectType<    {
revolverPlay?: boolean | undefined;
revolverPlayCountdown?: number | undefined;
revolverPlayAutoplayCountdown?: number | undefined;
endscreen?: "continue" | "none" | undefined;
endBehavior?: "loop" | "stop" | undefined;
contentFrequencyCapping?: boolean | undefined;
recommendations?: boolean | undefined;
}, {}>;

/**
 * Partial privacy config
 */
declare const PartialPrivacyConfigSchema: ObjectType<    {
loadThirdPartyOnlyIfConsent?: boolean | undefined;
}, {}>;

/**
 * Partial SEO config
 */
declare const PartialSeoConfigSchema: ObjectType<    {
addJsonLd?: boolean | undefined;
}, {}>;

/**
 * Partial UI config
 */
declare const PartialUiConfigSchema: ObjectType<    {
enable?: boolean | undefined;
title?: boolean | undefined;
contentBranding?: boolean | undefined;
contentOwnerLogo?: boolean | undefined;
nextVideoButton?: boolean | undefined;
epgButton?: boolean | undefined;
upsellButton?: boolean | undefined;
premiumProductName?: string | undefined;
useInitialTeaserComposition?: boolean | undefined;
contentComposition?: string | undefined;
tapToUnmute?: boolean | undefined;
globalKeyboardEvents?: boolean | undefined;
}, {}>;

export declare enum PassbackReason {
    UNKNOWN = "unknown",
    DISABLED = "disabled",
    ABORTED = "aborted",
    AD_LOAD_ERROR = "ad-load-error",
    MISCONFIGURED = "misconfigured",
    AUTOPLAY_BLOCKED = "autoplay-blocked"
}

/** @interface */
declare type PlaybackConfig = typeof PlaybackConfigSchema.infer;

/**
 * Playback configuration
 */
declare const PlaybackConfigSchema: ObjectType<    {
startBehavior: "click-to-play" | "scroll-out-to-play" | "scroll-out-to-play-when-ad" | "scroll-to-play" | "scroll-to-play-when-ad" | "scroll-to-play-with-out-to-play-fallback" | "scroll-to-play-with-silent-fallback" | "silent-scroll-to-play" | "silent-scroll-to-play-when-ad";
autoplayVolume?: number | undefined;
anyClickUnmute: boolean;
playOnVisibility: number;
noConsentNoAutoplay: boolean;
initialPlaybackRate: number;
initialAutoplayPlaybackRate: number;
restoreMediaPreferences: boolean;
preload: "auto" | "metadata" | "none";
}, {}>;

export declare enum PlaybackMode {
    LIVE = "live",
    VOD = "vod",
    INTERACTIVE = "interactive",
    EMBED = "embed"
}

/**
 * CSS selector that matches inline-config `<script>` tags in any of the three
 * supported MIME types ({@link ScriptType.PLAYER_CONFIG} and the two legacy
 * variants). Centralized so reader call-sites stay in sync.
 *
 * @internal
 */
export declare const PLAYER_CONFIG_SCRIPT_SELECTOR: string;

/** Fully resolved player configuration — all fields required. */
export declare interface PlayerConfig {
    id?: string;
    dock: DockConfig;
    playlist: PlaylistConfig;
    playback: PlaybackConfig;
    otherPlayers: OtherPlayersConfig;
    earlyRecommendations: EarlyRecommendationsConfig;
    privacy: PrivacyConfig;
    analytics: AnalyticsConfig;
    seo: SeoConfig;
    ui: UiConfig;
    ad: AdConfig;
    variant?: VariantSettings;
    experiments?: Record<string, string>;
    context?: ContextConfig;
    developmentFlags?: DevelopmentFlags;
}

/** Input config shape — all fields optional. Accepted as inline config and from a remote config service. */
export declare interface PlayerConfigInput {
    id?: string;
    dock?: typeof PartialDockConfigSchema.infer;
    playlist?: typeof PartialPlaylistConfigSchema.infer;
    playback?: typeof PartialPlaybackConfigSchema.infer;
    otherPlayers?: typeof PartialOtherPlayersConfigSchema.infer;
    earlyRecommendations?: typeof PartialEarlyRecommendationsConfigSchema.infer;
    privacy?: typeof PartialPrivacyConfigSchema.infer;
    analytics?: typeof PartialAnalyticsConfigSchema.infer;
    seo?: typeof PartialSeoConfigSchema.infer;
    ui?: typeof PartialUiConfigSchema.infer;
    ad?: typeof PartialAdConfigSchema.infer;
    variant?: VariantSettings;
    experiments?: Record<string, string>;
    context?: ContextConfig;
    developmentFlags?: DevelopmentFlags;
}

/** @interface */
declare type PlaylistConfig = typeof PlaylistConfigSchema.infer;

/**
 * Playlist configuration
 */
declare const PlaylistConfigSchema: ObjectType<    {
revolverPlay: boolean;
revolverPlayCountdown: number;
revolverPlayAutoplayCountdown: number;
endscreen: "continue" | "none";
endBehavior: "loop" | "stop";
contentFrequencyCapping: boolean;
recommendations: boolean;
}, {}>;

export declare enum PlaylistEndBehavior {
    LOOP = "loop",
    STOP = "stop"
}

/** The position of the player within the article. */
export declare type PositionInArticle = 'unknown' | 'invalid' | 'uppertop' | 'lowertop' | 'other';

export declare enum PresentationMode {
    HIDDEN = "hidden",
    INLINE = "inline",
    DOCK = "dock",
    LIGHTBOX = "lightbox",
    LIGHTBOX_EXTERNAL = "lightbox-external",
    FULLSCREEN = "fullscreen",
    AMP_DOCK = "amp-dock"
}

/** @interface */
declare type PrivacyConfig = typeof PrivacyConfigSchema.infer;

/**
 * Privacy configuration
 */
declare const PrivacyConfigSchema: ObjectType<    {
loadThirdPartyOnlyIfConsent: boolean;
}, {}>;

/**
 * Editorial classification of the media item describing what type of program it is.
 */
export declare enum ProgramType {
    COMPILATION = "compilation",
    CLIP = "clip",
    INTERACTIVE = "interactive",
    LIVE_ON_DEMAND = "live-on-demand",
    LIVE = "live",
    MOVIE = "movie",
    SERIES = "series",
    SPORTS_MATCH = "sports-match",
    TRAILER = "trailer"
}

declare type ProviderClass = new (window: Window, init: {
    hostContext: InternalHostContext;
    integrationElement: Element;
}) => IBaseMediaProvider;

declare interface ProviderModule {
    Provider: ProviderClass;
    ShakaConfigurator?: ShakaConfiguratorClass;
}

declare type ProviderModuleLoader = () => ProviderModule | Promise<ProviderModule>;

/**
 * The union of source shapes that a media provider's `getSources()` may return.
 * Fed into `normalizeDrmSources` which produces {@link SourceNormalized}[].
 *
 * Requires `id`, `src` and `mimetype` because by the time sources reach
 * normalization they have already been enriched by `#enhanceMediaItems`
 * (which generates an `id` and detects the `mimetype` from the URL).
 */
declare type ProviderSourceOutput = (SourceMediaItemBase & Required<Pick<SourceMediaItemBase, 'id' | 'mimetype'>>) | (SourceMediaItemDrm & Required<Pick<SourceMediaItemBase, 'id' | 'mimetype'>>) | SourceNormalized;

declare type RuntimeEnvironment = 'web' | 'cast' | 'mobile-web' | 'native';

export declare enum ScriptType {
    /**
     * MIME type for the inline `<script>` tag that carries a
     * player config payload alongside `<my-integration>`.
     */
    PLAYER_CONFIG = "application/player-config+json",
    /** @deprecated Use {@link ScriptType.PLAYER_CONFIG} instead. */
    PLAYER_CONFIG_LEGACY_V2 = "application/integration-configs+json",
    /** @deprecated Use {@link ScriptType.PLAYER_CONFIG} instead. */
    PLAYER_CONFIG_LEGACY_V1 = "application/glomex-integration-configs+json",
    EXTERNAL_MEDIA_ITEM = "application/external-media-item+json",
    /** @deprecated Use {@link ScriptType.EXTERNAL_MEDIA_ITEM} instead. */
    EXTERNAL_MEDIA_ITEM_LEGACY = "application/glomex-external-media-item+json"
}

/**
 * Represents the seekable range of the media.
 * For VoD content, this typically represents the full duration (0 to duration).
 * For live streams, this represents the DVR window that can be seeked to.
 */
export declare interface SeekRange {
    /** The start time of the seekable range in seconds, or undefined if not yet available */
    start?: number;
    /** The end time of the seekable range in seconds, or undefined if not yet available */
    end?: number;
}

/** @interface */
declare type SeoConfig = typeof SeoConfigSchema.infer;

/**
 * SEO configuration
 */
declare const SeoConfigSchema: ObjectType<    {
addJsonLd: boolean;
}, {}>;

/**
 * Provider-specific Shaka configuration.
 *
 * Registered via the media provider module loader and called
 * by the video element during Shaka source setup.
 *
 * Extend {@link BaseShakaConfigurator} to inherit the base defaults
 * (retry parameters, `ignoreTextStreamFailures`, DRM, etc.) and add
 * provider-specific overrides on top.
 */
declare interface ShakaConfigurator {
    /**
     * Returns Shaka player configuration.
     * The base implementation in {@link BaseShakaConfigurator} provides
     * default retry parameters, streaming settings and DRM configuration.
     * Provider subclasses should call `super.getPlayerConfig()` and
     * deep-merge their overrides.
     */
    getPlayerConfig?(context: ShakaSourceContext): Record<string, unknown>;
    /**
     * Returns request/response filters to register on the Shaka networking engine.
     * Called after configuration, before source loading.
     */
    getNetworkFilters?(context: ShakaSourceContext): ShakaNetworkFilters;
}

/**
 * Constructor type for Shaka configurators.
 *
 * Each provider exports a class extending {@link BaseShakaConfigurator}.
 * The registry instantiates it via `new Configurator()`.
 */
declare type ShakaConfiguratorClass = new () => BaseShakaConfigurator;

/**
 * Declarative set of network filters returned by {@link ShakaConfigurator.getNetworkFilters}.
 *
 * The caller is responsible for registering them on the Shaka networking engine.
 */
declare interface ShakaNetworkFilters {
    requestFilters?: shaka.extern.RequestFilter[];
    responseFilters?: shaka.extern.ResponseFilter[];
}

/**
 * Context passed to {@link ShakaConfigurator} callbacks during Shaka source setup.
 */
declare interface ShakaSourceContext {
    /** The selected source (the full normalized source from the media provider). */
    source: SourceNormalized;
    /** The Shaka library instance — for accessing `RequestType` enums, etc. */
    shaka: typeof shaka;
}

export declare type SourceMediaItem = SourceMediaItemBase | SourceMediaItemDrm | SourceMediaItemWithToken;

export declare interface SourceMediaItemBase {
    /**
     * Unique identifier of the media source.
     *
     * @defaultValue `V1StGXR8_Z5jdHi6B-myT` a generated identifier
     */
    id?: string;
    /**
     * Mimetype of the media source.
     *
     * @defaultValue detected from file extension of given {@link src} or `undefined`
     */
    mimetype?: Mimetype;
    /**
     * The source URL of this media source.
     */
    src: string;
    /**
     * Until the media source is valid. Unix timestamp in milliseconds.
     */
    validUntil?: number;
    /**
     * `true` when this source's signed token was already expired when resolved.
     * Used to skip the expiry reload, which would otherwise re-resolve the same
     * dead token in a loop. Re-derived on every resolve.
     */
    wasExpiredAtLoad?: boolean;
    /**
     * Playback mode of the media source (e.g. determines VOD or Live).
     *
     * @defaultValue `PlaybackMode.VOD`
     */
    playbackMode?: PlaybackMode;
    /**
     * When `true`, playback must always remain at the live edge.
     * Seeking behind the live edge is not permitted.
     *
     * @defaultValue `undefined` (treated as `false` — timeshift / seek-back is allowed)
     */
    liveEdgeOnly?: boolean;
    /**
     * Classification of the user's access level for this source.
     *
     * @defaultValue `undefined` (user tier is unknown or not applicable)
     */
    userTier?: UserTier;
    /**
     * Duration in seconds. Only relevant for dynamic content.
     */
    duration?: number;
}

export declare interface SourceMediaItemDrm extends SourceMediaItemBase {
    /**
     * The DRM system this source requires.
     */
    drmSystem: DrmSystem;
    /**
     * DRM token to include in license requests for the selected DRM system.
     */
    token?: string;
    /**
     * License server URL for the selected DRM system.
     */
    licenseUrl: string;
    /**
     * Certificate URL (relevant for FairPlay).
     */
    certificateUrl?: string;
}

/**
 * A token-authenticated media source — an alternative to {@link SourceMediaItemBase} for
 * providers that resolve the playback URL server-side using a token rather than exposing a
 * direct `src` URL. The provider detects these via `mimetype` and handles entitlement internally.
 */
export declare interface SourceMediaItemWithToken extends Omit<SourceMediaItemBase, 'src' | 'id' | 'mimetype' | 'playbackMode'> {
    /**
     * Unique identifier of the media source.
     */
    id: string;
    /**
     * Mimetype of the media source. Could also be a custom value.
     */
    mimetype: Mimetype | (string & {});
    /**
     * Playback mode of the media source (e.g. determines VOD or Live).
     */
    playbackMode: PlaybackMode;
    /**
     * User token used for authentication.
     */
    token: string;
}

/**
 * Source metadata produced by a media provider.
 *
 * Available on {@link SourceSelected.metadata}.
 */
export declare type SourceMetadata = Record<string, unknown>;

/**
 * A resolved source with guaranteed `id`, `src` and `mimetype`,
 * plus optional {@link DrmSourceData} fields.
 */
declare type SourceNormalized = Required<Pick<SourceMediaItemBase, 'id' | 'src' | 'mimetype'>> & Omit<SourceMediaItemBase, 'id' | 'src' | 'mimetype'> & DrmSourceData & {
    /** Provider-generated metadata for this source. */
    metadata?: SourceMetadata;
};

/**
 * Metadata of the source that was selected for playback.
 */
export declare interface SourceSelected {
    /** Unique identifier of the source. */
    id: string;
    /** MIME type of the media source (e.g. HLS, DASH, MP4). */
    mimetype: Mimetype;
    /** URL of the media source. */
    src: string;
    /** Playback mode indicating how the content should be played. */
    playbackMode?: PlaybackMode;
    /** DRM system used to protect the source, if any. */
    drmSystem?: DrmSystem;
    /**
     * When `true`, playback always remains at the live edge.
     * Seeking behind the live edge is not permitted.
     */
    liveEdgeOnly?: boolean;
    /**
     * Classification of the user's tier for this source.
     *
     * `undefined` means the user tier is unknown or not applicable.
     */
    userTier?: UserTier;
    /** Provider-generated metadata for this source. */
    metadata?: SourceMetadata;
}

export declare enum StartBehavior {
    CLICK_TO_PLAY = "click-to-play",
    SCROLL_TO_PLAY = "scroll-to-play",
    SCROLL_TO_PLAY_WHEN_AD = "scroll-to-play-when-ad",
    SCROLL_TO_PLAY_WITH_OUT_TO_PLAY_FALLBACK = "scroll-to-play-with-out-to-play-fallback",
    SCROLL_TO_PLAY_WITH_SILENT_FALLBACK = "scroll-to-play-with-silent-fallback",
    SILENT_SCROLL_TO_PLAY = "silent-scroll-to-play",
    SILENT_SCROLL_TO_PLAY_WHEN_AD = "silent-scroll-to-play-when-ad",
    SCROLL_OUT_TO_PLAY = "scroll-out-to-play",
    SCROLL_OUT_TO_PLAY_WHEN_AD = "scroll-out-to-play-when-ad"
}

export declare enum StartMethod {
    /** Autoplay occured for above the fold content */
    PRE_CLICK = "pre-click-to-play",
    /** Playback started with click */
    CLICK = "click-to-play",
    /** Autoplay started when scrolling into view */
    AUTOPLAY_SCROLL = "autoplay-scroll",
    /** Autoplay started when scrolling out of view, player was docked */
    AUTOPLAY_SCROLL_OUT = "autoplay-scroll-out",
    /** Playback of next video started with click */
    CLICK_NEXT = "click-to-play-next",
    /** Replay of current video started with click */
    CLICK_REPLAY = "click-to-play-replay",
    /** Autoplay of next video */
    AUTOPLAY_NEXT = "autoplay-next"
}

declare enum TcfVersion {
    UNKNOWN = "unknown",
    V2 = "2.0",
    V2_2 = "2.2",
    V2_3 = "2.3",
    V2_UNKNOWN = "2.?"
}

/**
 * The environment in which a teaser is rendered.
 */
export declare enum TeaserEnvironment {
    TEASER = "teaser",
    ENDSCREEN_RECOMMENDATION = "endscreen-recommendation",
    ENDSCREEN_REPLAY = "endscreen-replay",
    CAROUSEL = "carousel",
    GRID = "grid"
}

/**
 * Represents a text track (subtitles, captions, etc.).
 */
declare interface TextTrack_2 extends MediaTrack {
    /** The type of text track. */
    kind: 'subtitles' | 'captions' | 'descriptions' | 'chapters';
    /**
     * The current display mode of the track.
     * - `'disabled'`: Track is not active.
     * - `'hidden'`: Track is active but not displayed (for programmatic access).
     * - `'showing'`: Track is active and displayed to the user.
     */
    mode: 'disabled' | 'hidden' | 'showing';
}
export { TextTrack_2 as TextTrack }

/**
 * A collection of text tracks with selection support.
 * Text tracks can be deselected by passing `undefined` to `select()`.
 *
 * **Note:** Text tracks are available after the {@link IntegrationElement.ready | integration.ready} promise resolves.
 *
 * The list is iterable and can be converted to an array:
 * @example
 * ```ts
 * for (const track of integration.textTracks) { console.log(track); }
 * const tracks = Array.from(integration.textTracks);
 * ```
 */
declare interface TextTrackList_2 extends MediaTrackList<TextTrack_2> {
    /** The currently selected text track, or `null` if none is selected. */
    readonly selected: TextTrack_2 | null;
    /**
     * Selects a text track or disables text tracks.
     * @param trackOrId - The track, track ID, or `undefined` to disable all text tracks.
     */
    select(trackOrId: TextTrack_2 | string | undefined): void;
}
export { TextTrackList_2 as TextTrackList }

declare type UiAction = (typeof ALLOWED_UI_ACTIONS)[number];

/** @interface */
declare type UiConfig = typeof UiConfigSchema.infer;

/**
 * UI configuration
 */
declare const UiConfigSchema: ObjectType<    {
enable: boolean;
title: boolean;
contentBranding: boolean;
contentOwnerLogo: boolean;
nextVideoButton: boolean;
epgButton: boolean;
upsellButton: boolean;
premiumProductName: string;
useInitialTeaserComposition: boolean;
contentComposition: "content" | "content-network" | "content-streamer";
tapToUnmute: boolean;
globalKeyboardEvents: boolean;
}, {}>;

/**
 * Enriched user-id entry as returned by {@link InternalHostContext.getUserIds}.
 * Combines the raw resolver output with ortb2 metadata (`atype`, `gvlId`,
 * default `source`) from the user-id registry.
 */
declare interface UserId {
    name: string;
    id: string;
    atype: number;
    ext?: {
        created?: number;
    } & Record<string, unknown>;
    additionalUids?: {
        id: string;
        atype: number;
        ext?: Record<string, unknown>;
    }[];
    /**
     * ortb2 EID `source`. `undefined` keeps the id internal-only (not exposed
     * via `idsAsEids`).
     */
    source?: string;
    gvlId?: number;
}

declare interface UserIdAsEid {
    source: string;
    uids: {
        id: string;
        atype: number;
        ext?: Record<string, unknown>;
    }[];
}

/**
 * Identifier names for user IDs that can be passed via {@link HostContextData.userIds}.
 */
export declare enum UserIdName {
    /** {@link https://netid.de netID} — European login alliance ID */
    NET_ID = "netId",
    /** Publisher Provided ID. By default, the built-in PPID resolver auto-generates and persists a UUID when consent is given, unless overridden by a publisher-provided resolver registration. */
    PPID = "ppid",
    /** {@link https://utiq.com Utiq} — telco-based advertising ID */
    UTIQ_ID = "utiqId",
    /** {@link https://liveramp.com LiveRamp} — identity resolution ID */
    LIVERAMP_ID = "liverampId",
    /** {@link https://developers.google.com/interactive-media-ads/docs/sdks/html5/client-side/pair Google PAIR} — Publisher Advertiser Identity Reconciliation ID */
    PAIR_ID = "pairId",
    /** {@link https://liveramp.com LiveRamp} — Authenticated Traffic Solution (ATS) direct encrypted identity envelope */
    ATS_DIRECT = "atsDirect",
    /** {@link https://pubcid.org SharedID} — open-source first-party publisher ID */
    SHARED_ID = "sharedId",
    /** {@link https://theadex.com The Adex} — DMP user ID (integration-internal, not publisher-supplied) */
    THE_ADEX_ID = "theAdexId",
    /** {@link https://id5.io ID5} — cookieless identity solution */
    ID5_ID = "id5Id",
    /** {@link https://criteo.com Criteo} — identity solution */
    CRITEO_ID = "criteoId",
    /** {@link https://crwdcntrl.net Lotame Panorama ID} — cross-domain identity */
    LOTAME_PANORAMA_ID = "lotamePanoramaId",
    /** {@link https://uidapi.com UID2} — Unified ID 2.0 */
    UNIFIED_ID2 = "unifiedId2Id",
    /** {@link https://euid.eu EUID} — European Unified ID */
    EU_ID = "euId",
    /** {@link https://yieldlab.com Yieldlab} — programmatic advertising user ID */
    YIELDLAB_ID = "yieldlabId"
}

declare type UserIds = Partial<Record<UserIdName, UserId>> & Record<string, UserId | undefined>;

declare interface UserState {
    consent: Consent;
    ids: UserIds;
    idsAsEids: UserIdAsEid[];
}

/**
 * Classification of the user's tier.
 */
export declare enum UserTier {
    ANONYMOUS = "anonymous",
    REGISTERED = "registered",
    PAID = "paid"
}

declare type VariantLoaderMap = Record<string, () => Promise<{
    default: unknown;
}>>;

/** @interface */
declare type VariantSettings = typeof VariantSettingsSchema.infer;

/**
 * Variant settings embedded in the player config.
 *
 * Flat shape: the variant `id` identifies the variant, and all remaining
 * keys are the merged settings (variant defaults + per-integration overrides).
 * This matches the player-internal `VariantConfig` shape so no mapping is needed.
 */
declare const VariantSettingsSchema: ObjectType<    {
[x: string]: unknown;
id: string;
}, {}>;

declare interface VastLineItem {
    id: string;
    url: string;
    externalId: string;
    errorPixels?: string[];
    extra?: Record<string, unknown>;
}

declare interface VastPod {
    breakName: string;
    breakIndex: number;
    slots: VastSlot[];
}

declare interface VastSlot {
    index: number;
    maxDuration?: number;
    maxFallbackAttempts?: number;
    lineItems: VastLineItem[];
}

/**
 * Represents a video track (quality variant).
 */
export declare interface VideoTrack {
    /** Unique identifier for the track. */
    id: string;
    /**
     * The type of video track.
     * - `'variant'`: A specific quality level.
     * - `'auto'`: Synthetic track representing automatic quality selection (ABR).
     */
    kind: 'variant' | 'auto';
    /** Human-readable label (e.g., "1080p (6.2 Mbps)"). */
    label: string;
    /** Bitrate in bits per second. */
    bandwidth: number;
    /** Video width in pixels. */
    width?: number;
    /** Video height in pixels. */
    height?: number;
}

/**
 * A collection of video tracks with selection support.
 * May be empty or only synthetic when native track info is unavailable.
 *
 * **Note:** Video tracks are available after the {@link IntegrationElement.ready | integration.ready} promise resolves.
 *
 * The list is iterable and can be converted to an array:
 * @example
 * ```ts
 * for (const track of integration.videoTracks) { console.log(track); }
 * const tracks = Array.from(integration.videoTracks);
 * ```
 */
export declare interface VideoTrackList extends EventTarget, Iterable<VideoTrack> {
    /** The number of tracks in the list. */
    readonly length: number;
    /**
     * Returns the track with the specified ID.
     * @param id - The track ID to search for.
     * @returns The matching track, or `null` if not found.
     */
    getTrackById(id: string): VideoTrack | null;
    /** The currently selected video track, or `null` if unavailable. */
    readonly selected: VideoTrack | null;
    /**
     * Selects a video track or enables automatic quality selection.
     * @param trackOrId - The track, track ID, or `'auto'` for ABR.
     */
    select(trackOrId: VideoTrack | string): void;
    /**
     * Adds an event listener for track list changes.
     * @param type - The event type: `'trackschange'` (track list changed) or `'change'` (selection changed).
     * @param listener - The callback function.
     * @param options - Optional event listener options.
     */
    addEventListener(type: 'trackschange' | 'change', listener: EventListener, options?: boolean | AddEventListenerOptions): void;
}

export { }

declare global {
  interface HTMLElementEventMap extends IntegrationElementEventMap {}
}