@svta/cml-cmcd 1.0.2 → 2.0.0

package/dist/index.d.ts

@@ -1,835 +1,1138 @@
-import { SfItem, SfToken } from "@svta/cml-structured-field-values";
-import { CmObjectType, CmStreamType, CmStreamingFormat } from "@svta/cml-cta";
-import { Request, ValueOf, ValueOrArray } from "@svta/cml-utils";
+import { SfBareItem, SfItem, SfToken } from "@svta/cml-structured-field-values";
+import { ExclusiveRecord, Request, ValueOf, ValueOrArray } from "@svta/cml-utils";
 
-//#region src/CmcdCustomKey.d.ts
+//#region src/CmcdEventType.d.ts
 
 /**
-* A custom key for CMCD. Custom keys MUST carry a hyphenated prefix
-* to ensure that there will not be a namespace collision with future
-* revisions to this specification. Clients SHOULD use a reverse-DNS
-* syntax when defining their own prefix.
+* CMCD event type for the 'br' key (bitrate change).
 *
 * @public
 */
-type CmcdCustomKey = `${string}-${string}`;
-//#endregion
-//#region src/CmcdObjectType.d.ts
+declare const CMCD_EVENT_BITRATE_CHANGE: "br";
 /**
-* Common Media Client Data Object Type
+* CMCD event type for the 'ps' key (play state change).
 *
 * @public
+*/
+declare const CMCD_EVENT_PLAY_STATE: "ps";
+/**
+* CMCD event type for the 'e' key (error).
 *
-* @enum
+* @public
 */
-declare const CmcdObjectType: typeof CmObjectType;
+declare const CMCD_EVENT_ERROR: "e";
 /**
+* CMCD event type for the 't' key (time interval).
+*
 * @public
 */
-type CmcdObjectType = CmObjectType;
-//#endregion
-//#region src/CmcdStreamType.d.ts
+declare const CMCD_EVENT_TIME_INTERVAL: "t";
 /**
-* Common Media Client Data Stream Type
+* CMCD event type for the 'c' key (content ID).
 *
+* @public
+*/
+declare const CMCD_EVENT_CONTENT_ID: "c";
+/**
+* CMCD event type for the 'b' key (backgrounded mode).
 *
-* @enum
+* @public
+*/
+declare const CMCD_EVENT_BACKGROUNDED_MODE: "b";
+/**
+* CMCD event type for the 'm' key (mute).
 *
 * @public
 */
-declare const CmcdStreamType: typeof CmStreamType;
+declare const CMCD_EVENT_MUTE: "m";
 /**
+* CMCD event type for the 'um' key (unmute).
+*
 * @public
 */
-type CmcdStreamType = CmStreamType;
-//#endregion
-//#region src/CmcdStreamingFormat.d.ts
+declare const CMCD_EVENT_UNMUTE: "um";
 /**
-* Common Media Client Data Streaming Format
+* CMCD event type for the 'pe' key (player expand).
+*
+* @public
+*/
+declare const CMCD_EVENT_PLAYER_EXPAND: "pe";
+/**
+* CMCD event type for the 'pc' key (player collapse).
 *
+* @public
+*/
+declare const CMCD_EVENT_PLAYER_COLLAPSE: "pc";
+/**
+* CMCD event type for the 'rr' key (response received).
 *
-* @enum
+* @public
+*/
+declare const CMCD_EVENT_RESPONSE_RECEIVED: "rr";
+/**
+* CMCD event type for the 'as' key (ad start).
 *
 * @public
 */
-declare const CmcdStreamingFormat: typeof CmStreamingFormat;
+declare const CMCD_EVENT_AD_START: "as";
 /**
+* CMCD event type for the 'ae' key (ad end).
+*
 * @public
 */
-type CmcdStreamingFormat = CmStreamingFormat;
-//#endregion
-//#region src/CmcdValue.d.ts
+declare const CMCD_EVENT_AD_END: "ae";
 /**
-* CMCD Value
+* CMCD event type for the 'abs' key (ad break start).
 *
 * @public
 */
-type CmcdValue = CmcdObjectType | CmcdStreamingFormat | CmcdStreamType | string | string[] | number | number[] | boolean | symbol | SfToken | SfItem | SfItem[];
-//#endregion
-//#region src/Cmcd.d.ts
+declare const CMCD_EVENT_AD_BREAK_START: "abs";
+/**
+* CMCD event type for the 'abe' key (ad break end).
+*
+* @public
+*/
+declare const CMCD_EVENT_AD_BREAK_END: "abe";
 /**
-* Common Media Client Data (CMCD) is a standardized set of HTTP request header fields and query string parameters.
+* CMCD event type for the 'sk' key (skip).
 *
-* @see {@link https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf|CMCD Spec}
+* @public
+*/
+declare const CMCD_EVENT_SKIP: "sk";
+/**
+* CMCD event type for the 'ce' key (custom event).
 *
 * @public
 */
-type Cmcd = {
-  /**
-  * Custom key names may be used, but they MUST carry a hyphenated prefix to ensure that there will not be a namespace collision
-  * with future revisions to this specification. Clients SHOULD use a reverse-DNS syntax when defining their own prefix.
-  */
-  [index: CmcdCustomKey]: CmcdValue;
-  /**
-  * Encoded bitrate
-  *
-  * The encoded bitrate of the audio or video object being requested. This may not be known precisely by the player; however,
-  * it MAY be estimated based upon playlist/manifest declarations. If the playlist declares both peak and average bitrate values,
-  * the peak value should be transmitted.
-  *
-  * Integer kbps
-  */
-  br?: number;
+declare const CMCD_EVENT_CUSTOM_EVENT: "ce";
+/**
+* CMCD event types for the 'e' key (event mode).
+*
+*
+* @enum
+*
+* @public
+*/
+declare const CmcdEventType: {
   /**
-  * Object duration
-  *
-  * The playback duration in milliseconds of the object being requested. If a partial segment is being requested, then this value
-  * MUST indicate the playback duration of that part and not that of its parent segment. This value can be an approximation of the
-  * estimated duration if the explicit value is not known.
-  *
-  * Integer milliseconds
+  * A change in the bitrate.
   */
-  d?: number;
+  readonly BITRATE_CHANGE: typeof CMCD_EVENT_BITRATE_CHANGE;
   /**
-  * Object type
-  *
-  * The media type of the current object being requested:
-  * - `m` = text file, such as a manifest or playlist
-  * - `a` = audio only
-  * - `v` = video only
-  * - `av` = muxed audio and video
-  * - `i` = init segment
-  * - `c` = caption or subtitle
-  * - `tt` = ISOBMFF timed text track
-  * - `k` = cryptographic key, license or certificate.
-  * - `o` = other
-  *
-  * If the object type being requested is unknown, then this key MUST NOT be used.
+  * A change in the player state.
   */
-  ot?: CmcdObjectType;
+  readonly PLAY_STATE: typeof CMCD_EVENT_PLAY_STATE;
   /**
-  * Top bitrate
-  *
-  * The highest bitrate rendition in the manifest or playlist that the client is allowed to play, given current codec, licensing and
-  * sizing constraints.
-  *
-  * Integer Kbps
+  * An error event.
   */
-  tb?: number;
+  readonly ERROR: typeof CMCD_EVENT_ERROR;
   /**
-  * Buffer length
-  *
-  * The buffer length associated with the media object being requested. This value MUST be rounded to the nearest 100 ms. This key SHOULD only be
-  * sent with an object type of ‘a’, ‘v’ or ‘av’.
-  *
-  * Integer milliseconds
+  * A periodic report sent on a time interval.
   */
-  bl?: number;
+  readonly TIME_INTERVAL: typeof CMCD_EVENT_TIME_INTERVAL;
   /**
-  * Deadline
-  *
-  * Deadline from the request time until the first sample of this Segment/Object needs to be available in order to not create a buffer underrun or
-  * any other playback problems. This value MUST be rounded to the nearest 100ms. For a playback rate of 1, this may be equivalent to the player’s
-  * remaining buffer length.
-  *
-  * Integer milliseconds
+  * A change of the content ID.
   */
-  dl?: number;
+  readonly CONTENT_ID: typeof CMCD_EVENT_CONTENT_ID;
   /**
-  * Measured mtp CMCD throughput
-  *
-  * The throughput between client and server, as measured by the client and MUST be rounded to the nearest 100 kbps. This value, however derived,
-  * SHOULD be the value that the client is using to make its next Adaptive Bitrate switching decision. If the client is connected to multiple
-  * servers concurrently, it must take care to report only the throughput measured against the receiving server. If the client has multiple concurrent
-  * connections to the server, then the intent is that this value communicates the aggregate throughput the client sees across all those connections.
-  *
-  * Integer kbps
+  * A change in the application's backgrounded state.
   */
-  mtp?: number;
+  readonly BACKGROUNDED_MODE: typeof CMCD_EVENT_BACKGROUNDED_MODE;
   /**
-  * Next object request
-  *
-  * Relative path of the next object to be requested. This can be used to trigger pre-fetching by the CDN. This MUST be a path relative to the current
-  * request. This string MUST be URLEncoded. The client SHOULD NOT depend upon any pre-fetch action being taken - it is merely a request for such a
-  * pre-fetch to take place.
-  *
-  * String
+  * The player was muted.
   */
-  nor?: ValueOrArray<string | SfItem>;
+  readonly MUTE: typeof CMCD_EVENT_MUTE;
   /**
-  * Next range request
-  *
-  * If the next request will be a partial object request, then this string denotes the byte range to be requested. If the ‘nor’ field is not set, then the
-  * object is assumed to match the object currently being requested. The client SHOULD NOT depend upon any pre-fetch action being taken – it is merely a
-  * request for such a pre-fetch to take place. Formatting is similar to the HTTP Range header, except that the unit MUST be ‘byte’, the ‘Range:’ prefix is
-  * NOT required and specifying multiple ranges is NOT allowed. Valid combinations are:
-  *
-  * - `"\<range-start\>-"`
-  * - `"\<range-start\>-\<range-end\>"`
-  * - `"-\<suffix-length\>"`
-  *
-  * String
+  * Player unmuted.
   */
-  nrr?: string;
+  readonly UNMUTE: typeof CMCD_EVENT_UNMUTE;
   /**
-  * Startup
-  *
-  * Key is included without a value if the object is needed urgently due to startup, seeking or recovery after a buffer-empty event. The media SHOULD not be
-  * rendering when this request is made. This key MUST not be sent if it is FALSE.
-  *
-  * Boolean
+  * The player view was expanded.
   */
-  su?: boolean;
+  readonly PLAYER_EXPAND: typeof CMCD_EVENT_PLAYER_EXPAND;
   /**
-  * Content ID
-  *
-  * A unique string identifying the current content. Maximum length is 64 characters. This value is consistent across multiple different
-  * sessions and devices and is defined and updated at the discretion of the service provider.
-  *
-  * String
+  * The player view was collapsed.
   */
-  cid?: string;
+  readonly PLAYER_COLLAPSE: typeof CMCD_EVENT_PLAYER_COLLAPSE;
   /**
-  * Playback rate
-  *
-  * `1` if real-time, `2` if double speed, `0` if not playing. SHOULD only be sent if not equal to `1`.
-  *
-  * Decimal
+  * The receipt of a response.
   */
-  pr?: number;
+  readonly RESPONSE_RECEIVED: typeof CMCD_EVENT_RESPONSE_RECEIVED;
   /**
-  * Streaming format
-  *
-  * The streaming format that defines the current request.
-  *
-  * - `d` = MPEG DASH
-  * - `h` = HTTP Live Streaming (HLS)
-  * - `s` = Smooth Streaming
-  * - `o` = other
-  *
-  * If the streaming format being requested is unknown, then this key MUST NOT be used.
+  * The start of an ad.
   */
-  sf?: CmcdStreamingFormat;
+  readonly AD_START: typeof CMCD_EVENT_AD_START;
   /**
-  * Session ID
-  *
-  * A GUID identifying the current playback session. A playback session typically ties together segments belonging to a single media asset.
-  * Maximum length is 64 characters. It is RECOMMENDED to conform to the UUID specification.
-  *
-  * String
+  * The end of an ad.
   */
-  sid?: string;
+  readonly AD_END: typeof CMCD_EVENT_AD_END;
   /**
-  * Stream type
-  * - `v` = all segments are available – e.g., VOD
-  * - `l` = segments become available over time – e.g., LIVE
+  * The start of an ad break.
   */
-  st?: CmcdStreamType;
+  readonly AD_BREAK_START: typeof CMCD_EVENT_AD_BREAK_START;
   /**
-  * CMCD version
-  *
-  * The version of this specification used for interpreting the defined key names and values. If this key is omitted, the client and server MUST
-  * interpret the values as being defined by version 1. Client SHOULD omit this field if the version is 1.
-  *
-  * Integer
+  * The end of an ad break.
   */
-  v?: number;
+  readonly AD_BREAK_END: typeof CMCD_EVENT_AD_BREAK_END;
   /**
-  * Buffer starvation
-  *
-  * Key is included without a value if the buffer was starved at some point between the prior request and this object request,
-  * resulting in the player being in a rebuffering state and the video or audio playback being stalled. This key MUST NOT be
-  * sent if the buffer was not starved since the prior request.
-  *
-  * If the object type `ot` key is sent along with this key, then the `bs` key refers to the buffer associated with the particular
-  * object type. If no object type is communicated, then the buffer state applies to the current session.
-  *
-  * Boolean
+  * The user skipped an ad.
   */
-  bs?: boolean;
+  readonly SKIP: typeof CMCD_EVENT_SKIP;
   /**
-  * Requested maximum throughput
-  *
-  * The requested maximum throughput that the client considers sufficient for delivery of the asset. Values MUST be rounded to the
-  * nearest 100kbps. For example, a client would indicate that the current segment, encoded at 2Mbps, is to be delivered at no more
-  * than 10Mbps, by using rtp=10000.
-  *
-  * Note: This can benefit clients by preventing buffer saturation through over-delivery and can also deliver a community benefit
-  * through fair-share delivery. The concept is that each client receives the throughput necessary for great performance, but no more.
-  * The CDN may not support the rtp feature.
-  *
-  * Integer kbps
+  * A custom event.
   */
-  rtp?: number;
+  readonly CUSTOM_EVENT: typeof CMCD_EVENT_CUSTOM_EVENT;
 };
+/**
+* @public
+*/
+type CmcdEventType = ValueOf<typeof CmcdEventType>;
 //#endregion
-//#region src/CMCD_EVENT_MODE.d.ts
+//#region src/CmcdCustomKey.d.ts
 /**
-* CMCD event mode variable name.
+* A custom key for CMCD. Custom keys MUST carry a hyphenated prefix
+* to ensure that there will not be a namespace collision with future
+* revisions to this specification. Clients SHOULD use a reverse-DNS
+* syntax when defining their own prefix.
 *
 * @public
 */
-declare const CMCD_EVENT_MODE = "event";
+type CmcdCustomKey = `${string}-${string}`;
 //#endregion
-//#region src/CMCD_REQUEST_MODE.d.ts
+//#region src/CmcdCustomValue.d.ts
 /**
-* CMCD request mode variable name.
+* A value type for custom CMCD keys.
 *
 * @public
 */
-declare const CMCD_REQUEST_MODE = "request";
+type CmcdCustomValue = string | SfItem<string> | (string | SfItem<string>)[] | number | SfItem<number> | (number | SfItem<number>)[] | boolean | SfItem<boolean> | (boolean | SfItem<boolean>)[] | symbol | SfItem<symbol> | (symbol | SfItem<symbol>)[] | SfToken | SfItem<SfToken> | (SfToken | SfItem<SfToken>)[];
 //#endregion
-//#region src/CmcdReportingMode.d.ts
+//#region src/CmcdObjectType.d.ts
 /**
-* CMCD reporting mode types.
+* Common Media Client Data Object Type
 *
+* @public
 *
 * @enum
-*
-* @public
 */
-declare const CmcdReportingMode: {
+declare const CmcdObjectType: {
   /**
-  * Request mode
+  * text file, such as a manifest or playlist
   */
-  readonly REQUEST: typeof CMCD_REQUEST_MODE;
+  readonly MANIFEST: "m";
   /**
-  * Event mode
+  * audio only
   */
-  readonly EVENT: typeof CMCD_EVENT_MODE;
-};
-/**
-* @public
-*/
-type CmcdReportingMode = ValueOf<typeof CmcdReportingMode>;
-//#endregion
-//#region src/CmcdFormatterOptions.d.ts
-/**
-* Options for formatting CMCD data values.
-*
-* @public
-*/
-type CmcdFormatterOptions = {
+  readonly AUDIO: "a";
   /**
-  * The version of the CMCD specification to use.
+  * video only
   */
-  version: number;
+  readonly VIDEO: "v";
   /**
-  * The reporting mode to use.
+  * muxed audio and video
   */
-  reportingMode: CmcdReportingMode;
+  readonly MUXED: "av";
   /**
-  * The base URL to use for relative URLs.
+  * init segment
   */
-  baseUrl?: string;
+  readonly INIT: "i";
+  /**
+  * caption or subtitle
+  */
+  readonly CAPTION: "c";
+  /**
+  * ISOBMFF timed text track
+  */
+  readonly TIMED_TEXT: "tt";
+  /**
+  * cryptographic key, license or certificate.
+  */
+  readonly KEY: "k";
+  /**
+  * other
+  */
+  readonly OTHER: "o";
 };
-//#endregion
-//#region src/CmcdFormatter.d.ts
 /**
-* A formatter for CMCD values.
-*
-* @param value - The value to format.
-*
-* @returns The formatted value.
-*
 * @public
 */
-type CmcdFormatter = (value: CmcdValue, options: CmcdFormatterOptions) => number | ValueOrArray<string> | ValueOrArray<SfItem>;
+type CmcdObjectType = ValueOf<typeof CmcdObjectType>;
 //#endregion
-//#region src/CmcdEventExcludedKeys.d.ts
+//#region src/CmcdObjectTypeList.d.ts
 /**
-* Keys that are excluded from CMCD event mode.
+* A numeric list with an optional object type boolean flag.
 *
 * @public
 */
-type CmcdEventExcludedKeys = "bsd" | "d" | "dl" | "nor" | "ot" | "rtp" | "sid" | "su";
+type CmcdObjectTypeList = (number | SfItem<number, ExclusiveRecord<CmcdObjectType, boolean>>)[];
 //#endregion
-//#region src/CmcdEventType.d.ts
+//#region src/CmcdPlayerState.d.ts
 /**
-* CMCD event types for the 'e' key (event mode).
+* CMCD v2 player states for the 'sta' key.
 *
 *
 * @enum
 *
 * @public
 */
-declare const CmcdEventType: {
+declare const CmcdPlayerState: {
   /**
-  * A change in the player state.
+  * Starting: Initial startup of the player.
   */
-  readonly PLAY_STATE: "ps";
+  readonly STARTING: "s";
   /**
-  * An error event.
+  * Playing: The player is actively rendering content.
   */
-  readonly ERROR: "e";
+  readonly PLAYING: "p";
   /**
-  * A periodic report sent on a time interval.
+  * Seeking: The player is seeking to a new position.
   */
-  readonly TIME_INTERVAL: "t";
+  readonly SEEKING: "k";
   /**
-  * A change of the content ID.
+  * Rebuffering: The player is buffering data during playback.
   */
-  readonly CONTENT_ID: "c";
+  readonly REBUFFERING: "r";
   /**
-  * A change in the application's backgrounded state.
+  * Paused: The player is paused.
   */
-  readonly BACKGROUNDED_MODE: "b";
+  readonly PAUSED: "a";
   /**
-  * The player was muted.
+  * Waiting: The player is waiting for a user action or another event.
   */
-  readonly MUTE: "m";
+  readonly WAITING: "w";
   /**
-  * Player unmuted.
+  * Ended: The media has finished playing.
   */
-  readonly UNMUTE: "um";
+  readonly ENDED: "e";
   /**
-  * The player view was expanded.
+  * Fatal Error: The player has encountered a fatal error.
   */
-  readonly PLAYER_EXPAND: "pe";
+  readonly FATAL_ERROR: "f";
   /**
-  * The player view was collapsed.
+  * Quit: User initiated end of playback before media asset completion.
   */
-  readonly PLAYER_COLLAPSE: "pc";
+  readonly QUIT: "q";
   /**
-  * The receipt of a response.
+  * Preloading: The player is loading assets ahead of starting in order to provide a fast startup. The expectation is that playback will commence at a future time.
   */
-  readonly RESPONSE_RECEIVED: "rr";
+  readonly PRELOADING: "d";
 };
 /**
 * @public
 */
-type CmcdEventType = ValueOf<typeof CmcdEventType>;
+type CmcdPlayerState = ValueOf<typeof CmcdPlayerState>;
 //#endregion
-//#region src/CmcdPlayerState.d.ts
+//#region src/CmcdStreamType.d.ts
 /**
-* CMCD v2 player states for the 'sta' key.
+* Common Media Client Data Stream Type
 *
 *
 * @enum
 *
 * @public
 */
-declare const CmcdPlayerState: {
-  /**
-  * Starting: Initial startup of the player.
-  */
-  readonly STARTING: "s";
+declare const CmcdStreamType: {
   /**
-  * Playing: The player is actively rendering content.
+  *  All segments are available – e.g., VOD
   */
-  readonly PLAYING: "p";
+  readonly VOD: "v";
   /**
-  * Seeking: The player is seeking to a new position.
+  * Segments become available over time – e.g., LIVE
   */
-  readonly SEEKING: "k";
+  readonly LIVE: "l";
   /**
-  * Rebuffering: The player is buffering data during playback.
+  * Low latency stream
   */
-  readonly REBUFFERING: "r";
-  /**
-  * Paused: The player is paused.
-  */
-  readonly PAUSED: "a";
+  readonly LOW_LATENCY: "ll";
+};
+/**
+* @public
+*/
+type CmcdStreamType = ValueOf<typeof CmcdStreamType>;
+//#endregion
+//#region src/CmcdStreamingFormat.d.ts
+/**
+* Common Media Client Data Streaming Format
+*
+*
+* @enum
+*
+* @public
+*/
+declare const CmcdStreamingFormat: {
   /**
-  * Waiting: The player is waiting for a user action or another event.
+  * MPEG DASH
   */
-  readonly WAITING: "w";
+  readonly DASH: "d";
   /**
-  * Ended: The media has finished playing.
+  * HTTP Live Streaming (HLS)
   */
-  readonly ENDED: "e";
+  readonly HLS: "h";
   /**
-  * Fatal Error: The player has encountered a fatal error.
+  * Smooth Streaming
   */
-  readonly FATAL_ERROR: "f";
+  readonly SMOOTH: "s";
   /**
-  * Quit: User initiated end of playback before media asset completion.
+  * Other
   */
-  readonly QUIT: "q";
-  /**
-  * Preloading: The player is loading assets ahead of starting in order to provide a fast startup. The expectation is that playback will commence at a future time.
-  */
-  readonly PRELOADING: "d";
+  readonly OTHER: "o";
 };
 /**
 * @public
 */
-type CmcdPlayerState = ValueOf<typeof CmcdPlayerState>;
+type CmcdStreamingFormat = ValueOf<typeof CmcdStreamingFormat>;
 //#endregion
 //#region src/CmcdRequest.d.ts
 /**
-* Common Media Client Data (CMCD) is a standardized set of HTTP request header fields and query string parameters.
+* Common Media Client Data (CMCD) version 2 - Request Mode.
+*
+* A standardized set of HTTP request header fields and query string parameters
+* for communicating media playback metrics in request mode.
+*
+* @see {@link https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf|CMCD v1 Spec}
 *
 * @public
 */
-type CmcdRequest = Omit<Cmcd, "nrr"> & {
+type CmcdRequest = {
+  /**
+  * Custom key names may be used, but they MUST carry a hyphenated prefix to ensure that there will not be a namespace collision
+  * with future revisions to this specification. Clients SHOULD use a reverse-DNS syntax when defining their own prefix.
+  */
+  [index: CmcdCustomKey]: CmcdCustomValue | undefined;
   /**
   * Aggregate encoded bitrate
   *
-  * The aggregate encoded bitrate of the complete media object including all object types. This SHOULD be derived from
-  * playlist/manifest declarations, or it MAY be estimated by the player. If the playlist declares both peak and average bitrate values,
-  * the peak value MUST be transmitted. This value MUST NOT be sent for objects which do not have an object type of 'a', 'v', 'av' or 'o'.
-  * This value MUST NOT be sent if the encoded bitrate is known.
+  * The aggregate encoded bitrate across a playable combination of tracks. This metric SHOULD NOT be used when the individual bitrates
+  * of the tracks are known. This value SHOULD be derived from a playlist/manifest declaration, or it MAY be estimated by the player.
+  * If the playlist declares both peak and average bitrate values, the peak value MUST be transmitted. This value MUST NOT be sent if
+  * the encoded bitrate is known.
   *
-  * Integer kbps
+  * Inner list of integer kbps with token identifiers
   */
-  ab?: number;
+  ab?: CmcdObjectTypeList;
   /**
-  * Target buffer length (ms)
+  * Backgrounded
   *
-  * The target buffer length associated with the media object being requested at the time of the request.
-  * This value SHOULD be rounded to the nearest 100 ms. This value MUST NOT be sent for objects which do not have an object
-  * type of 'a', 'v', 'av', 'tt', 'c', or 'o'
+  * All players in a session are currently in a state that is not visible to the user due to a user interaction. This key SHOULD only
+  * be sent if it is TRUE. If the visibility state of the player is not known this key SHOULD NOT be reported.
   *
-  * Integer milliseconds
+  * Boolean
+  */
+  bg?: boolean;
+  /**
+  * Buffer length
+  *
+  * The buffer length associated with the media object being requested. This value SHOULD be rounded to the nearest 100 ms.
+  *
+  * Inner list of integer milliseconds with token identifiers
   */
-  tbl?: number;
+  bl?: CmcdObjectTypeList;
   /**
-  * CDN ID (string, max 128 chars)
+  * Encoded bitrate
   *
-  * A string identifying the current delivery network from which the player is retrieving content. Maximum length is 128 characters
+  * The encoded bitrate. In request mode, this refers to the encoded bitrate of the requested representation.
+  * In event mode this refers to the encoded bitrate of the currently selected representation.
+  * This SHOULD be derived from playlist/manifest declarations, or it MAY be estimated by the player.
+  * If the playlist declares both peak and average bitrate values, the peak value MUST be transmitted.
+  *
+  * Inner list of integer kbps with token identifiers
+  */
+  br?: CmcdObjectTypeList;
+  /**
+  * Buffer starvation
+  *
+  * TRUE if the player buffer was starved at some point between the prior report and this report per reporting destination, resulting in
+  * the player entering a rebuffering state or remaining in a rebuffering state. Note that if the player begins requesting data from a
+  * new CDN, then this key might initially report buffering caused by the prior CDN. This key SHOULD NOT be reported if it is FALSE.
+  *
+  * Boolean
+  */
+  bs?: boolean;
+  /**
+  * Buffer Starvation Absolute
+  *
+  * An absolute count of buffer starvation events since session initiation. A buffer starvation event occurs when the state changes
+  * to rebuffering. Token identifier MAY be omitted if the cause of the rebuffering is unknown.
+  *
+  * Inner list of integers with optional token identifiers
+  */
+  bsa?: CmcdObjectTypeList;
+  /**
+  * Buffer Starvation Duration
+  *
+  * A list of durations of each buffer starvation period reported once the rebuffering has completed. This value MUST only be reported
+  * once per reporting mode and report destination. Token identifier MAY be omitted if the cause of the rebuffering is unknown.
+  *
+  * Inner list of integer milliseconds with optional token identifiers
+  */
+  bsd?: CmcdObjectTypeList;
+  /**
+  * Buffer Starvation Duration Absolute
+  *
+  * An absolute count of buffer starvation duration since session initiation. Token identifier MAY be omitted if the cause of the
+  * rebuffering is unknown.
+  *
+  * Inner list of integer milliseconds with optional token identifiers
+  */
+  bsda?: CmcdObjectTypeList;
+  /**
+  * CDN ID
+  *
+  * A string identifying the current delivery network from which the player is retrieving content. Maximum length is 128 characters.
   *
   * String
   */
   cdn?: string;
   /**
-  * Live stream latency (ms)
+  * Content ID
   *
-  * The time delta between when a given media timestamp was made available at the origin and when it was rendered by the client.
-  * The accuracy of this estimate is dependent on synchronization between the packager and the player clocks.
+  * A unique string identifying the current content. The maximum length is 128 characters. This value is consistent across multiple different
+  * sessions and devices and is defined and updated at the discretion of the service provider.
   *
-  * Integer Milliseconds
+  * String
   */
-  ltc?: number;
+  cid?: string;
   /**
-  * Backgrounded (all players in session not visible, boolean)
+  * Content Signature
   *
-  * All players in a session are currently in a state that is not visible to the user.
-  * This key SHOULD only be sent if it is TRUE.
-  * If the visibility state of the player is not known this key SHOULD NOT be reported
+  * A string representing a signature of the content being played. This field SHOULD vary with content ID and be bound by some mechanism
+  * to the content. For example, this field may be used to transmit the C2PA signature associated with the content being viewed.
   *
-  * Bool
+  * String
   */
-  bg?: boolean;
+  cs?: string;
   /**
-  * State (player state, e.g. "s", "p", etc.)
+  * Object duration
   *
-  * A token describing the current playback state of the player as perceived by the end user, one of:
-  * s - starting: the player has been instructed to play media for a given session, either by a user interaction or by an autoplay action.
-  * p - playing : Media is being rendered.
-  * k - seeking : The start of the user initiated action of moving the playhead position.
-  * r - rebuffering : Media has stopped being rendered due to an insufficient buffer. This state is not reported during startup or seeking.
-  * a - paused : Playback has been intentionally paused by the user.
-  * w - waiting : Playback has been paused by the player.
-  * e - ended : Rendering has ended due to completion of the media asset playback.
-  * f - fatal error : Rendering has ended due to an irrecoverable error.
-  * q - quit : User initiated end of playback before media asset completion.
-  * d - preloading : the player is loading assets ahead of starting in order to provide a fast startup. The expectation is that playback will commence at a future time.
-  *
-  * Note: if used with Request Mode or Response Mode, then this key represents a snapshot of the state at request time, which may obscure prior state changes since the last request.
-  * For most accurate state tracking in players, use State-Interval mode.
-  * The addition of a timestamp in Request Mode might be useful in correctly placing the state change on a timeline.
-  *
-  * Token - one of [s,p,k,r,a,w,e,f,q,d]
+  * The playback duration in milliseconds of the object being requested. If a partial segment is being requested,
+  * then this value MUST indicate the playback duration of that part and not that of its parent segment.
+  * This value can be an approximation of the estimated duration if the explicit value is not known.
+  * This value MUST NOT be sent for objects which do not have an object type of 'a', 'v', 'av', 'tt', 'c', or 'o'.
+  *
+  * Integer milliseconds
   */
-  sta?: CmcdPlayerState;
+  d?: number;
   /**
-  * The encoded bitrate of the audio or video object being shown to the end user.
+  * Dropped Frames Absolute
   *
-  * Integer Kbps
+  * An absolute count of dropped frames since session initiation. This key SHOULD only be sent for content types of 'v', 'av' or 'o'.
+  * Note that this value will be driven by the content being rendered rather than the content being retrieved, therefore it is
+  * beneficial if accompanied by the playhead time 'pt' key to allow for correct interpretation.
+  *
+  * Integer
   */
-  pb?: number;
+  dfa?: number;
   /**
-  * Timestamp (ms since UNIX epoch, required for event mode)
+  * Deadline
   *
-  * The timestamp at which the associated event occurred, expressed as milliseconds since the UNIX epoch.
-  * When the event is a request for a media object the time SHOULD reference when the request was first initiated.
-  * When used with Response Mode, the timestamp should indicate the time at which the object was first requested and not when it was received.
+  * Deadline from the request time until the first sample of this Segment/Object needs to be available in order to not create a buffer underrun
+  * or any other playback problems. This value MUST be rounded to the nearest 100ms. For a playback rate of 1, this may be equivalent to the
+  * player's remaining buffer length.
   *
   * Integer milliseconds
   */
-  ts?: number;
+  dl?: number;
   /**
-  * Top playable bitrate (kbps)
+  * Player Error Code
   *
-  * The highest bitrate rendition that the player is currently capable of playing for reasons other than bandwidth limitations.
-  * This key captures the cases in which, for example, screen resolution, DRM, or performance constraints limit the player's topmost choice of bitrate.
-  * These constraints are intentionally obfuscated for privacy reasons.
-  * This key can increase the fingerprinting surface exposed by CMCD transmission and SHOULD NOT be transmitted in a default player configuration.
+  * A string defining an error code produced by the player. The namespace and formatting of this error code is left to the application.
   *
-  * If the playlist declares both peak and average bitrate values, the peak value MUST be transmitted.
-  * This top playable bitrate MUST apply to the object type being requested.
-  * Requests for video objects MUST specify the top playable video bitrate and requests for audio objects MUST specify the top playable audio bitrate.
-  * This value MUST NOT be sent for objects which do not have an object type of 'a', 'v', 'av' or 'c'.
+  * Even if only one error code is being specified, the list notation MUST still be used.
   *
-  * Integer Kbps
+  * Inner list of strings
   */
-  tpb?: number;
+  ec?: string[];
   /**
-  * Lowest encoded bitrate (kbps)
+  * Lowest aggregated encoded bitrate
   *
-  * The lowest bitrate rendition in the manifest or playlist.
-  * This SHOULD be derived from playlist/manifest declarations, or it MAY be estimated by the player.
-  * If the playlist declares both peak and average bitrate values, the peak value MUST be transmitted.
-  * This lowest bitrate MUST apply to the object type being requested.
-  * Requests for video objects MUST specify the lowest video bitrate and requests for audio objects MUST specify the lowest audio bitrate.
-  * This value MUST NOT be sent for objects which do not have an object type of 'a', 'v', 'av' or 'c'.
+  * The lowest aggregated bitrate rendition in the manifest or playlist. This SHOULD be derived from playlist/manifest declarations,
+  * or it MAY be estimated by the player. If the playlist declares both peak and average bitrate values, the peak value MUST be
+  * transmitted. The aggregate encoded bitrate is of the complete media object including all object types. This value MUST NOT be
+  * sent if the lowest encoded bitrate is known.
   *
-  * Integer Kbps
+  * Inner list of integer kbps with token identifiers
   */
-  lb?: number;
+  lab?: CmcdObjectTypeList;
   /**
-  * Top aggregated encoded bitrate (kbps)
+  * Lowest encoded bitrate
   *
-  * The highest aggregated bitrate rendition in the manifest or playlist.
-  * This SHOULD be derived from playlist/manifest declarations, or it MAY be estimated by the player.
-  * If the playlist declares both peak and average bitrate values,the peak value MUST be transmitted.
-  * The aggregate encoded bitrate is of the complete media object including all object types.
-  * This value MUST NOT be sent for objects which do not have an object type of 'a', 'v', 'av' or 'c'.
-  * This value MUST NOT be sent if the top encoded bitrate is known
+  * The lowest bitrate rendition in the manifest or playlist. This SHOULD be derived from playlist/manifest declarations, or it MAY be
+  * estimated by the player. If the playlist declares both peak and average bitrate values, the peak value MUST be transmitted. This
+  * lowest bitrate MUST apply to the object type being requested. Requests for video objects MUST specify the lowest video bitrate and
+  * requests for audio objects MUST specify the lowest audio bitrate.
   *
-  * Integer Kbps
+  * Inner list of integer kbps with token identifiers
   */
-  tab?: number;
+  lb?: CmcdObjectTypeList;
   /**
-  * Lowest aggregated encoded bitrate (kbps)
+  * Live stream latency
   *
-  * The lowest aggregated bitrate rendition in the manifest or playlist.
-  * This SHOULD be derived from playlist/manifest declarations, or it MAY be estimated by the player.
-  * If the playlist declares both peak and average bitrate values, the peak value MUST be transmitted.
-  * The aggregate encoded bitrate is of the complete media object including all object types.
-  * This value MUST NOT be sent for objects which do not have an object type of 'a', 'v', 'av' or 'c'.
-  * This value MUST NOT be sent if the lowest encoded bitrate is known.
+  * The time delta between when a given media timestamp was made available at the origin and when it was rendered by the player. The
+  * accuracy of this estimate is dependent on synchronization between the packager and the player clocks.
   *
-  * Integer Kbps
+  * Integer milliseconds
+  */
+  ltc?: number;
+  /**
+  * Media Start Delay
+  *
+  * Measures the initial delay in wall-clock time from when a player is instructed to play media for a given session to when any media
+  * begins playback, whether it be primary content or interstitial content. This value SHOULD be the time difference between the
+  * "starting" and "playing" states.
+  *
+  * This key MUST only be sent once per Session ID and MUST be sent for each reporting mode which is active within the player.
+  *
+  * Integer milliseconds
+  */
+  msd?: number;
+  /**
+  * Measured throughput
+  *
+  * The throughput between player and server, as measured by the player. Throughput MUST be rounded to the nearest 100 kbps. This value, however
+  * derived, SHOULD be the value that the player is using to make its next Adaptive Bitrate switching decision. If the player is requesting
+  * different object types from different providers then it SHOULD take care to match the throughput measured against that provider with each
+  * object type request. It is acceptable to report aggregate information if objects of the same type are requested from different providers.
+  * If the player has multiple concurrent connections to the provider, then the intent is that this value communicates the aggregate throughput
+  * the player sees across all those connections. If this key is sent on an interval report, the value transmitted should be the last throughput
+  * estimate made by the player prior to making the report. There is no requirement for the player to calculate the average measured throughput
+  * since the prior interval report.
+  *
+  * Inner list of integer kbps with token identifiers
+  */
+  mtp?: CmcdObjectTypeList;
+  /**
+  * Next object request
+  *
+  * The relative path, as defined by RFC 3986, to one or more objects which can reasonably be expected to be requested by the player making
+  * the current request. Each object SHOULD be fetched in its entirety unless there is a range associated with the future request. Even if
+  * only one object is being specified, the list notation MUST still be used. If there is a range associated with the future request, then
+  * the range is communicated as the parameter 'r' with a String value. The formatting of the String value is similar to the HTTP Range
+  * header, except that the unit MUST be 'byte', the 'Range:' prefix is NOT permitted, specifying multiple ranges is NOT allowed and the
+  * only valid combinations are:
+  *
+  * - `"<range-start>-"`
+  * - `"<range-start>-<range-end>"`
+  * - `"-<suffix-length>"`
+  *
+  * The player SHOULD NOT depend upon any pre-fetch action being taken - it is merely a request for such a pre-fetch to take place.
+  *
+  * Inner list of strings
+  */
+  nor?: (string | SfItem<string, {
+    r: string;
+  }>)[];
+  /**
+  * Non rendered
+  *
+  * True when the content being retrieved by a player is not rendered as audio or video. The key SHOULD only be sent when it is TRUE.
+  *
+  * Boolean
+  */
+  nr?: boolean;
+  /**
+  * Object type
+  *
+  * The media type of the current object being requested:
+  * - `m` = text file, such as a manifest or playlist
+  * - `a` = audio only
+  * - `v` = video only
+  * - `av` = muxed audio and video
+  * - `i` = init segment
+  * - `c` = caption or subtitle
+  * - `tt` = ISOBMFF timed text track
+  * - `k` = cryptographic key, license or certificate.
+  * - `o` = other
+  *
+  * If the object type being requested is unknown, then this key MUST NOT be used.
+  *
+  * This key is also used as a token parameter for other keys.
+  *
+  * Token
+  */
+  ot?: CmcdObjectType;
+  /**
+  * Playhead bitrate
+  *
+  * The encoded bitrate of the media object(s) being shown to the end user.
+  *
+  * Inner list of integer kbps with token identifiers
   */
-  lab?: number;
+  pb?: CmcdObjectTypeList;
   /**
-  * Playhead time (ms)
+  * Playback rate
+  *
+  * 1.0 if real-time, 2.0 if double speed, 0 if not playing. SHOULD only be sent if not equal to 1.0.
+  *
+  * Decimal
+  */
+  pr?: number;
+  /**
+  * Playhead time
   *
   * The playhead time, expressed in milliseconds, which is being rendered to the viewer when the report is made.
-  * For Response and State-Interval modes, this corresponds to the playhead time that was rendered at the wallclock time reported by the timestamp field.
   *
   * Integer milliseconds
   */
   pt?: number;
   /**
-  * Error code(s), application-defined
+  * Requested maximum throughput
   *
-  * A string defining an error code produced by the player.
-  * The namespace and formatting of this error code is left to the application.
-  * Use of standardized error codes is recommended.
-  * Errors should be buffered per report destination as they occur and reported along with the next CMCD report.
-  * With Event mode there is the option to report errors as they occur.
+  * The requested maximum throughput that the player considers sufficient for delivery of the asset. Values MUST be rounded to the
+  * nearest 100kbps.
   *
-  * An Inner List of Strings
+  * Integer kbps
   */
-  ec?: string | string[];
+  rtp?: number;
   /**
-  * Media Start Delay (ms)
+  * Streaming format
   *
-  * Measures the initial delay in wall-clock time from when a player is instructed to play media for a given session to when any media begins playback,
-  * whether it be primary content or interstitial content.
-  * This value SHOULD be the time difference between the "starting" and "playing" states.
-  * This key MUST only be sent once per Session ID and MUST be sent for each reporting mode which is active within the player.
-  * For request and response reporting modes, this key SHOULD be sent on the next media object request following successful startup.
+  * The streaming format that defines the current request.
   *
-  * Integer milliseconds
+  * - `d` = MPEG DASH
+  * - `h` = HTTP Live Streaming (HLS)
+  * - `e` = HESP
+  * - `s` = Smooth Streaming
+  * - `o` = other
+  *
+  * Token
   */
-  msd?: number;
+  sf?: CmcdStreamingFormat;
+  /**
+  * Session ID
+  *
+  * A GUID identifying the current playback session. A playback session typically consists of the playback of a single media asset along
+  * with accompanying content such as advertisements. This session may comprise the playback of primary content combined with interstitial
+  * content. This session is being played on a single device. The maximum length is 64 characters. It is RECOMMENDED to conform to the
+  * UUID specification.
+  *
+  * String
+  */
+  sid?: string;
   /**
   * Sequence Number
   *
-  * A monotonically increasing integer to identify the sequence of a CMCD report to a target within a session. This MUST be reset to zero on the start of
-  * a new session-id. Sequence numbers increase independently per each combination of mode and target.
+  * A monotonically increasing integer to identify the sequence of a CMCD report to a target within a session. This MUST be reset to
+  * zero on the start of a new session-id. Sequence numbers increase independently per each combination of mode and target.
   *
   * Integer
   */
   sn?: number;
   /**
-  * Buffer starvation duration
+  * Stream type
   *
-  * Duration of the latest rebuffering period reported once the rebuffering has completed. This value MUST only be reported once per rebuffering incident, per object type.
+  * - `v` = all segments are available - e.g., VOD
+  * - `l` = segments become available over time - e.g., LIVE
+  * - `ll` = low latency LIVE
   *
-  * If the object type 'ot' key is sent along with this key, then the 'bsd' key refers to the buffer associated with the particular object type. If no object type is communicated, then the buffer state applies to the current session.
+  * Token
+  */
+  st?: CmcdStreamType;
+  /**
+  * State
   *
-  * Integer milliseconds
+  * A token describing the current playback state of the player as perceived by the end user, one of:
+  *
+  * - `s` - starting: the player has been instructed to play media for a given session, either by a user interaction or by an autoplay action.
+  * - `p` - playing: Media is being rendered.
+  * - `k` - seeking: The start of the action of moving the playhead position after starting.
+  * - `r` - rebuffering: Media has stopped being rendered due to an insufficient buffer. This state is not reported during startup or seeking.
+  * - `a` - paused: Playback has been intentionally paused by either the user or the player.
+  * - `e` - ended: Rendering has ended due to completion of the media asset playback.
+  * - `f` - fatal error: Rendering has ended due to an irrecoverable error.
+  * - `q` - quit: User initiated end of playback before media asset completion.
+  * - `d` - preloading: the player is loading, or has loaded, assets ahead of starting in order to provide a fast startup. The expectation is that playback will commence at a future time.
+  *
+  * Token - one of [s,p,k,r,a,e,f,q,d]
   */
-  bsd?: number;
+  sta?: CmcdPlayerState;
   /**
-  * Dropped Frames
+  * Startup
   *
-  * An absolute count of dropped frames since session initiation. This key should only be sent for content types of 'v','av' or 'o'.
-  * Note that this value will be driven by the content being rendered rather than the content being retrieved, therefore it is beneficial if accompanied by the playhead time 'pt' key to allow for correct interpretation.
+  * Key is included without a value if the object is needed urgently due to startup, seeking or recovery after a buffer-empty event. The player
+  * reports this key as true until its buffer first reaches the target buffer for stable playback.
   *
-  * Integer
+  * Boolean
+  */
+  su?: boolean;
+  /**
+  * Top aggregated encoded bitrate
+  *
+  * The highest aggregated bitrate rendition in the manifest or playlist. This SHOULD be derived from playlist/manifest declarations,
+  * or it MAY be estimated by the player. If the playlist declares both peak and average bitrate values, the peak value MUST be
+  * transmitted. The aggregate encoded bitrate is of the complete media object including all object types. This value MUST NOT be
+  * sent if the top encoded bitrate is known.
+  *
+  * Inner list of integer kbps with token identifiers
   */
-  df?: number;
+  tab?: CmcdObjectTypeList;
   /**
-  * Content Signature
+  * Top encoded bitrate
   *
-  * A string representing a signature of the content being played. This field SHOULD vary with content ID and be bound by some mechanism to the content.
-  * For example, this field may be used to transmit the C2PA signature associated with the content being viewed.
+  * The highest bitrate rendition in the manifest or playlist. This SHOULD be derived from playlist/manifest declarations,
+  * or it MAY be estimated by the player. If the playlist declares both peak and average bitrate values, the peak value
+  * MUST be transmitted. This top bitrate MUST apply to the object type being requested. Requests for video objects MUST
+  * specify the top video bitrate and requests for audio objects MUST specify the top audio bitrate.
   *
-  * Integer bytes
+  * Inner list of integer kbps with token identifiers
   */
-  cs?: number;
+  tb?: CmcdObjectTypeList;
+  /**
+  * Target Buffer length
+  *
+  * The target buffer length associated with the media object being requested at the time of the request. This value SHOULD be rounded
+  * to the nearest 100 ms.
+  *
+  * Inner list of integer milliseconds with token identifiers
+  */
+  tbl?: CmcdObjectTypeList;
+  /**
+  * Top playable bitrate
+  *
+  * The highest bitrate rendition that the player is currently capable of playing for reasons other than bandwidth limitations. This
+  * key captures the cases in which, for example, screen resolution, DRM, or performance constraints limit the player's topmost choice
+  * of bitrate. These constraints are intentionally obfuscated for privacy reasons.
+  *
+  * This key can increase the fingerprinting surface exposed by CMCD transmission and SHOULD NOT be transmitted in a default player
+  * configuration.
+  *
+  * If the playlist declares both peak and average bitrate values, the peak value MUST be transmitted. This top playable bitrate MUST
+  * apply to the object type being requested. Requests for video objects MUST specify the top playable video bitrate and requests for
+  * audio objects MUST specify the top playable audio bitrate. This value MUST NOT be sent for objects which do not have an object type
+  * of 'a', 'v', 'av' or 'c'.
+  *
+  * Inner list of integer kbps with token identifiers
+  */
+  tpb?: CmcdObjectTypeList;
+  /**
+  * Version
+  *
+  * The version of this specification used for interpreting the defined key names and values. If this key is omitted, the player and server
+  * MUST interpret the values as being defined by version 1. Player SHOULD omit this field if the version is 1 and MUST include this field
+  * if the version is not 1.
+  *
+  * Integer
+  */
+  v?: number;
 };
 //#endregion
 //#region src/CmcdEvent.d.ts
 /**
-* CMCD v2 - Event Mode.
+* Common Media Client Data (CMCD) version 2 - Event Mode.
 *
-* Represents the event and keys for CMCD v2.
+* Extends {@link CmcdRequest} with event-specific keys for reporting events
+* according to the CMCD version 2 specification.
 *
-* This type is used to structure the data for reporting events according to the
-* Common Media Client Data (CMCD) version 2 specification. It encapsulates
-* the reporting event token.
+* @public
+*/
+type CmcdEvent = CmcdRequest & {
+  /**
+  * Custom Event Name
+  *
+  * Used to define a custom event name. A maximum length of 64 characters is allowed. This key MUST be sent when the event type is
+  * 'ce' (custom event) and MUST NOT be sent when the event type is any other value. A custom key-value pair MAY be used to transfer
+  * a custom value associated with this event. The names chosen SHOULD associate the custom event name with the custom key name.
+  *
+  * String
+  */
+  cen?: string;
+  /**
+  * Event
+  *
+  * This key MUST only be used in Event mode and MUST be present on all reports. The minimum recommended set of supported events
+  * are: `ps`, `e`, `t`, and `rr`.
+  *
+  * - `abs` - ad break start
+  * - `abe` - ad break end
+  * - `ae` - ad end
+  * - `as` - ad start
+  * - `b` - backgrounded mode
+  * - `bc` - bitrate change
+  * - `c` - content ID changed
+  * - `ce` - custom event
+  * - `e` - error
+  * - `h` - hostname changed
+  * - `m` - mute
+  * - `pc` - player collapse
+  * - `pe` - player expand
+  * - `pr` - playback rate change
+  * - `ps` - play state change
+  * - `rr` - response received
+  * - `sk` - skip
+  * - `t` - time interval
+  * - `um` - unmute
+  *
+  * Token
+  */
+  e?: CmcdEventType;
+  /**
+  * Hostname
+  *
+  * A string identifying the current hostname from which the player is retrieving content. Maximum length is 128 characters.
+  *
+  * String
+  */
+  h?: string;
+  /**
+  * Timestamp
+  *
+  * The timestamp at which the associated event occurred, expressed as the number of milliseconds that have elapsed since the Unix
+  * Epoch (January 1, 1970, at 00:00:00 UTC), excluding leap seconds. When the event is a request for a media object the time SHOULD
+  * reference when the request was first initiated.
+  *
+  * This key MUST be included with all Event reports.
+  *
+  * Integer milliseconds
+  */
+  ts?: number;
+};
+//#endregion
+//#region src/CmcdResponse.d.ts
+/**
+* Common Media Client Data (CMCD) version 2 - Response Mode.
+*
+* Extends {@link CmcdRequest} with response-specific keys for reporting
+* response data according to the CMCD version 2 specification.
 *
 * @public
 */
-type CmcdEvent = Omit<CmcdRequest, CmcdEventExcludedKeys> & {
+type CmcdResponse = CmcdRequest & {
   /**
-  * Event (event mode; e.g. "e", "t", "ps")
+  * CMSD Dynamic Header
   *
-  * This key MUST only be used in Event mode.
+  * Holds a Base64 encoded copy of the CMSD data received on the CMSD-Dynamic response header. This key MUST only be reported on
+  * events of type `rr` (response received).
   *
-  * ps - play state change. This token MUST be accompanied by a 'sta' key carrying the new state.
+  * String
+  */
+  cmsdd?: string;
+  /**
+  * CMSD Static Header
   *
-  * e - the player has experienced an error. This token MUST be accompanied by a 'ec' key defining the player error code.
+  * Holds a Base64 encoded copy of the CMSD data received on the CMSD-Static response header. This key MUST only be reported on
+  * events of type `rr` (response received).
   *
-  * t - time interval. The interval at which these reports are made is application-defined. A default interval of 30 seconds SHOULD
-  * be used if no explicit application interval is provided. Short form content may wish to use a shorter interval.
-  * An application-defined interval of zero should be interpreted as turning off interval event reporting.
-  * This event MUST be supported by all players that support Event mode.
+  * String
+  */
+  cmsds?: string;
+  /**
+  * Response code
   *
-  * c - content ID has changed. This token MUST be accompanied by a 'cid' key defining the new content ID.
+  * The response code received when requesting a media object. In a redirect scenario, this would be the final response code received.
+  * A value of 0 SHOULD be used to indicate that a response was not received.
   *
-  * b - the player has entered backgrounded mode if this event is accompanied by the ‘bg’ key and exited backgrounded mode if not.
+  * This key MUST only be reported on events of type `rr` (response received).
   *
-  * m - mute. The user activated the mute control or set the volume to zero.
+  * Integer
+  */
+  rc?: number;
+  /**
+  * SMRT-Data Header
   *
-  * um - unmute. The user deactivated the mute control or raised the volume above zero if it was previously set to zero.
+  * Holds a Base64 encoded copy of the streaming media response tracing data received on the Request Tracing header. This key MUST
+  * only be reported on events of type `rr` (response received).
   *
-  * pe - playerExpand. The user activated a control to extend the player to a larger size. The definition of this event is intended to be
-  * compliant with the VAST [VAST] Player Operation Metrics.
+  * String
+  */
+  smrt?: string;
+  /**
+  * Time to first byte
   *
-  * c - playerCollapse: the user activated a control to reduce the player to a smaller size. The definition of this event is intended to be
-  * compliant with the VAST [VAST] Player Operation Metrics.
+  * The elapsed time between when the request was first initiated (captured in ts) and the time when the first byte of the response
+  * was received. This key MUST only be reported on events of type `rr` (response received).
   *
-  * Token - one of [ps,e,t,c,b,m,u m, abs, abe, as, ae]
+  * Integer milliseconds
   */
-  e?: CmcdEventType;
+  ttfb?: number;
+  /**
+  * Time to first body byte
+  *
+  * The elapsed time between when the request was first initiated (captured in ts) and the time the first bytes of the response body
+  * are received. This key MUST only be reported on events of type `rr` (response received).
+  *
+  * Integer milliseconds
+  */
+  ttfbb?: number;
+  /**
+  * Time to last byte
+  *
+  * The elapsed time between when the request was first initiated (captured in ts) and the time the response body is fully received.
+  * This key MUST only be reported on events of type `rr` (response received).
+  *
+  * Integer milliseconds
+  */
+  ttlb?: number;
+  /**
+  * Request URL
+  *
+  * The URL used to request the media object. If the request is redirected, this key MUST report the initial requested URL. This key
+  * MUST be reported on events of type `rr` (response received).
+  *
+  * String
+  */
+  url?: string;
+};
+//#endregion
+//#region src/Cmcd.d.ts
+/**
+* Common Media Client Data (CMCD) version 2.
+*
+* A standardized set of HTTP request header fields, query string parameters,
+* and event reporting fields for communicating media playback metrics.
+*
+* This type is the intersection of {@link CmcdRequest}, {@link CmcdResponse},
+* and {@link CmcdEvent}, combining all keys from all reporting modes.
+*
+* @see {@link https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf|CMCD v1 Spec}
+*
+* @public
+*/
+type Cmcd = CmcdRequest & CmcdResponse & CmcdEvent;
+//#endregion
+//#region src/CmcdReportingMode.d.ts
+/**
+* CMCD event mode variable name.
+*
+* @public
+*/
+declare const CMCD_EVENT_MODE: "event";
+/**
+* CMCD request mode variable name.
+*
+* @public
+*/
+declare const CMCD_REQUEST_MODE: "request";
+/**
+* CMCD reporting mode types.
+*
+* @enum
+*
+* @public
+*/
+declare const CmcdReportingMode: {
+  /**
+  * Request mode
+  */
+  readonly REQUEST: typeof CMCD_REQUEST_MODE;
+  /**
+  * Event mode
+  */
+  readonly EVENT: typeof CMCD_EVENT_MODE;
 };
+/**
+* @public
+*/
+type CmcdReportingMode = ValueOf<typeof CmcdReportingMode>;
+//#endregion
+//#region src/CmcdFormatterOptions.d.ts
+/**
+* Options for formatting CMCD data values.
+*
+* @public
+*/
+type CmcdFormatterOptions = {
+  /**
+  * The version of the CMCD specification to use.
+  */
+  version: number;
+  /**
+  * The reporting mode to use.
+  */
+  reportingMode: CmcdReportingMode;
+  /**
+  * The base URL to use for relative URLs.
+  */
+  baseUrl?: string;
+};
+//#endregion
+//#region src/CmcdValue.d.ts
+/**
+* CMCD Value
+*
+* @public
+*/
+type CmcdValue = ValueOf<Cmcd>;
 //#endregion
-//#region src/CmcdResponse.d.ts
+//#region src/CmcdFormatter.d.ts
 /**
-* CMCD Response Mode.
+* A formatter for CMCD values.
+*
+* @param value - The value to format.
 *
-* Defines the keys for the CMCD (Common Media Client Data) v2 Response group.
+* @returns The formatted value.
 *
 * @public
 */
-type CmcdResponse = CmcdRequest & {
-  /**
-  * Response code for object request (response mode)
-  *
-  * The response code received when requesting a media object. In a redirect scenario, this would be the final response code received.
-  * A value of 0 SHOULD be used to indicate that a response was not received.
-  *
-  * Integer
-  */
-  rc?: number;
+type CmcdFormatter = (value: CmcdValue, options: CmcdFormatterOptions) => ValueOrArray<number | SfItem<number>> | ValueOrArray<string | SfItem<string>>;
+//#endregion
+//#region src/CmcdV1.d.ts
+/**
+* CMCD Version 1
+*
+* @public
+*/
+type CmcdV1 = {
   /**
-  * Time to first byte (ms; response mode)
+  * Buffer length
   *
-  * The elapsed time between when the request was first initiated (captured in ts) and the time when the first byte of the response was received.
-  * This value should only be reported if it is known. Absence of this key does not indicate that the response was not received.
+  * The buffer length associated with the media object being requested. This value MUST be rounded to the nearest 100 ms. This key SHOULD only be
+  * sent with an object type of ‘a’, ‘v’ or ‘av’.
   *
   * Integer milliseconds
   */
-  ttfb?: number;
+  bl?: number;
   /**
-  * Time to first body byte (ms; response mode)
+  * Bitrate
   *
-  * The elapsed time between when the request was first initiated (captured in ts) and the time the first bytes of the response body are received.
-  * This value should only be reported if it is known. Absence of this key does not indicate that the body was not received.
-  *
-  * Integer milliseconds
+  * Integer
   */
-  ttfbb?: number;
+  br?: number;
   /**
-  * Time to last byte (ms; response mode)
+  * Measured mtp CMCD throughput
   *
-  * The elapsed time between when the request was first initiated (captured in ts) and the time the response body is fully received.
-  * This value should only be reported if it is known.
-  * Absence of this key does not indicate that the response was not fully received
+  * The throughput between client and server, as measured by the client and MUST be rounded to the nearest 100 kbps. This value, however derived,
+  * SHOULD be the value that the client is using to make its next Adaptive Bitrate switching decision. If the client is connected to multiple
+  * servers concurrently, it must take care to report only the throughput measured against the receiving server. If the client has multiple concurrent
+  * connections to the server, then the intent is that this value communicates the aggregate throughput the client sees across all those connections.
   *
-  * Integer milliseconds
+  * Integer kbps
   */
-  ttlb?: number;
+  mtp?: number;
   /**
-  * Requested URL (string; response mode)
+  * Next object request
   *
-  * The URL used to request the media object.
-  * This key MUST NOT be used with reporting mode #1.
-  * If the request is redirected, this key MUST report the initial requested URL.
+  * Relative path of the next object to be requested. This can be used to trigger pre-fetching by the CDN. This MUST be a path relative to the current
+  * request. This string MUST be URLEncoded. The client SHOULD NOT depend upon any pre-fetch action being taken - it is merely a request for such a
+  * pre-fetch to take place.
   *
   * String
   */
-  url?: string;
+  nor?: string;
   /**
-  * CMSD Dynamic Header (response mode)
+  * Next range request
   *
-  * Holds a Base64 [base64] encoded copy of the CMSD data received on the CMSD-Dynamic response header.
-  * This key MUST only be used in RESPONSE mode.
+  * @deprecated Use 'nor' with the 'r' parameter instead.
   *
   * String
   */
-  cmsdd?: string;
+  nrr?: string;
   /**
-  * CMSD Static Header (response mode)
+  * Top bitrate
   *
-  * Holds a Base64 [base64] encoded copy of the CMSD data received on the CMSD-Static response header.
-  * This key MUST only be used in RESPONSE mode.
+  * The highest bitrate rendition in the manifest or playlist that the client is allowed to play, given current codec, licensing and
+  * sizing constraints.
   *
-  * String
-  */
-  cmsds?: string;
-  /**
-  * SMRT Header
-  
-  * Holds a Base64 [base64] encoded copy of the streaming media response tracing data received on the SMRT-Data header.
-  * This key MUST only be used in RESPONSE mode.
+  * Integer Kbps
   */
-  smrt?: number;
+  tb?: number;
 };
 //#endregion
-//#region src/CmcdData.d.ts
-/**
-* All CMCD data types combined.
-*
-* @public
-*/
-type CmcdData = Cmcd & CmcdRequest & CmcdEvent & CmcdResponse;
-//#endregion
 //#region src/CmcdKey.d.ts
 /**
-* A CMCD key.
+* A CMCD key including V1-only keys.
 *
 * @public
 */
-type CmcdKey = keyof CmcdData;
+type CmcdKey = keyof Cmcd | keyof CmcdV1;
 //#endregion
 //#region src/CmcdFormatterMap.d.ts
 /**
@@ -839,39 +1142,31 @@ type CmcdKey = keyof CmcdData;
 */
 type CmcdFormatterMap = Record<CmcdKey, CmcdFormatter>;
 //#endregion
-//#region src/CMCD_OBJECT.d.ts
+//#region src/CmcdHeaderField.d.ts
 /**
 * CMCD object header name.
 *
 * @public
 */
-declare const CMCD_OBJECT = "CMCD-Object";
-//#endregion
-//#region src/CMCD_REQUEST.d.ts
+declare const CMCD_OBJECT: "CMCD-Object";
 /**
 * CMCD request header name.
 *
 * @public
 */
-declare const CMCD_REQUEST = "CMCD-Request";
-//#endregion
-//#region src/CMCD_SESSION.d.ts
+declare const CMCD_REQUEST: "CMCD-Request";
 /**
 * CMCD session header name.
 *
 * @public
 */
-declare const CMCD_SESSION = "CMCD-Session";
-//#endregion
-//#region src/CMCD_STATUS.d.ts
+declare const CMCD_SESSION: "CMCD-Session";
 /**
 * CMCD status header name.
 *
 * @public
 */
-declare const CMCD_STATUS = "CMCD-Status";
-//#endregion
-//#region src/CmcdHeaderField.d.ts
+declare const CMCD_STATUS: "CMCD-Status";
 /**
 * CMCD header fields.
 *
@@ -990,17 +1285,9 @@ declare function appendCmcdHeaders(headers: Record<string, string>, cmcd: Cmcd,
 */
 declare function appendCmcdQuery(url: string, cmcd: Cmcd, options?: CmcdEncodeOptions): string;
 //#endregion
-//#region src/CMCD_COMMON_KEYS.d.ts
-/**
-* Defines the common keys for CMCD (Common Media Client Data) version 2.
-*
-* @public
-*/
-declare const CMCD_COMMON_KEYS: readonly ["ab", "bg", "bl", "br", "bs", "bsd", "cdn", "cid", "cs", "df", "ec", "lab", "lb", "ltc", "msd", "mtp", "pb", "pr", "pt", "sf", "sid", "sn", "st", "sta", "tab", "tb", "tbl", "tpb", "ts", "v"];
-//#endregion
 //#region src/CMCD_DEFAULT_TIME_INTERVAL.d.ts
 /**
-* The default time interval in secondswhen using using event mode
+* The default time interval in seconds when using using event mode
 *
 * @public
 */
@@ -1012,7 +1299,7 @@ declare const CMCD_DEFAULT_TIME_INTERVAL = 30;
 *
 * @public
 */
-declare const CMCD_EVENT_KEYS: readonly ["e"];
+declare const CMCD_EVENT_KEYS: readonly ["cen", "e", "h", "ts"];
 //#endregion
 //#region src/CMCD_FORMATTER_MAP.d.ts
 /**
@@ -1022,100 +1309,190 @@ declare const CMCD_EVENT_KEYS: readonly ["e"];
 */
 declare const CMCD_FORMATTER_MAP: Record<string, CmcdFormatter>;
 //#endregion
-//#region src/CMCD_HEADERS.d.ts
+//#region src/CMCD_KEYS.d.ts
 /**
-* CMCD `headers` transmission mode.
+* A list of all CMCD keys.
 *
 * @public
 */
-declare const CMCD_HEADERS = "headers";
+declare const CMCD_KEYS: CmcdKey[];
 //#endregion
-//#region src/CMCD_JSON.d.ts
+//#region src/CMCD_PARAM.d.ts
 /**
-* CMCD `json` transmission mode.
+* CMCD parameter name.
 *
 * @public
+*/
+declare const CMCD_PARAM = "CMCD";
+//#endregion
+//#region src/CMCD_REQUEST_KEYS.d.ts
+/**
+* Defines the request-specific keys for CMCD (Common Media Client Data) version 2.
 *
-* @deprecated JSON transmission mode is deprecated and will be removed in future versions.
+* @public
 */
-declare const CMCD_JSON = "json";
+declare const CMCD_REQUEST_KEYS: readonly ["ab", "bg", "bl", "br", "bs", "bsa", "bsd", "bsda", "cdn", "cid", "cs", "d", "dfa", "dl", "ec", "lab", "lb", "ltc", "msd", "mtp", "nor", "nr", "ot", "pb", "pr", "pt", "rtp", "sf", "sid", "sn", "st", "sta", "su", "tab", "tb", "tbl", "tpb", "v"];
 //#endregion
-//#region src/CMCD_KEYS.d.ts
+//#region src/CMCD_RESPONSE_KEYS.d.ts
 /**
-* A list of all CMCD keys.
+* CMCD v2 - Response-only and timing keys.
 *
 * @public
 */
-declare const CMCD_KEYS: CmcdKey[];
+declare const CMCD_RESPONSE_KEYS: readonly ["cmsdd", "cmsds", "rc", "smrt", "ttfb", "ttfbb", "ttlb", "url"];
 //#endregion
-//#region src/CMCD_PARAM.d.ts
+//#region src/CMCD_V1.d.ts
 /**
-* CMCD parameter name.
+* CMCD Version 1
 *
 * @public
 */
-declare const CMCD_PARAM = "CMCD";
+declare const CMCD_V1: 1;
 //#endregion
-//#region src/CMCD_QUERY.d.ts
+//#region src/CMCD_V1_KEYS.d.ts
 /**
-* CMCD `query` transmission mode.
+* Defines the keys for CMCD (Common Media Client Data) version 1.
 *
 * @public
 */
-declare const CMCD_QUERY = "query";
+declare const CMCD_V1_KEYS: readonly ["bl", "br", "bs", "cid", "d", "dl", "mtp", "nor", "nrr", "ot", "pr", "rtp", "sf", "sid", "st", "su", "tb", "v"];
 //#endregion
-//#region src/CMCD_REQUEST_KEYS.d.ts
+//#region src/CMCD_V2.d.ts
 /**
-* Defines the request-specific keys for CMCD (Common Media Client Data) version 2.
+* CMCD Version 2
 *
 * @public
 */
-declare const CMCD_REQUEST_KEYS: readonly ["d", "dl", "nor", "ot", "rtp", "su"];
+declare const CMCD_V2: 2;
 //#endregion
-//#region src/CMCD_RESPONSE_KEYS.d.ts
+//#region src/CmcdVersion.d.ts
 /**
-* CMCD v2 - Response-only and timing keys.
+* The version of the CMCD specification.
 *
 * @public
 */
-declare const CMCD_RESPONSE_KEYS: readonly ["cmsdd", "cmsds", "rc", "smrt", "ttfb", "ttfbb", "ttlb", "url"];
+type CmcdVersion = typeof CMCD_V1 | typeof CMCD_V2;
 //#endregion
-//#region src/CMCD_RESPONSE_MODE.d.ts
+//#region src/CmcdReportConfig.d.ts
 /**
-* CMCD response mode variable name.
+* Configuration for a CMCD report.
 *
 * @public
 */
-declare const CMCD_RESPONSE_MODE = "response";
+type CmcdReportConfig = {
+  /**
+  * The version of the CMCD specification to use.
+  *
+  * @defaultValue `CMCD_V2`
+  */
+  version?: CmcdVersion;
+  /**
+  * The list of CMCD keys to include in the report. If not provided,
+  * no keys will be reported, unless there are other configuration
+  * options that require keys to be reported, specifically in event mode.
+  *
+  * @defaultValue `undefined`
+  */
+  enabledKeys?: CmcdKey[];
+};
 //#endregion
-//#region src/CMCD_V1.d.ts
+//#region src/CmcdEventReportConfig.d.ts
 /**
-* CMCD Version 1
+* Configuration for a CMCD event report.
+*
+* @public
+*/
+type CmcdEventReportConfig = CmcdReportConfig & {
+  /**
+  * The version of the CMCD protocol to use. Must be
+  * version 2 or higher for event reporting.
+  *
+  * @defaultValue `CMCD_V2`
+  */
+  version?: typeof CMCD_V2;
+  /**
+  * The URL to which the CMCD event should be sent.
+  */
+  url: string;
+  /**
+  * The events to report. If no events are provided,
+  * the event target will be effectively disabled.
+  *
+  * @defaultValue `undefined`
+  */
+  events?: CmcdEventType[];
+  /**
+  * When the time interval event is sent, the interval at which the
+  * events should be reported as a number of seconds.
+  *
+  * @defaultValue `CMCD_DEFAULT_TIME_INTERVAL`
+  *
+  * @see {@link CMCD_DEFAULT_TIME_INTERVAL}
+  */
+  interval?: number;
+  /**
+  * The number of events to batch before sending the report.
+  *
+  * @defaultValue `1`
+  */
+  batchSize?: number;
+};
+//#endregion
+//#region src/CmcdRequestKey.d.ts
+/**
+* A CMCD request key.
 *
 * @public
 */
-declare const CMCD_V1 = 1;
+type CmcdRequestKey = keyof CmcdRequest | "nrr";
 //#endregion
-//#region src/CMCD_V1_KEYS.d.ts
+//#region src/CMCD_HEADER_MAP.d.ts
 /**
-* Defines the keys for CMCD (Common Media Client Data) version 1.
+* The map of CMCD keys to their appropriate header shard.
+*
+* @internal
+*/
+declare const CMCD_HEADER_MAP: Record<CmcdRequestKey | "nrr", CmcdHeaderField>;
+//#endregion
+//#region src/CmcdHeaderKey.d.ts
+/**
+* A CMCD header key.
 *
 * @public
 */
-declare const CMCD_V1_KEYS: readonly ["bl", "br", "bs", "cid", "d", "dl", "mtp", "nor", "nrr", "ot", "pr", "rtp", "sf", "sid", "st", "su", "tb", "v"];
+type CmcdHeaderKey = keyof typeof CMCD_HEADER_MAP;
 //#endregion
-//#region src/CMCD_V2.d.ts
+//#region src/CmcdHeaderValue.d.ts
 /**
-* CMCD Version 2
+* CMCD header value
 *
 * @public
 */
-declare const CMCD_V2 = 2;
+type CmcdHeaderValue = CmcdRequest | CmcdV1;
 //#endregion
 //#region src/CmcdTransmissionMode.d.ts
 /**
-* CMCD transmission modes.
+* CMCD `query` transmission mode.
 *
+* @public
+*/
+declare const CMCD_QUERY: "query";
+/**
+* CMCD `headers` transmission mode.
+*
+* @public
+*/
+declare const CMCD_HEADERS: "headers";
+/**
+* CMCD `json` transmission mode.
+*
+* @public
+*
+* @deprecated JSON transmission mode is deprecated and will be removed in future versions.
+*/
+declare const CMCD_JSON: "json";
+/**
+* CMCD transmission modes.
 *
 * @enum
 *
@@ -1142,85 +1519,127 @@ declare const CmcdTransmissionMode: {
 */
 type CmcdTransmissionMode = ValueOf<typeof CmcdTransmissionMode>;
 //#endregion
-//#region src/CmcdEncoding.d.ts
+//#region src/CmcdRequestReportConfig.d.ts
 /**
-* CMCD encoding types.
+* Configuration for a CMCD request report.
 *
-*
-* @enum
-*
-* @public
-*
-* @deprecated Use {@link CmcdTransmissionMode} instead.
-*
-* @see {@link CmcdTransmissionMode}
-*/
-declare const CmcdEncoding: typeof CmcdTransmissionMode;
-/**
 * @public
 */
-type CmcdEncoding = ValueOf<typeof CmcdEncoding>;
-//#endregion
-//#region src/CmcdFormatters.d.ts
-/**
-* The default formatters for CMCD values.
-*
-* @public
-*
-* @deprecated Use `CMCD_FORMATTER_MAP` instead.
-*/
-declare const CmcdFormatters: Record<string, CmcdFormatter>;
+type CmcdRequestReportConfig = CmcdReportConfig & {
+  /**
+  * The transmission mode to use.
+  *
+  * @defaultValue `CmcdTransmissionMode.QUERY`
+  */
+  transmissionMode?: CmcdTransmissionMode;
+};
 //#endregion
-//#region src/CmcdHeadersMap.d.ts
+//#region src/CmcdReporterConfig.d.ts
 /**
-* A map of CMCD header fields to CMCD keys.
+* Configuration for a CMCD reporting component.
 *
 * @public
-*
-* @deprecated Use `CmcdHeaderMap` instead.
 */
-type CmcdHeadersMap = Record<CmcdHeaderField, CmcdKey[]>;
+type CmcdReporterConfig = CmcdRequestReportConfig & {
+  /**
+  * The session ID. If not provided, a new random session ID will be generated.
+  *
+  * @defaultValue `undefined`
+  */
+  sid?: string;
+  /**
+  * The content ID.
+  *
+  * @defaultValue `undefined`
+  */
+  cid?: string;
+  /**
+  * The event configurations. If not provided, no events will be reported.
+  *
+  * @defaultValue `undefined`
+  */
+  eventTargets?: CmcdEventReportConfig[];
+};
 //#endregion
-//#region src/CmcdReportTarget.d.ts
+//#region src/CmcdReporter.d.ts
 /**
-* A CMCD report target configuration.
+* The CMCD reporter.
 *
 * @public
 */
-type CmcdReportTarget = {
+declare class CmcdReporter {
+  private data;
+  private config;
+  private requestEncodingOptions;
+  private msd;
+  private eventTargets;
+  private requestTarget;
+  private requester;
+  /**
+  * Creates a new CMCD reporter.
+  *
+  * @param config - The configuration for the CMCD reporter.
+  * @param requester - The function to use to send the request.
+  *                    The default is a simple wrapper around the
+  *                    native `fetch` API.
+  */
+  constructor(config: Partial<CmcdReporterConfig>, requester?: (request: Request) => Promise<{
+    status: number;
+  }>);
   /**
-  * The URL to which the CMCD report should be sent.
+  * Starts the CMCD reporter. Called by the player when the reporter is enabled.
   */
-  url: string;
+  start(): void;
+  /**
+  * Stops the CMCD reporter. Called by the player when the reporter is disabled.
+  */
+  stop(): void;
+  /**
+  * Forces the sending of all event reports, regardless of the batch size or interval.
+  * Useful for sending outstanding reports when the player is destroyed or a playback
+  * session ends.
+  */
+  flush(): void;
   /**
-  * The reporting mode for the CMCD report.
+  * Updates the CMCD data. Called by the player when the data changes.
   *
-  * @defaultValue `CmcdReportingMode.REQUEST`
+  * @param data - The data to update.
   */
-  reportingMode?: CmcdReportingMode;
+  update(data: Partial<Cmcd>): void;
   /**
-  * The HTTP method to use for the CMCD report.
+  * Records an event. Called by the player when an event occurs.
   *
-  * @defaultValue `'GET'`
+  * @param type - The type of event to record.
+  * @param data - Additional data to record with the event. This is
+  *               the same as calling `update()` with the same data.
   */
-  method?: "GET" | "POST";
+  recordEvent(type: CmcdEventType, data?: Partial<Cmcd>): void;
   /**
-  * The version of the CMCD report.
+  * Applies the CMCD request report data to the request. Called by the player
+  * before sending the request.
   *
-  * @defaultValue `1`
+  * @param req - The request to apply the CMCD request report to.
+  * @returns The request with the CMCD request report applied.
   */
-  version?: number;
+  applyRequestReport(req: Request): Request;
   /**
-  * The transmission mode for the CMCD report.
+  * Processes the event targets. Called by the reporter when an event occurs.
   *
-  * @defaultValue `CmcdTransmissionMode.QUERY`
+  * @param flush - Whether to flush the event targets.
   */
-  transmissionMode?: CmcdTransmissionMode;
+  private processEventTargets;
   /**
-  * The list of CMCD keys to include in the report.
+  * Sends an event report. Called by the reporter when a batch is ready to be sent.
+  *
+  * @param target - The target to send the event report to.
+  * @param data - The data to send in the event report.
   */
-  enabledKeys?: CmcdKey[];
-};
+  private sendEventReport;
+  /**
+  * Resets the session related data. Called when the session ID changes.
+  */
+  private resetSession;
+}
 //#endregion
 //#region src/decodeCmcd.d.ts
 /**
@@ -1235,7 +1654,7 @@ type CmcdReportTarget = {
 * @example
 * {@includeCode ../test/decodeCmcd.test.ts#example}
 */
-declare function decodeCmcd<T extends CmcdData = CmcdData>(cmcd: string): T;
+declare function decodeCmcd<T extends Cmcd = Cmcd>(cmcd: string): T;
 //#endregion
 //#region src/encodeCmcd.d.ts
 /**
@@ -1251,7 +1670,7 @@ declare function decodeCmcd<T extends CmcdData = CmcdData>(cmcd: string): T;
 * @example
 * {@includeCode ../test/encodeCmcd.test.ts#example}
 */
-declare function encodeCmcd(cmcd: CmcdData, options?: CmcdEncodeOptions): string;
+declare function encodeCmcd(cmcd: Cmcd, options?: CmcdEncodeOptions): string;
 //#endregion
 //#region src/fromCmcdHeaders.d.ts
 /**
@@ -1266,7 +1685,7 @@ declare function encodeCmcd(cmcd: CmcdData, options?: CmcdEncodeOptions): string
 * @example
 * {@includeCode ../test/fromCmcdHeaders.test.ts#example}
 */
-declare function fromCmcdHeaders(headers: Record<string, string> | Headers): CmcdData;
+declare function fromCmcdHeaders(headers: Record<string, string> | Headers): Cmcd;
 //#endregion
 //#region src/fromCmcdQuery.d.ts
 /**
@@ -1309,7 +1728,7 @@ declare function fromCmcdUrl(url: string): Cmcd;
 *
 * @public
 */
-declare function groupCmcdHeaders(cmcd: CmcdData, customHeaderMap?: Partial<CmcdHeaderMap>): Record<CmcdHeaderField, CmcdData>;
+declare function groupCmcdHeaders(cmcd: Cmcd, customHeaderMap?: Partial<CmcdHeaderMap>): Record<CmcdHeaderField, CmcdHeaderValue>;
 //#endregion
 //#region src/isCmcdCustomKey.d.ts
 /**
@@ -1336,7 +1755,7 @@ declare function isCmcdCustomKey(key: CmcdKey): boolean;
 * @example
 * {@includeCode ../test/isCmcdEventKey.test.ts#example}
 */
-declare function isCmcdEventKey(key: string): key is keyof CmcdEvent;
+declare function isCmcdEventKey(key: string): key is keyof Cmcd;
 //#endregion
 //#region src/isCmcdRequestKey.d.ts
 /**
@@ -1351,7 +1770,7 @@ declare function isCmcdEventKey(key: string): key is keyof CmcdEvent;
 * @example
 * {@includeCode ../test/isCmcdRequestKey.test.ts#example}
 */
-declare function isCmcdRequestKey(key: string): key is keyof CmcdRequest;
+declare function isCmcdRequestKey(key: string): key is keyof Cmcd;
 //#endregion
 //#region src/isCmcdResponseReceivedKey.d.ts
 /**
@@ -1361,14 +1780,12 @@ declare function isCmcdRequestKey(key: string): key is keyof CmcdRequest;
 *
 * @returns `true` if the key is a valid CMCD request key, `false` otherwise.
 *
-* @group CMCD
-*
 * @public
 *
 * @example
-* {@includeCode ../../test/cmcd/isCmcdResponseReceivedKey.test.ts#example}
+* {@includeCode ../test/isCmcdResponseReceivedKey.test.ts#example}
 */
-declare function isCmcdResponseReceivedKey(key: string): key is keyof CmcdResponse;
+declare function isCmcdResponseReceivedKey(key: string): key is keyof Cmcd;
 //#endregion
 //#region src/isCmcdV1Key.d.ts
 /**
@@ -1383,7 +1800,7 @@ declare function isCmcdResponseReceivedKey(key: string): key is keyof CmcdRespon
 * @example
 * {@includeCode ../test/isCmcdV1Key.test.ts#example}
 */
-declare function isCmcdV1Key(key: string): key is keyof Cmcd;
+declare function isCmcdV1Key(key: string): key is CmcdKey;
 //#endregion
 //#region src/prepareCmcdData.d.ts
 /**
@@ -1394,7 +1811,7 @@ declare function isCmcdV1Key(key: string): key is keyof Cmcd;
 *
 * @public
 */
-declare function prepareCmcdData(obj: Record<string, any>, options?: CmcdEncodeOptions): CmcdData;
+declare function prepareCmcdData(obj: Record<string, any>, options?: CmcdEncodeOptions): Cmcd;
 //#endregion
 //#region src/toCmcdHeaders.d.ts
 /**
@@ -1410,22 +1827,7 @@ declare function prepareCmcdData(obj: Record<string, any>, options?: CmcdEncodeO
 * @example
 * {@includeCode ../test/toCmcdHeaders.test.ts#example}
 */
-declare function toCmcdHeaders(cmcd: CmcdData, options?: CmcdEncodeOptions): Record<CmcdHeaderField, string>;
-//#endregion
-//#region src/toCmcdJson.d.ts
-/**
-* Convert a CMCD data object to JSON.
-*
-* @param cmcd - The CMCD object to convert.
-* @param options - Options for encoding the CMCD object.
-*
-* @returns The CMCD JSON.
-*
-* @public
-*
-* @deprecated Sending CMCD as JSON objects is deprecated. Use `toCmcdUrl` to create an array of url strings instead.
-*/
-declare function toCmcdJson(cmcd: Cmcd, options?: CmcdEncodeOptions): string;
+declare function toCmcdHeaders(cmcd: Cmcd, options?: CmcdEncodeOptions): Record<CmcdHeaderField, string>;
 //#endregion
 //#region src/toCmcdQuery.d.ts
 /**
@@ -1443,24 +1845,6 @@ declare function toCmcdJson(cmcd: Cmcd, options?: CmcdEncodeOptions): string;
 */
 declare function toCmcdQuery(cmcd: Cmcd, options?: CmcdEncodeOptions): string;
 //#endregion
-//#region src/toCmcdReport.d.ts
-/**
-* Converts CMCD data into a report format.
-*
-* @param data - The CMCD data to be transformed into a report
-* @param target - The target configuration for the CMCD report
-*
-* @return A CMCD report object
-*
-* @public
-*
-* @example
-* {@includeCode ../test/toCmcdReport.test.ts#example}
-*/
-declare function toCmcdReport(data: CmcdData, target: CmcdReportTarget): Request<{
-  cmcd: Cmcd;
-}> | null;
-//#endregion
 //#region src/toCmcdUrl.d.ts
 /**
 * Convert a CMCD data object to a URL encoded string.
@@ -1474,5 +1858,17 @@ declare function toCmcdReport(data: CmcdData, target: CmcdReportTarget): Request
 */
 declare function toCmcdUrl(cmcd: Cmcd, options?: CmcdEncodeOptions): string;
 //#endregion
-export { CMCD_COMMON_KEYS, CMCD_DEFAULT_TIME_INTERVAL, CMCD_EVENT_KEYS, CMCD_EVENT_MODE, CMCD_FORMATTER_MAP, CMCD_HEADERS, CMCD_JSON, CMCD_KEYS, CMCD_OBJECT, CMCD_PARAM, CMCD_QUERY, CMCD_REQUEST, CMCD_REQUEST_KEYS, CMCD_REQUEST_MODE, CMCD_RESPONSE_KEYS, CMCD_RESPONSE_MODE, CMCD_SESSION, CMCD_STATUS, CMCD_V1, CMCD_V1_KEYS, CMCD_V2, Cmcd, CmcdCustomKey, CmcdData, CmcdEncodeOptions, CmcdEncoding, CmcdEvent, CmcdEventExcludedKeys, CmcdEventType, CmcdFormatter, CmcdFormatterMap, CmcdFormatterOptions, CmcdFormatters, CmcdHeaderField, CmcdHeaderMap, CmcdHeadersMap, CmcdKey, CmcdObjectType, CmcdPlayerState, CmcdReportTarget, CmcdReportingMode, CmcdRequest, CmcdResponse, CmcdStreamType, CmcdStreamingFormat, CmcdTransmissionMode, CmcdValue, appendCmcdHeaders, appendCmcdQuery, decodeCmcd, encodeCmcd, fromCmcdHeaders, fromCmcdQuery, fromCmcdUrl, groupCmcdHeaders, isCmcdCustomKey, isCmcdEventKey, isCmcdRequestKey, isCmcdResponseReceivedKey, isCmcdV1Key, prepareCmcdData, toCmcdHeaders, toCmcdJson, toCmcdQuery, toCmcdReport, toCmcdUrl };
+//#region src/toCmcdValue.d.ts
+/**
+* Convert a value to a CMCD value.
+*
+* @param value - The value to convert to a CMCD value.
+* @param params - The parameters to convert to a CMCD value.
+* @returns The CMCD value.
+*
+* @public
+*/
+declare function toCmcdValue<V extends SfBareItem, P>(value: V, params?: P): SfItem<V, P>;
+//#endregion
+export { CMCD_DEFAULT_TIME_INTERVAL, CMCD_EVENT_AD_BREAK_END, CMCD_EVENT_AD_BREAK_START, CMCD_EVENT_AD_END, CMCD_EVENT_AD_START, CMCD_EVENT_BACKGROUNDED_MODE, CMCD_EVENT_BITRATE_CHANGE, CMCD_EVENT_CONTENT_ID, CMCD_EVENT_CUSTOM_EVENT, CMCD_EVENT_ERROR, CMCD_EVENT_KEYS, CMCD_EVENT_MODE, CMCD_EVENT_MUTE, CMCD_EVENT_PLAYER_COLLAPSE, CMCD_EVENT_PLAYER_EXPAND, CMCD_EVENT_PLAY_STATE, CMCD_EVENT_RESPONSE_RECEIVED, CMCD_EVENT_SKIP, CMCD_EVENT_TIME_INTERVAL, CMCD_EVENT_UNMUTE, CMCD_FORMATTER_MAP, CMCD_HEADERS, CMCD_JSON, CMCD_KEYS, CMCD_OBJECT, CMCD_PARAM, CMCD_QUERY, CMCD_REQUEST, CMCD_REQUEST_KEYS, CMCD_REQUEST_MODE, CMCD_RESPONSE_KEYS, CMCD_SESSION, CMCD_STATUS, CMCD_V1, CMCD_V1_KEYS, CMCD_V2, Cmcd, CmcdCustomKey, CmcdCustomValue, CmcdEncodeOptions, CmcdEvent, CmcdEventReportConfig, CmcdEventType, CmcdFormatter, CmcdFormatterMap, CmcdFormatterOptions, CmcdHeaderField, CmcdHeaderKey, CmcdHeaderMap, CmcdHeaderValue, CmcdKey, CmcdObjectType, CmcdObjectTypeList, CmcdPlayerState, CmcdReportConfig, CmcdReporter, CmcdReporterConfig, CmcdReportingMode, CmcdRequest, CmcdRequestKey, CmcdRequestReportConfig, CmcdResponse, CmcdStreamType, CmcdStreamingFormat, CmcdTransmissionMode, CmcdV1, CmcdValue, appendCmcdHeaders, appendCmcdQuery, decodeCmcd, encodeCmcd, fromCmcdHeaders, fromCmcdQuery, fromCmcdUrl, groupCmcdHeaders, isCmcdCustomKey, isCmcdEventKey, isCmcdRequestKey, isCmcdResponseReceivedKey, isCmcdV1Key, prepareCmcdData, toCmcdHeaders, toCmcdQuery, toCmcdUrl, toCmcdValue };
 //# sourceMappingURL=index.d.ts.map