@newrelic/video-core 5.0.2 → 5.1.0

package/src/{tracker.js → tracker.ts}

@@ -3,6 +3,13 @@ import Emitter from "./emitter";
 import Chrono from "./chrono";
 import Constants from "./constants";
 import Log from "./log";
+import { Harvester } from "./utils/eventBuilder";
+
+export interface TrackerOptions {
+  heartbeat?: number;
+  customData?: Record<string, any>;
+  parentTracker?: Tracker;
+}
 
 /**
  * Tracker class provides the basic logic to extend Newrelic's Browser Agent capabilities.
@@ -17,12 +24,31 @@ import Log from "./log";
  * @extends Emitter
  */
 class Tracker extends Emitter {
+  static Events: Record<string, string>;
+
+  customData: Record<string, any>;
+  heartbeat: number | null;
+  parentTracker: Tracker | null;
+  /**
+   * Set externally by subclasses (VideoTracker, which assigns a real
+   * VideoTrackerState instance) / tests (which assign plain `{ _isAd }`
+   * objects) before any method that reads `this.state._isAd` is invoked.
+   * Not initialized in the base constructor. Loosely typed (`any`) since
+   * both shapes need to be assignable here without a circular import of
+   * VideoTrackerState into the base Tracker.
+   */
+  state?: any;
+  _trackerReadyChrono: Chrono;
+  _actionTable: any;
+  _actionAdTable: any;
+  _heartbeatInterval?: ReturnType<typeof setInterval>;
+
   /**
    * Constructor, receives options. You should call {@see registerListeners} after this.
    *
    * @param {Object} [options] Options for the tracker. See {@link setOptions}.
    */
-  constructor(options) {
+  constructor(options?: TrackerOptions) {
     super();
 
     /**
@@ -56,8 +82,8 @@ class Tracker extends Emitter {
     /**
      * Store the initial table of actions with time 0 ms
      */
-    this._actionTable = Constants.ACTION_TABLE;
-    this._actionAdTable = Constants.ACTION_AD_TABLE;
+    this._actionTable = (Constants as any).ACTION_TABLE;
+    this._actionAdTable = (Constants as any).ACTION_AD_TABLE;
 
     options = options || {};
     this.setOptions(options);
@@ -71,7 +97,7 @@ class Tracker extends Emitter {
    * @param {Object} [options.customData] Set custom data. See {@link customData}.
    * @param {Tracker} [options.parentTracker] Set parent tracker. See {@link parentTracker}.
    */
-  setOptions(options) {
+  setOptions(options?: TrackerOptions): void {
     if (options) {
       if (options.parentTracker) this.parentTracker = options.parentTracker;
       if (options.customData) this.customData = options.customData;
@@ -82,7 +108,7 @@ class Tracker extends Emitter {
   /**
    * Prepares tracker to dispose. Calls {@see unregisterListeners} and drops references.
    */
-  dispose() {
+  dispose(): void {
     this.unregisterListeners();
   }
 
@@ -100,7 +126,7 @@ class Tracker extends Emitter {
    *  }
    * }
    */
-  registerListeners() {}
+  registerListeners(): void {}
 
   /**
    * Override this method to unregister listeners to third party elements created with
@@ -121,15 +147,15 @@ class Tracker extends Emitter {
    *  }
    * }
    */
-  unregisterListeners() {}
+  unregisterListeners(): void {}
 
   /**
    * Returns heartbeat time interval. 30000 (30s) if not set. See {@link setOptions}.
    * @return {number} Heartbeat interval in ms.
    * @final
    */
-  getHeartbeat() {
-    if (this.state._isAd) {
+  getHeartbeat(): number {
+    if (this.state?._isAd) {
       // modifying heartbeat for Ad Tracker
       return 2000;
     } else {
@@ -147,7 +173,7 @@ class Tracker extends Emitter {
    * Starts heartbeating. Interval period set by options.heartbeat. Min 2000 ms.
    * This method is automaticaly called by the tracker once sendRequest is called.
    */
-  startHeartbeat() {
+  startHeartbeat(): void {
     this._heartbeatInterval = setInterval(
       this.sendHeartbeat.bind(this),
       Math.max(this.getHeartbeat(), 2000)
@@ -157,7 +183,7 @@ class Tracker extends Emitter {
   /**
    * Stops heartbeating. This method is automaticaly called by the tracker.
    */
-  stopHeartbeat() {
+  stopHeartbeat(): void {
     if (this._heartbeatInterval) {
       clearInterval(this._heartbeatInterval);
     }
@@ -181,7 +207,7 @@ class Tracker extends Emitter {
    *
    * @param {Object} [att] Collection of key:value attributes to send with the request.
    */
-  sendHeartbeat(att) {
+  sendHeartbeat(att?: Record<string, any>): void {
     this.sendVideoAction(Tracker.Events.HEARTBEAT, att);
   }
 
@@ -201,7 +227,7 @@ class Tracker extends Emitter {
    * @return {object} Filled attributes
    * @final
    */
-  getAttributes(att, eventType) {
+  getAttributes(att?: Record<string, any>, eventType?: string): Record<string, any> {
     att = att || {};
     att.trackerName = this.getTrackerName();
     att.trackerVersion = this.getTrackerVersion();
@@ -220,12 +246,12 @@ class Tracker extends Emitter {
   }
 
   /** Override to change of the Version of tracker. ie: '1.0.1' */
-  getTrackerVersion() {
+  getTrackerVersion(): string {
     return pkg.version;
   }
 
   /** Override to change of the Name of the tracker. ie: 'custom-html5' */
-  getTrackerName() {
+  getTrackerName(): string {
     return "base-tracker";
   }
 
@@ -240,20 +266,20 @@ class Tracker extends Emitter {
    * @param {object} [att] Key:value dictionary filled with attributes.
    */
 
-  sendVideoAction(event, att) {
+  sendVideoAction(event: string, att?: Record<string, any>): void {
     this.emit("VideoAction", event, this.getAttributes(att));
   }
 
-  sendVideoAdAction(event, att) {
+  sendVideoAdAction(event: string, att?: Record<string, any>): void {
     this.emit("VideoAdAction", event, this.getAttributes(att));
   }
 
-  sendVideoErrorAction(event, att) {
-    let ev = this.isAd() ? "adError" : "videoError";
+  sendVideoErrorAction(event: string, att?: Record<string, any>): void {
+    let ev = (this as any).isAd() ? "adError" : "videoError";
     this.emit("VideoErrorAction", event, this.getAttributes(att, ev));
   }
 
-  sendVideoCustomAction(event, att) {
+  sendVideoCustomAction(event: string, att?: Record<string, any>): void {
     this.emit(
       "VideoCustomAction",
       event,
@@ -267,7 +293,7 @@ class Tracker extends Emitter {
    * @returns {void}
    */
 
-  setHarvestInterval(interval) {
+  setHarvestInterval(interval: number): void {
     const harvester = this.getHarvester?.();
     if (!harvester) {
       Log.error("Tracker has no harvester; setHarvestInterval ignored");
@@ -276,7 +302,7 @@ class Tracker extends Emitter {
 
     try {
       harvester.setHarvestInterval(interval);
-    } catch (error) {
+    } catch (error: any) {
       Log.error("Failed to set harvest interval:", error.message);
       return;
     }
@@ -288,9 +314,16 @@ class Tracker extends Emitter {
    * means a tracker that doesn't override `getHarvester()` will silently no-op
    * on harvester-bound calls (setHarvestInterval, QoE drain wiring).
    */
-  getHarvester() {
+  getHarvester(): Harvester | null {
     return null;
   }
+
+  // Note: base Tracker has no `isAd` member at all (matching original JS —
+  // calling sendVideoErrorAction on a bare Tracker throws the native "not a
+  // function" error). VideoTracker defines its own `isAd()`; the one call
+  // site above (sendVideoErrorAction) casts to `any` rather than declaring
+  // an `isAd` member here, since TS treats a `declare`d property and a real
+  // subclass method as incompatible override kinds (TS2425).
 }
 
 /**

package/src/utils/{eventBuilder.js → eventBuilder.ts}

@@ -2,6 +2,23 @@ import Constants from "../constants";
 import Tracker from "../tracker";
 import { getObjectEntriesForKeys } from "./index";
 
+export type EventAttributes = Record<string, any>;
+
+export interface Harvester {
+  addEvent(eventObject: EventAttributes): boolean;
+  setHarvestInterval(ms: number): void;
+  /** Set (or clear, with `null`) the callback run just before the next harvest drain. */
+  setBeforeDrainCallback(callback: (() => void) | null): void;
+  /** Merge fresh QoE KPI values into the buffered QOE_AGGREGATE event for a view. */
+  refreshQoeKpis(freshKpis: EventAttributes, viewId?: string): void;
+  /** Force the next harvest cycle to be treated as a QoE cycle. Only the browser harvester supports this — the connected-device harvester does not implement it. */
+  forceNextQoeCycle?(): void;
+}
+
+interface BuildEventObjectsOptions {
+  addTimeSinceLoad?: boolean;
+}
+
 /**
  * Pure helper that constructs the wire-format event objects from `recordEvent`
  * arguments. Used by `src/recordEvent.js`, which is the single shared
@@ -26,11 +43,11 @@ import { getObjectEntriesForKeys } from "./index";
  * @returns {{ eventObject: object, qoeEventObject: object|null }}
  */
 export function buildEventObjects(
-  eventType,
-  attributes,
-  info,
-  { addTimeSinceLoad = false } = {}
-) {
+  eventType: string,
+  attributes: EventAttributes,
+  info: Record<string, any>,
+  { addTimeSinceLoad = false }: BuildEventObjectsOptions = {}
+): { eventObject: EventAttributes; qoeEventObject: EventAttributes | null } {
   const { appName, applicationID } = info;
   const { qoe, ...eventAttributes } = attributes;
   const qoeAttrs = qoe ? { ...qoe } : {};
@@ -54,7 +71,7 @@ export function buildEventObjects(
     ...otherAttrs,
   };
 
-  let qoeEventObject = null;
+  let qoeEventObject: EventAttributes | null = null;
   if (eventType === "VideoAction") {
     const metadataAttributes = getObjectEntriesForKeys(
       Constants.QOE_AGGREGATE_KEYS,
@@ -94,19 +111,19 @@ export function buildEventObjects(
  * @param {object} info - Resolved `info` from the pipeline's config global.
  * @param {{ addEvent: function }} harvester - The registered harvester for
  *   the current pipeline. Returns false if null/undefined.
- * @param {boolean} qoeEnabled 
+ * @param {boolean} qoeEnabled
  * @param {{ addTimeSinceLoad?: boolean }} [opts] - Forwarded to
  *   `buildEventObjects`.
  * @returns {boolean}
  */
 export function dispatchRecordEvent(
-  eventType,
-  attributes,
-  info,
-  harvester,
-  qoeEnabled,
-  { addTimeSinceLoad = false } = {}
-) {
+  eventType: string,
+  attributes: EventAttributes,
+  info: Record<string, any>,
+  harvester: Harvester | null | undefined,
+  qoeEnabled: boolean,
+  { addTimeSinceLoad = false }: BuildEventObjectsOptions = {}
+): boolean {
   if (!harvester) return false;
 
   const { eventObject, qoeEventObject } = buildEventObjects(

package/src/utils/{harvestTimer.js → harvestTimer.ts}

@@ -1,5 +1,22 @@
 import Log from "../log";
 
+export interface HarvestTimerOptions {
+  /** Initial tick interval in ms. */
+  interval: number;
+  /** Pipeline-specific drain callback. Awaited; the next tick is scheduled in `finally`. */
+  onTick: () => Promise<void> | void;
+  /** Prefix for the error log when `onTick` throws (e.g. "HarvestScheduler"). */
+  errorLabel: string;
+}
+
+export interface HarvestTimer {
+  start: () => void;
+  stop: () => void;
+  cancelAndReschedule: () => void;
+  updateInterval: (ms: number) => void;
+  isRunning: () => boolean;
+}
+
 /**
  * Periodic harvest timer using chained `setTimeout`. Each tick schedules the
  * next one only after the current `onTick` callback resolves — by construction
@@ -29,9 +46,9 @@ import Log from "../log";
  *   isRunning: () => boolean,
  * }}
  */
-export function createHarvestTimer({ interval, onTick, errorLabel }) {
+export function createHarvestTimer({ interval, onTick, errorLabel }: HarvestTimerOptions): HarvestTimer {
   let isStarted = false;
-  let currentTimerId = null;
+  let currentTimerId: ReturnType<typeof setTimeout> | null = null;
   let currentInterval = interval;
 
   function scheduleNext() {
@@ -40,7 +57,7 @@ export function createHarvestTimer({ interval, onTick, errorLabel }) {
       currentTimerId = null;
       try {
         await onTick();
-      } catch (error) {
+      } catch (error: any) {
         Log.error(`${errorLabel}: scheduled tick failed:`, error.message);
       } finally {
         if (isStarted) scheduleNext();
@@ -93,7 +110,7 @@ export function createHarvestTimer({ interval, onTick, errorLabel }) {
      * @param {number} ms - New interval in milliseconds. Must be a positive
      *   number; invalid values are silently ignored.
      */
-    updateInterval(ms) {
+    updateInterval(ms: number) {
       if (typeof ms !== "number" || ms <= 0) return;
       currentInterval = ms;
       if (isStarted && currentTimerId) {

package/src/utils/{index.js → index.ts}

@@ -6,7 +6,7 @@ import Log from "../log";
  * @returns {string} Harvest URL
  */
 
-export function buildUrl(fallbackUrl) {
+export function buildUrl(fallbackUrl?: string): string | null {
   try {
     if (!window.NRVIDEO || !window.NRVIDEO.info) {
       throw new Error("NRVIDEO info is not available.");
@@ -30,7 +30,7 @@ export function buildUrl(fallbackUrl) {
     return `https://${
       fallbackUrl ? fallbackUrl : beacon
     }/ins/1/${licenseKey}?&v=${pkg.version}&ref=${window.location.href}&ca=VA`;
-  } catch (error) {
+  } catch (error: any) {
     console.error(error.message);
     return null; // Return null instead of undefined
   }
@@ -43,7 +43,7 @@ export function buildUrl(fallbackUrl) {
  */
 const getCircularReplacer = () => {
   const seen = new WeakSet();
-  return (key, value) => {
+  return (key: string, value: unknown) => {
     if (typeof value === "object" && value !== null) {
       if (seen.has(value)) {
         return;
@@ -60,16 +60,16 @@ const getCircularReplacer = () => {
  * @param {*} val - A value to be converted to a JSON string.
  * @returns {string} A JSON string representation of the value, with circular references handled.
  */
-function stringify(val) {
+function stringify(val: unknown): string {
   try {
     return JSON.stringify(val, getCircularReplacer()) ?? "";
-  } catch (e) {
+  } catch (e: any) {
     Log.error("Error stringifying value:", e.message);
     return "";
   }
 }
 
-export function dataSize(data) {
+export function dataSize(data: unknown): number | undefined {
   if (typeof data === "string" && data.length) return data.length;
   if (typeof data !== "object") return undefined;
   // eslint-disable-next-line
@@ -96,7 +96,7 @@ export function dataSize(data) {
  * @param {number} status - HTTP status code
  * @returns {boolean} - True if request should be retried
  */
-export function shouldRetry(status) {
+export function shouldRetry(status: number): boolean {
   switch (status) {
     case 408: // Request Timeout
     case 429: // Too Many Requests
@@ -118,7 +118,7 @@ export function shouldRetry(status) {
  * @returns {Promise<Blob>} A Promise that resolves with a Blob of the Gzipped data.
  */
 
-export function compressPayload(payload) {
+export function compressPayload(payload: unknown): Promise<Blob> {
   const stringifiedPayload = JSON.stringify(payload);
   const stream = new Blob([stringifiedPayload]).stream();
   const compressionStream = new CompressionStream("gzip");
@@ -132,7 +132,7 @@ export function compressPayload(payload) {
  * @param {Blob|ArrayBuffer|Uint8Array} compressedData - The gzipped data to decompress.
  * @returns {Promise<object>} A Promise that resolves with the decompressed JSON object.
  */
-export async function decompressPayload(compressedData) {
+export async function decompressPayload(compressedData: Blob | ArrayBuffer | Uint8Array): Promise<unknown> {
   try {
     // Convert different input types to a stream
     let stream;
@@ -141,7 +141,7 @@ export async function decompressPayload(compressedData) {
     } else if (compressedData instanceof ArrayBuffer) {
       stream = new Blob([compressedData]).stream();
     } else if (compressedData instanceof Uint8Array) {
-      stream = new Blob([compressedData]).stream();
+      stream = new Blob([compressedData as BlobPart]).stream();
     } else {
       throw new Error("Unsupported compressed data type");
     }
@@ -156,7 +156,7 @@ export async function decompressPayload(compressedData) {
 
     // Parse JSON
     return JSON.parse(decompressedText);
-  } catch (error) {
+  } catch (error: any) {
     throw new Error(`Failed to decompress payload: ${error.message}`);
   }
 }
@@ -173,14 +173,14 @@ export async function decompressPayload(compressedData) {
  * const filtered = getObjectEntriesForKeys(['name', 'city'], data);
  * // Returns: { name: 'John', city: 'NYC' }
  */
-export function getObjectEntriesForKeys(keys, obj) {
+export function getObjectEntriesForKeys(keys: string[], obj: Record<string, unknown>): Record<string, unknown> {
     if(!keys || !Array.isArray(keys) || keys.length === 0) return obj;
     if(!obj || typeof obj !== 'object') return {};
 
-    return keys.reduce((result, key) => {
+    return keys.reduce((result: Record<string, unknown>, key) => {
         if(key in obj) {
             result[key] = obj[key];
         }
         return result;
     }, {});
-}
+}

package/src/utils/{qoeFilters.js → qoeFilters.ts}

@@ -17,6 +17,17 @@
 import Constants from "../constants";
 import Tracker from "../tracker";
 
+type QoeEvent = Record<string, any>;
+type QoeSnapshots = Record<string, Record<string, any>>;
+
+interface QoeBuffer {
+  addOrReplaceByActionNameAndViewId(actionName: string, viewId: string, event: QoeEvent): boolean;
+  addOrReplaceByActionName(actionName: string, event: QoeEvent): boolean;
+  add(event: QoeEvent): boolean;
+  findByActionNameAndViewId(actionName: string, viewId: string): QoeEvent | null;
+  findByActionName(actionName: string): QoeEvent | null;
+}
+
 /**
  * Add an event to the buffer with QOE_AGGREGATE dedup. QOE_AGGREGATE events
  * are deduplicated by `(actionName, viewId)` so multiple players sharing one
@@ -28,7 +39,7 @@ import Tracker from "../tracker";
  * @param {object} eventObject
  * @returns {boolean} True if added/replaced.
  */
-export function bufferEventWithQoeDedup(buffer, eventObject) {
+export function bufferEventWithQoeDedup(buffer: QoeBuffer, eventObject: QoeEvent): boolean {
   if (!eventObject) return false;
   if (eventObject.actionName === Tracker.Events.QOE_AGGREGATE) {
     if (eventObject.viewId) {
@@ -53,7 +64,7 @@ export function bufferEventWithQoeDedup(buffer, eventObject) {
  * @param {object} freshKpis
  * @param {string} [viewId]
  */
-export function refreshQoeKpisInBuffer(buffer, freshKpis, viewId) {
+export function refreshQoeKpisInBuffer(buffer: QoeBuffer, freshKpis: QoeEvent, viewId?: string): void {
   if (!buffer || !freshKpis) return;
   const existing = viewId
     ? buffer.findByActionNameAndViewId(Tracker.Events.QOE_AGGREGATE, viewId)
@@ -78,7 +89,7 @@ export function refreshQoeKpisInBuffer(buffer, freshKpis, viewId) {
  * @param {object} event
  * @returns {boolean}
  */
-export function qoeKpisUnchanged(snapshots, event) {
+export function qoeKpisUnchanged(snapshots: QoeSnapshots, event: QoeEvent): boolean {
   const snapshot = snapshots[event.viewId];
   if (!snapshot) return false;
   for (const key of Constants.QOE_KPI_KEYS) {
@@ -94,8 +105,8 @@ export function qoeKpisUnchanged(snapshots, event) {
  * @param {Object<string, object>} snapshots - viewId → KPI snapshot (mutated in place)
  * @param {object} event
  */
-export function saveQoeKpiSnapshot(snapshots, event) {
-  const snapshot = {};
+export function saveQoeKpiSnapshot(snapshots: QoeSnapshots, event: QoeEvent): void {
+  const snapshot: Record<string, any> = {};
   for (const key of Constants.QOE_KPI_KEYS) {
     snapshot[key] = event[key];
   }
@@ -112,9 +123,9 @@ export function saveQoeKpiSnapshot(snapshots, event) {
  * @param {NrVideoEventAggregator} buffer
  * @returns {object[]}
  */
-export function partitionByQoeCycle(drained, isQoeCycle, buffer) {
+export function partitionByQoeCycle(drained: QoeEvent[], isQoeCycle: boolean, buffer: QoeBuffer): QoeEvent[] {
   if (isQoeCycle) return drained;
-  const filtered = [];
+  const filtered: QoeEvent[] = [];
   for (const e of drained) {
     if (e.actionName === Tracker.Events.QOE_AGGREGATE) {
       buffer.add(e);
@@ -136,7 +147,7 @@ export function partitionByQoeCycle(drained, isQoeCycle, buffer) {
  * @param {boolean} isForced - When true, skip the dirty check and ship every
  *   QOE_AGGREGATE regardless of KPI sameness (final flush, CONTENT_END, etc.)
  */
-export function applyQoeDirtyFilter(filtered, snapshots, isForced) {
+export function applyQoeDirtyFilter(filtered: QoeEvent[], snapshots: QoeSnapshots, isForced: boolean): void {
   for (let i = filtered.length - 1; i >= 0; i--) {
     const e = filtered[i];
     if (e.actionName !== Tracker.Events.QOE_AGGREGATE) continue;

package/src/{videoConfiguration.js → videoConfiguration.ts}

@@ -1,9 +1,43 @@
 import Log from "./log";
 import Constants from "./constants";
-import { ENDPOINT_URL } from "./connectedDevice/connectedDeviceConstants";
+import { ENDPOINT_URL, VegaEndpoint } from "./connectedDevice/connectedDeviceConstants";
+import { ObfuscationRule } from "./obfuscate";
 
 const { COLLECTOR } = Constants;
 
+export interface NrVideoBrowserInfo {
+  region?: string;
+  beacon: string;
+  licenseKey: string;
+  applicationID?: string;
+  appName?: string;
+}
+
+export interface NrVideoBrowserConfig {
+  qoeAggregate: boolean;
+  qoeIntervalFactor: number;
+  obfuscate: ObfuscationRule[];
+}
+
+export interface NrVideoCdInfo {
+  accountId?: string;
+  applicationToken: string;
+  endpoint: VegaEndpoint;
+  appName?: string;
+  applicationID?: string;
+  deviceInfo?: unknown;
+}
+
+export interface NrVideoCdConfig {
+  qoeAggregate: boolean;
+  qoeIntervalFactor: number;
+  obfuscate: ObfuscationRule[];
+}
+
+/** Raw, unvalidated user-supplied config — shape varies by pipeline (`src`). */
+export type RawVideoConfigInfo = Record<string, any>;
+export type RawVideoConfigOptions = Record<string, any>;
+
 /**
  * Enhanced video analytics configuration system that extends the existing auth configuration.
  * Provides feature flags, retry policies, and advanced harvesting options.
@@ -16,7 +50,7 @@ class VideoConfiguration {
    * @returns {boolean} True if configuration is valid and set
    */
 
-  setConfiguration(userInfo, config, src) {
+  setConfiguration(userInfo: RawVideoConfigInfo, config?: RawVideoConfigOptions, src?: string): boolean {
     const validated = src === "Vega"
       ? this.validateVegaFields(userInfo)
       : this.validateRequiredFields(userInfo);
@@ -36,7 +70,7 @@ class VideoConfiguration {
    * @param {object} info
    * @returns {boolean} True if valid
    */
-  validateVegaFields(info) {
+  validateVegaFields(info: RawVideoConfigInfo): boolean {
     if (!info || typeof info !== "object") {
       Log.error("Configuration must be an object");
       return false;
@@ -57,7 +91,7 @@ class VideoConfiguration {
    * @param {object} config - Configuration to validate
    * @returns {boolean} True if valid
    */
-  validateRequiredFields(info) {
+  validateRequiredFields(info: RawVideoConfigInfo): boolean {
     if (!info || typeof info !== "object") {
       Log.error("Configuration must be an object");
       return false;
@@ -107,7 +141,7 @@ class VideoConfiguration {
    * @param {object} config - Config to validate
    * @returns {boolean} True if valid
    */
-  validateConfigFields(config) {
+  validateConfigFields(config?: RawVideoConfigOptions): boolean {
     if (config === null || config === undefined) {
       return true;
     }
@@ -137,7 +171,7 @@ class VideoConfiguration {
    * @param {Array} rules - Raw obfuscation rules
    * @returns {Array} Valid rules only
    */
-  filterObfuscateRules(rules) {
+  filterObfuscateRules(rules?: any[]): ObfuscationRule[] {
     if (!rules) return [];
     return rules.filter((rule) => {
       const hasRegex = rule.regex !== undefined && (typeof rule.regex === "string" || rule.regex instanceof RegExp);
@@ -156,7 +190,7 @@ class VideoConfiguration {
    * @param {*} value
    * @returns {number}
    */
-  sanitizeQoeIntervalFactor(value) {
+  sanitizeQoeIntervalFactor(value: unknown): number {
     if (value === undefined || value === null) return Constants.DEFAULT_QOE_INTERVAL_FACTOR;
     if (typeof value === "number" && Number.isInteger(value) && value >= 1) return value;
     Log.warn(`Invalid qoeIntervalFactor "${value}" — must be a positive integer. Defaulting to ${Constants.DEFAULT_QOE_INTERVAL_FACTOR}.`);
@@ -168,7 +202,7 @@ class VideoConfiguration {
    * @param {object} userInfo - User provided configuration
    * @param {object} [config] - Optional configuration object
    */
-  initializeGlobalConfig(userInfo, config, src) {
+  initializeGlobalConfig(userInfo: RawVideoConfigInfo, config?: RawVideoConfigOptions, src?: string): void {
     // Vega path: write `globalThis.__NRVIDEO_CD__` with info+config only.
     // The harvester is owned by `connectedDeviceAgent.js` as a module singleton — no
     // harvester field on this global.
@@ -194,7 +228,7 @@ class VideoConfiguration {
     let { licenseKey, appName, region, beacon, applicationID } = userInfo;
 
     if (region === "US") {
-      beacon = Constants.COLLECTOR["US"][0];
+      beacon = (Constants.COLLECTOR["US"] as string[])[0];
     } else {
       beacon = beacon || COLLECTOR[region];
     }
@@ -226,7 +260,7 @@ const videoConfiguration = new VideoConfiguration();
  * @param {object} [config] - Optional configuration object
  * @returns {boolean} True if configuration was set successfully
  */
-export function setVideoConfig(info, config, src) {
+export function setVideoConfig(info: RawVideoConfigInfo, config?: RawVideoConfigOptions, src?: string): boolean {
   return videoConfiguration.setConfiguration(info, config, src);
 }