@dolby-optiview/ads-sdk-core 1.0.0-beta.1

package/dist/types/BreakManifest.d.ts

@@ -0,0 +1,335 @@
+/** Break Manifest types, per https://github.com/Dolby-OptiView/optiview-ads-manifest-spec/blob/v1.4.0/spec.md. */
+/** Which 'time' reference break start times use. @category Break Manifests & Ad Formats */
+export declare enum Timebase {
+    /** An absolute ISO-8601 timestamp */
+    WALLCLOCK = "wallclock",
+    /** A presentation timestamp in seconds (may be fractional); live streams */
+    PTS = "pts",
+    /** Seconds from the start of the asset, matched against the playback position; VOD only */
+    MEDIATIME = "mediatime"
+}
+/** Polling configuration for manifest refresh. @category Break Manifests & Ad Formats */
+export interface Polling {
+    /** Interval (seconds >= 1) between manifest polls when no break is active. */
+    idle: number;
+    /** Interval (seconds >= 1) between manifest polls while a break is currently being rendered. */
+    active: number;
+}
+/**
+ * Session-level configuration for one vendor, discriminated by `type` (same identifiers as an
+ * asset's `vendor`). At most one entry per type; unknown types are logged and ignored.
+ * @category Break Manifests & Ad Formats */
+export interface VendorConfigurationBase {
+    /** The vendor this configuration applies to. */
+    type: string;
+}
+/** Session-level GAM configuration for pod-serving SGAI. @category Break Manifests & Ad Formats */
+export interface GamSgaiConfiguration {
+    customAssetKey: string;
+    assetParameters?: Record<string, string>;
+}
+/** Session-level GAM configuration for full-service DAI SSAI. @category Break Manifests & Ad Formats */
+export interface GamSsaiConfiguration {
+    assetKey: string;
+    assetParameters?: Record<string, string>;
+}
+/**
+ * The GAM identity needed to create the IMA/DAI stream session. Must agree with the per-asset
+ * `vendorParameters`: GAM answers a `stream_id` registered under another custom asset key with HTTP 410.
+ * @category Break Manifests & Ad Formats */
+export interface GamVendorConfiguration extends VendorConfigurationBase {
+    type: 'gam';
+    /** The configured network code for this organization. */
+    networkCode: string;
+    /**
+     * The configured custom asset key for this channel — pod serving (sgai).
+     * @deprecated Prefer `sgai[0].customAssetKey` in manifest spec v1.4.0.
+     */
+    customAssetKey: string;
+    /**
+     * Full-service DAI livestream asset key, required for a stitched (ssai) stream.
+     * @deprecated Prefer `ssai[0].assetKey` in manifest spec v1.4.0.
+     */
+    assetKey?: string;
+    sgai?: GamSgaiConfiguration[];
+    ssai?: GamSsaiConfiguration[];
+}
+/** Known vendor configuration entries, kept open to unrecognized vendors from newer manifests. @category Break Manifests & Ad Formats */
+export type VendorConfiguration = GamVendorConfiguration | VendorConfigurationBase;
+/** Type guard: narrows a {@link VendorConfiguration} to a {@link GamVendorConfiguration}. */
+export declare function isGamVendorConfiguration(entry: VendorConfiguration): entry is GamVendorConfiguration;
+/** The root Break Manifest structure. @category Break Manifests & Ad Formats */
+export interface BreakManifest {
+    /** Manifest version (semver format, e.g., "1.0.0") */
+    version: string;
+    /** Determines which 'time' reference is used */
+    timebase: Timebase;
+    /** Identifier of the organization owning the stream. */
+    organizationId?: string;
+    /** Identifier of the channel the stream belongs to. */
+    channelId?: string;
+    /** Identifier of the event being streamed. */
+    eventId?: string;
+    /** Determines how often the manifest should be refreshed */
+    polling?: Polling;
+    /** Ordered delivery-steering rules (first match wins), evaluated once on the first fetch; absent means sgai. */
+    delivery?: DeliveryRule[];
+    /** Played seconds (>= 0) before any break may start; omitted means 0. */
+    adStartDelay?: number;
+    /** Session-level configuration per vendor integration (spec 1.1.0). */
+    vendorConfiguration?: VendorConfiguration[];
+    /** The available breaks */
+    breaks: Break[];
+}
+/** Delivery architecture selected by a {@link DeliveryRule}. @category Break Manifests & Ad Formats */
+export declare enum DeliveryMode {
+    /** Server-Guided Ad Insertion — the SDK schedules and renders breaks client-side. */
+    SGAI = "sgai",
+    /** Server-Side Ad Insertion — the content player plays a server-stitched stream. */
+    SSAI = "ssai"
+}
+/** One delivery-steering rule. Without targeting it matches every client (the default). @category Break Manifests & Ad Formats */
+export interface DeliveryRule {
+    /** Typed as {@link DeliveryMode}, but unknown future values may arrive (forward compatibility). */
+    mode: DeliveryMode;
+    targeting?: Targeting;
+}
+/** User control options during a break. @category Break Manifests & Ad Formats */
+export interface Controls {
+    /** Offset after which the break can be skipped, in seconds >= 0. */
+    skipOffset?: number;
+    /** Whether snapback is enabled. */
+    snapback?: boolean;
+}
+/**
+ * Break position relative to playback lifecycle (SDK shorthand for an {@link EventTrigger}).
+ * - `pre`: pre-roll, same as `start: { type: 'event', event: 'start' }`.
+ * @category Break Manifests & Ad Formats */
+export type BreakPosition = 'pre';
+/** Playback lifecycle events a break can be triggered by (spec 1.1.0). @category Break Manifests & Ad Formats */
+export declare enum BreakEvent {
+    /** Content playback begins (pre-roll). Fires once per session. */
+    START = "start",
+    /** The viewer pauses content. */
+    PAUSE = "pause",
+    /** Content playback ends (post-roll). */
+    END = "end"
+}
+/** Event-triggered break start (spec 1.1.0): the break is scheduled by a playback event, not a time. @category Break Manifests & Ad Formats */
+export interface EventTrigger {
+    type: 'event';
+    /** Typed as {@link BreakEvent}, but unknown future values may arrive (forward compatibility). */
+    event: BreakEvent;
+    /**
+     * Seconds after the event before the break triggers. For `start` this counts played media
+     * time only: pausing or seeking does not advance it.
+     * @default 0
+     */
+    delay?: number;
+}
+/** A single ad break. @category Break Manifests & Ad Formats */
+export interface Break {
+    /** The identifier of the break */
+    id: string;
+    /**
+     * Break start in the timebase: wallclock is an ISO-8601 string, pts/mediatime seconds >= 0,
+     * or an {@link EventTrigger}. Ignored when `position` is set (scheduling uses `delay`).
+     */
+    start: string | number | EventTrigger;
+    /** `'pre'`: pre-roll relative to playback start. Not supported in SSAI mode. */
+    position?: BreakPosition;
+    /**
+     * Seconds of content played before a `'pre'` roll triggers.
+     * @default 0
+     */
+    delay?: number;
+    /** The maximum duration of the break in seconds */
+    duration: number;
+    /** Where the player should resume after the break in seconds >= 0 */
+    resumeOffset?: number;
+    /** What the user is allowed to do during a break */
+    controls?: Controls;
+    /** The variant or list of variants for this break */
+    variant: BreakVariant | BreakVariant[];
+}
+/** The supported break formats. @category Break Manifests & Ad Formats */
+export declare enum BreakFormat {
+    /** One slot covering the player surface */
+    SINGLE = "single",
+    /** Two zones — main video area + a companion area alongside */
+    DOUBLE = "double",
+    /** Main video shrinks into a corner, ad is played, backdrop filled with companion ad */
+    LSHAPE_AD = "lshape_ad",
+    /** Main video shrinks, content keeps playing, backdrop filled with ad */
+    LSHAPE_CONTENT = "lshape_content",
+    /** Ad rendered on top of main content, main keeps playing */
+    OVERLAY = "overlay"
+}
+/** Device type for targeting. @category Break Manifests & Ad Formats */
+export declare enum DeviceType {
+    DESKTOP = "desktop",
+    MOBILE = "mobile",
+    TABLET = "tablet",
+    TV = "tv"
+}
+/** Targeting criteria for break variants. @category Break Manifests & Ad Formats */
+export interface Targeting {
+    deviceType?: DeviceType;
+}
+/** Base fields for all break variants. @category Break Manifests & Ad Formats */
+export interface BaseBreakVariant {
+    /** The format of the break */
+    format: BreakFormat;
+    /** Player-side match criteria, omit to mark as default variant */
+    targeting?: Targeting;
+}
+/** Single break variant - full-screen ad. @category Break Manifests & Ad Formats */
+export interface SingleBreakVariant extends BaseBreakVariant {
+    format: BreakFormat.SINGLE;
+    /** A list of assets */
+    assets: Asset[];
+}
+/** An asset paired with a companion (double and lshape_ad). The companion is a flat property per spec. @category Break Manifests & Ad Formats */
+export type AssetWithCompanion = Asset & {
+    companion: Asset;
+};
+/** Overlay position, fractional [0.0–1.0]; the SDK converts to CSS percentages. @category Break Manifests & Ad Formats */
+export interface OverlayPosition {
+    top?: number;
+    bottom?: number;
+    left?: number;
+    right?: number;
+}
+/** Overlay size, fractional [0.0–1.0]; the SDK converts to CSS percentages. @category Break Manifests & Ad Formats */
+export interface OverlaySize {
+    width: number;
+    height: number;
+}
+/** Double-box variant — ad on one side, companion on the other. Content pauses. @category Break Manifests & Ad Formats */
+export interface DoubleBreakVariant extends BaseBreakVariant {
+    format: BreakFormat.DOUBLE;
+    /** Paired ad + companion assets. */
+    assets: AssetWithCompanion[];
+}
+/** L-shape (ad) variant — content shrinks to pip, ad fills main area, companion fills the backdrop. Content pauses. @category Break Manifests & Ad Formats */
+export interface LshapeAdBreakVariant extends BaseBreakVariant {
+    format: BreakFormat.LSHAPE_AD;
+    /** Paired ad + companion assets. */
+    assets: AssetWithCompanion[];
+}
+/** L-shape (content) variant — content shrinks to pip and keeps playing, ad fills the main area. @category Break Manifests & Ad Formats */
+export interface LshapeContentBreakVariant extends BaseBreakVariant {
+    format: BreakFormat.LSHAPE_CONTENT;
+    /** Ad assets (no companion). */
+    assets: Asset[];
+}
+/** Overlay variant — ad plays on top of content, which keeps playing. Position and size come from the manifest. @category Break Manifests & Ad Formats */
+export interface OverlayBreakVariant extends BaseBreakVariant {
+    format: BreakFormat.OVERLAY;
+    /** Ad assets. */
+    assets: Asset[];
+    /** Position within the player container (CSS values). */
+    position: OverlayPosition;
+    /** Size of the overlay (CSS values). */
+    size: OverlaySize;
+    /** Opacity 0–1. Defaults to 1. */
+    opacity?: number;
+}
+/** Union of all break variants. @category Break Manifests & Ad Formats */
+export type BreakVariant = SingleBreakVariant | DoubleBreakVariant | LshapeAdBreakVariant | LshapeContentBreakVariant | OverlayBreakVariant;
+/** The type of the asset. @category Break Manifests & Ad Formats */
+export declare enum AssetType {
+    /** Static resource, direct URL */
+    STATIC = "static",
+    /** VAST tag URL */
+    VAST = "vast",
+    /** Vendor-specific (e.g., Google DAI) */
+    VENDOR = "vendor"
+}
+/** Whether the asset is a video or image. @category Break Manifests & Ad Formats */
+export declare enum MediaType {
+    VIDEO = "video",
+    IMAGE = "image"
+}
+/** Supported vendors for vendor assets. @category Break Manifests & Ad Formats */
+export declare enum Vendor {
+    /** Google Ad Manager */
+    GAM = "gam"
+}
+/** Interaction options for an asset. @category Break Manifests & Ad Formats */
+export interface Interaction {
+    /** Click-through URL */
+    clickThrough?: string;
+}
+/** Asset URI with optional targeting. @category Break Manifests & Ad Formats */
+export interface AssetUri {
+    value: string;
+    targeting?: Targeting;
+}
+/** Base fields for all assets. @category Break Manifests & Ad Formats */
+export interface BaseAsset {
+    /** The identifier of the asset, unique within the break */
+    id: string;
+    /** The type of the asset */
+    type: AssetType;
+    /** The media type, video or image */
+    mediaType: MediaType;
+    /** The mime type of the media */
+    mimeType?: string;
+    /** The maximum duration of the asset in seconds */
+    duration?: number;
+    /** Interaction options */
+    interaction?: Interaction;
+}
+/** Static asset - direct URL to media. @category Break Manifests & Ad Formats */
+export interface StaticAsset extends BaseAsset {
+    type: AssetType.STATIC;
+    /** The resource URL or array of URLs with targeting */
+    uri: string | AssetUri[];
+}
+/** VAST asset, played by Google IMA as CSAI. SGAI only, linear formats only (single, double, lshape_ad). @category Break Manifests & Ad Formats */
+export interface VastAsset extends BaseAsset {
+    type: AssetType.VAST;
+    /** The VAST tag URL, or an array of URLs with targeting. */
+    uri: string | AssetUri[];
+    /**
+     * Query parameters the player appends to the VAST tag URL. Values may be
+     * `$NAME$` macros (`$OPTIVIEW_*$` built-ins or customer-registered ones).
+     */
+    assetParameters?: Record<string, string>;
+}
+/** Vendor asset - vendor-specific retrieval (e.g., Google DAI). @category Break Manifests & Ad Formats */
+export interface VendorAsset extends BaseAsset {
+    type: AssetType.VENDOR;
+    /** The URI of the asset for the vendor (e.g., pod id for GAM DAI) */
+    uri: string;
+    /** The vendor used to retrieve the asset */
+    vendor: Vendor;
+    /** Vendor-specific parameters */
+    vendorParameters: Record<string, string>;
+    /** Asset-specific parameters (e.g., adTagParameters for GAM) */
+    assetParameters?: Record<string, string>;
+}
+/** Union of all assets. @category Break Manifests & Ad Formats */
+export type Asset = StaticAsset | VastAsset | VendorAsset;
+/** Type guard: narrows a break `start` to an {@link EventTrigger}. */
+export declare function isEventTrigger(start: Break['start']): start is EventTrigger;
+/**
+ * The lifecycle event a break is triggered by, or `null` for a timeline break. Reads both the
+ * spec shape (`start: { type: 'event', event }`) and the SDK shorthand (`position`).
+ */
+export declare function getBreakEvent(breakInfo: Break): string | null;
+/** Whether the break is a pause ad: `start: { type: 'event', event: 'pause' }`. */
+export declare function isPauseBreak(breakInfo: Break): boolean;
+/** Seconds of played content before a pre-roll triggers, or `null` when the break is not a pre-roll. */
+export declare function getPreRollDelay(breakInfo: Break): number | null;
+/** Whether the break is a post-roll: `start: { type: 'event', event: 'end' }`. */
+export declare function isPostRollBreak(breakInfo: Break): boolean;
+/** Seconds after content playback ends before a post-roll triggers, or `null` when the break is not a post-roll. */
+export declare function getPostRollDelay(breakInfo: Break): number | null;
+/** Type guard: narrows an {@link Asset} to a {@link StaticAsset}. */
+export declare function isStaticAsset(asset: Asset): asset is StaticAsset;
+/** Type guard: narrows an {@link Asset} to a {@link VastAsset}. */
+export declare function isVastAsset(asset: Asset): asset is VastAsset;
+/** Type guard: narrows an {@link Asset} to a {@link VendorAsset}. */
+export declare function isVendorAsset(asset: Asset): asset is VendorAsset;

package/dist/types/BreakManifest.js

@@ -0,0 +1 @@
+export var Timebase;!function(e){e.WALLCLOCK="wallclock",e.PTS="pts",e.MEDIATIME="mediatime"}(Timebase||(Timebase={}));export function isGamVendorConfiguration(e){return"gam"===e.type}export var DeliveryMode;!function(e){e.SGAI="sgai",e.SSAI="ssai"}(DeliveryMode||(DeliveryMode={}));export var BreakEvent;!function(e){e.START="start",e.PAUSE="pause",e.END="end"}(BreakEvent||(BreakEvent={}));export var BreakFormat;!function(e){e.SINGLE="single",e.DOUBLE="double",e.LSHAPE_AD="lshape_ad",e.LSHAPE_CONTENT="lshape_content",e.OVERLAY="overlay"}(BreakFormat||(BreakFormat={}));export var DeviceType;!function(e){e.DESKTOP="desktop",e.MOBILE="mobile",e.TABLET="tablet",e.TV="tv"}(DeviceType||(DeviceType={}));export var AssetType;!function(e){e.STATIC="static",e.VAST="vast",e.VENDOR="vendor"}(AssetType||(AssetType={}));export var MediaType;!function(e){e.VIDEO="video",e.IMAGE="image"}(MediaType||(MediaType={}));export var Vendor;!function(e){e.GAM="gam"}(Vendor||(Vendor={}));export function isEventTrigger(e){return"object"==typeof e&&null!==e&&"event"===e.type}export function getBreakEvent(e){return"pre"===e.position?BreakEvent.START:isEventTrigger(e.start)?e.start.event:null}export function isPauseBreak(e){return getBreakEvent(e)===BreakEvent.PAUSE}export function getPreRollDelay(e){return getBreakEvent(e)!==BreakEvent.START?null:"pre"===e.position?e.delay??0:isEventTrigger(e.start)?e.start.delay??0:0}export function isPostRollBreak(e){return getBreakEvent(e)===BreakEvent.END}export function getPostRollDelay(e){return isEventTrigger(e.start)&&e.start.event===BreakEvent.END?e.start.delay??0:null}export function isStaticAsset(e){return e.type===AssetType.STATIC}export function isVastAsset(e){return e.type===AssetType.VAST}export function isVendorAsset(e){return e.type===AssetType.VENDOR}

package/dist/types/Events.d.ts

@@ -0,0 +1,245 @@
+import { Break, Asset, BreakFormat } from './BreakManifest';
+import type { OptiViewAdsMode } from './OptiViewAdsConfig';
+/**
+ * Lifecycle phase reported by {@link AdBreakStatus}.
+ * - `idle`: no break is upcoming or active.
+ * - `upcoming`: a break is scheduled in the future (including pre-break warnings).
+ * - `active`: a break is currently playing.
+ * @category Events */
+export type AdBreakPhase = 'idle' | 'upcoming' | 'active' | 'complete';
+/** Playback-gated snapshot of an ad break for UI countdowns (`adbreakstatus` event, `sdk.getAdBreakStatus()`). @category Events */
+export interface AdBreakStatus {
+    /** Current lifecycle phase of the ad break. */
+    phase: AdBreakPhase;
+    /** The break this status describes; `null` when `phase` is `idle`. */
+    break: Break | null;
+    /** Declared format of the break's selected variant, when known. */
+    format?: BreakFormat | undefined;
+    /** Seconds until the break starts; for a pre-break warning, the countdown value when it fired. */
+    secondsUntilBreak?: number | undefined;
+    /** Estimated seconds left in the active break; `undefined` when not yet derivable (e.g. a backdrop break with no per-ad `timeupdate`). */
+    breakRemainingSec?: number | undefined;
+    /** 0-based index of the ad currently playing within the break. */
+    adIndex?: number | undefined;
+    /** Total number of ads in the break, when known. */
+    totalAds?: number | undefined;
+    /** Number of ads remaining including the currently playing one. */
+    adsRemaining?: number | undefined;
+    /** Whether the countdown is advancing (ad rendered, playback progressing). `false` while buffering or before a held pre-roll's first frame. */
+    ticking: boolean;
+    /** The configured warning second that was crossed, when a pre-break warning triggered this status. */
+    warningSec?: number | undefined;
+}
+/** Event types emitted by the OptiViewAds SDK. @category Events */
+export type OptiViewAdsEventType = 'adbreakbegin' | 'adbreakend' | 'adbegin' | 'adend' | 'aderror' | 'adfirstquartile' | 'admidpoint' | 'adthirdquartile' | 'adtimeupdate' | 'adbreakstatus' | 'adclick' | 'waiting' | 'playing' | 'volumechange' | 'adchannelchange';
+/** Which player a playback event originated from. @category Events */
+export type PlaybackSource = 'ad' | 'content';
+/** Base event interface. @category Events */
+export interface OptiViewAdsEvent {
+    type: OptiViewAdsEventType;
+    timestamp: number;
+}
+/** Emitted when an ad break starts. @category Events */
+export interface AdBreakBeginEvent extends OptiViewAdsEvent {
+    type: 'adbreakbegin';
+    break: Break;
+    /** Declared format of the break's selected variant. */
+    format?: BreakFormat | undefined;
+    /** Seconds elapsed since the break's start when this viewer joined; zero only at the exact start. */
+    elapsedSec: number;
+    /**
+     * Seconds the break is presented for. Always reported: a viewer can be part-way into a break
+     * without a tune-in classification (inside the scheduler's start tolerance).
+     */
+    remainingSec: number;
+    /**
+     * Present when the viewer joined a break already in progress (tune-in).
+     * @deprecated Read the top-level `elapsedSec` / `remainingSec`; use this only as the join
+     * classification, since part-way joins inside the start tolerance do not set it.
+     */
+    tuneIn?: {
+        /** Seconds already elapsed since the break's start when the viewer joined. */
+        elapsedSec: number;
+        /** Effective remaining duration, in seconds, the break is presented for. */
+        remainingSec: number;
+    };
+}
+/** Emitted when an ad break ends. @category Events */
+export interface AdBreakEndEvent extends OptiViewAdsEvent {
+    type: 'adbreakend';
+    break: Break;
+    /** Declared format of the break's selected variant. */
+    format?: BreakFormat | undefined;
+}
+/** Emitted when the current or upcoming break's status changes; carries a full {@link AdBreakStatus}. @category Events */
+export interface AdBreakStatusEvent extends OptiViewAdsEvent {
+    type: 'adbreakstatus';
+    status: AdBreakStatus;
+}
+/** Emitted when an individual ad starts playing. @category Events */
+export interface AdBeginEvent extends OptiViewAdsEvent {
+    type: 'adbegin';
+    break: Break;
+    /** Declared format of the break's selected variant. */
+    format?: BreakFormat | undefined;
+    asset: Asset;
+    adIndex: number;
+    totalAds: number;
+    /** IMA's ad id for an ad of a GAM pod, where several creatives play under one asset. Absent otherwise. */
+    adId?: string | undefined;
+    /** IMA's creative id for an ad of a GAM pod. */
+    creativeId?: string | undefined;
+    /** 1-based position within the pod as reported at runtime (IMA `getAdPodInfo().getAdPosition()` / VAST `sequence`). */
+    podPosition?: number | undefined;
+}
+/** Emitted when an individual ad finishes playing. @category Events */
+export interface AdEndEvent extends OptiViewAdsEvent {
+    type: 'adend';
+    break: Break;
+    /** Declared format of the break's selected variant. */
+    format?: BreakFormat | undefined;
+    asset: Asset;
+    adIndex: number;
+    totalAds: number;
+    /** IMA's ad id for an ad of a GAM pod. */
+    adId?: string | undefined;
+    /** IMA's creative id for an ad of a GAM pod. */
+    creativeId?: string | undefined;
+}
+/** Emitted when playback fails (ad or content; see `source`). `break`/`asset` only for ad errors. @category Events */
+export interface AdErrorEvent extends OptiViewAdsEvent {
+    type: 'aderror';
+    source: PlaybackSource;
+    break?: Break;
+    /** Declared format of the break's selected variant; absent for content errors. */
+    format?: BreakFormat | undefined;
+    asset?: Asset;
+    error: Error;
+}
+/** Emitted when an ad reaches the first quartile (25%). @category Events */
+export interface AdFirstQuartileEvent extends OptiViewAdsEvent {
+    type: 'adfirstquartile';
+    break: Break;
+    /** Declared format of the break's selected variant. */
+    format?: BreakFormat | undefined;
+    asset: Asset;
+    /** Which ad the milestone belongs to, for multi-ad GAM pods where quartile cycles repeat under one asset. */
+    adIndex?: number | undefined;
+    /** Ads in the break, when known. */
+    totalAds?: number | undefined;
+}
+/** Emitted when an ad reaches the midpoint (50%). @category Events */
+export interface AdMidpointEvent extends OptiViewAdsEvent {
+    type: 'admidpoint';
+    break: Break;
+    /** Declared format of the break's selected variant. */
+    format?: BreakFormat | undefined;
+    asset: Asset;
+    /** Which ad the milestone belongs to, when known. */
+    adIndex?: number | undefined;
+    /** Ads in the break, when known. */
+    totalAds?: number | undefined;
+}
+/** Emitted when an ad reaches the third quartile (75%). @category Events */
+export interface AdThirdQuartileEvent extends OptiViewAdsEvent {
+    type: 'adthirdquartile';
+    break: Break;
+    /** Declared format of the break's selected variant. */
+    format?: BreakFormat | undefined;
+    asset: Asset;
+    /** Which ad the milestone belongs to, when known. */
+    adIndex?: number | undefined;
+    /** Ads in the break, when known. */
+    totalAds?: number | undefined;
+}
+/** Emitted on each timeupdate tick during ad playback. @category Events */
+export interface AdTimeupdateEvent extends OptiViewAdsEvent {
+    type: 'adtimeupdate';
+    break: Break;
+    /** Declared format of the break's selected variant. */
+    format?: BreakFormat | undefined;
+    asset: Asset;
+    /** Current playback position within the ad asset, in seconds. */
+    currentTime: number;
+    /** Total duration of the ad asset in seconds. May be Infinity for live/unknown assets. */
+    duration: number;
+}
+/** Emitted when playback stalls (native `waiting`), ad or content per `source`. `break`/`asset` only for ads. @category Events */
+export interface WaitingEvent extends OptiViewAdsEvent {
+    type: 'waiting';
+    source: PlaybackSource;
+    break?: Break;
+    asset?: Asset;
+}
+/** Emitted on every native `playing`, ad or content per `source`. `break`/`asset` only for ads. @category Events */
+export interface PlayingEvent extends OptiViewAdsEvent {
+    type: 'playing';
+    source: PlaybackSource;
+    break?: Break;
+    asset?: Asset;
+}
+/**
+ * Emitted when the unified mute/volume state changes (setters, a direct element mutation the
+ * sync picked up, or the `double`-break audio-focus handoff). Describes the effective audio
+ * owner: the ad player during a break, content otherwise.
+ * @category Events */
+export interface VolumeChangeEvent extends OptiViewAdsEvent {
+    type: 'volumechange';
+    muted: boolean;
+    volume: number;
+}
+/**
+ * Emitted when the on-screen ad is clicked (viewer tap or {@link OptiViewAds.clickAd}).
+ * `clickThrough` is the asset's declared URL. The SDK does not navigate automatically;
+ * your application decides how to open the destination.
+ * @category Events */
+export interface AdClickEvent extends OptiViewAdsEvent {
+    type: 'adclick';
+    break: Break;
+    /** Declared format of the break's selected variant. */
+    format?: BreakFormat | undefined;
+    asset: Asset;
+    clickThrough?: string | undefined;
+}
+/** Why the SDK rebuilt its ad setup from a polled manifest; see {@link AdChannelChangeEvent}. @category Events */
+export type AdChannelChangeReason = 'channel-id-changed' | 'channel-id-added' | 'channel-id-removed' | 'vendor-configuration-changed' | 'timebase-changed';
+/**
+ * Emitted when a polled manifest describes a different ads channel than the one the session
+ * was started on. During an active break, the event is emitted after that break finishes and
+ * the latest polled manifest is applied. Before playback starts, the new manifest's
+ * `adStartDelay` applies; after playback starts, the delay in effect is unchanged.
+ * @category Events */
+export interface AdChannelChangeEvent extends OptiViewAdsEvent {
+    type: 'adchannelchange';
+    /** `channelId` of the manifest the session was aligned to before; `null` when it had none. */
+    previousChannelId: string | null;
+    /** `channelId` of the manifest the session is aligned to now; `null` when it has none. */
+    channelId: string | null;
+    reason: AdChannelChangeReason;
+    /** The polled manifest URL (unchanged by the switch). */
+    manifestUrl: string;
+    /** Delivery mode in effect before the switch. */
+    previousDeliveryMode: OptiViewAdsMode;
+    /** Delivery mode in effect after the switch. */
+    deliveryMode: OptiViewAdsMode;
+}
+/** Union type of all SDK events. @category Events */
+export type OptiViewAdsEventMap = {
+    adbreakbegin: AdBreakBeginEvent;
+    adbreakend: AdBreakEndEvent;
+    adbegin: AdBeginEvent;
+    adend: AdEndEvent;
+    aderror: AdErrorEvent;
+    adfirstquartile: AdFirstQuartileEvent;
+    admidpoint: AdMidpointEvent;
+    adthirdquartile: AdThirdQuartileEvent;
+    adtimeupdate: AdTimeupdateEvent;
+    adbreakstatus: AdBreakStatusEvent;
+    adclick: AdClickEvent;
+    waiting: WaitingEvent;
+    playing: PlayingEvent;
+    volumechange: VolumeChangeEvent;
+    adchannelchange: AdChannelChangeEvent;
+};
+/** Event handler type. @category Events */
+export type OptiViewAdsEventHandler<T extends OptiViewAdsEventType> = (event: OptiViewAdsEventMap[T]) => void;

package/dist/types/Events.js

@@ -0,0 +1 @@
+export{};