@newrelic/video-core 5.0.2 → 5.1.0

package/dist/types/browser/agent.d.ts

@@ -0,0 +1,46 @@
+import { HarvestScheduler } from "./harvestScheduler";
+import { NrVideoEventAggregator } from "../eventAggregator";
+import { EventAttributes, Harvester } from "../utils/eventBuilder";
+/**
+ * Enhanced video analytics agent with HarvestScheduler only.
+ */
+declare class VideoAnalyticsAgent implements Harvester {
+    isInitialized: boolean;
+    harvestScheduler: HarvestScheduler | null;
+    eventBuffer: NrVideoEventAggregator | null;
+    constructor();
+    /**
+     * Initializes the video analytics agent with enhanced HarvestScheduler.
+     */
+    initialize(): void;
+    /**
+     * Adds an event to the harvesting system.
+     * @param {object} eventObject - Event to add
+     * @returns {boolean} True if event was added successfully
+     */
+    addEvent(eventObject: EventAttributes): boolean;
+    /**
+     * Sets the harvest interval for the scheduler.
+     * @param {number} interval - The harvest interval in milliseconds.
+     */
+    setHarvestInterval(interval: number): void;
+    /**
+     * Forces the next harvest cycle to include QOE_AGGREGATE events.
+     * Called at CONTENT_END to ensure final QoE is sent.
+     */
+    forceNextQoeCycle(): void;
+    /**
+     * Sets a callback to be called before each drain to refresh QoE KPIs.
+     * @param {Function|null} callback - Function that refreshes QoE data in the buffer, or null to clear
+     */
+    setBeforeDrainCallback(callback: (() => void) | null): void;
+    /**
+     * Updates QoE KPI fields on the existing QOE_AGGREGATE event in the buffer.
+     * Scoped to a specific viewId to support multiple players on the same page.
+     * @param {object} freshKpis - Object with latest KPI values
+     * @param {string} [viewId] - The viewId of the player whose QoE event to update
+     */
+    refreshQoeKpis(freshKpis: EventAttributes, viewId?: string): void;
+}
+export declare const videoAnalyticsHarvester: VideoAnalyticsAgent;
+export {};

package/dist/types/browser/harvestScheduler.d.ts

@@ -0,0 +1,125 @@
+import { NrVideoEventAggregator } from "../eventAggregator";
+import { RetryQueueHandler } from "../retryQueueHandler";
+import { OptimizedHttpClient } from "../optimizedHttpClient";
+import { HarvestTimer } from "../utils/harvestTimer";
+import { EventAttributes } from "../utils/eventBuilder";
+interface HarvestOptions {
+    isFinalHarvest?: boolean;
+    force?: boolean;
+}
+interface HarvestResult {
+    success: boolean;
+    reason?: string;
+    totalChunks?: number;
+    results?: any[];
+    error?: string;
+}
+/**
+ * Enhanced harvest scheduler that orchestrates the video analytics data collection,
+ * processing, and transmission with smart harvesting and performance monitoring.
+ */
+export declare class HarvestScheduler {
+    eventBuffer: NrVideoEventAggregator;
+    retryQueueHandler: RetryQueueHandler;
+    httpClient: OptimizedHttpClient;
+    fallBackUrl: string;
+    retryCount: number;
+    harvestCycle: number;
+    isHarvesting: boolean;
+    qoeCycleCount: number;
+    forceNextQoeCycle: boolean;
+    beforeDrainCallback: (() => void) | null;
+    _lastSentQoeKpis: Record<string, any>;
+    timer: HarvestTimer;
+    constructor(eventAggregator: NrVideoEventAggregator);
+    /**
+     * Whether the scheduler is currently running. Backed by the shared timer.
+     * @returns {boolean}
+     */
+    get isStarted(): boolean;
+    /**
+     * Starts the harvest scheduler.
+     */
+    startScheduler(): void;
+    /**
+     * Stops the harvest scheduler.
+     */
+    stopScheduler(): void;
+    /**
+     * Triggers a smart harvest when buffer reaches threshold capacity.
+     * @param {string} type - Type of harvest trigger ('smart' or 'overflow')
+     * @param {number} threshold - Threshold percentage that triggered the harvest (60 or 90)
+     */
+    triggerSmartHarvest(type: string, threshold: number): Promise<void>;
+    /**
+     * Periodic-tick callback. Invoked by the shared harvest timer on each cycle.
+     * @private
+     */
+    onHarvestInterval(): Promise<void>;
+    /**
+     * Triggers a harvest cycle with comprehensive error handling and monitoring.
+     * @param {object} options - Harvest options
+     * @param {boolean} options.isFinalHarvest - Whether this is a final harvest on page unload
+     * @param {boolean} options.force - Force harvest even if buffer is empty
+     * @returns {Promise<object>} Harvest result
+     */
+    triggerHarvest(options?: HarvestOptions): Promise<HarvestResult>;
+    /**
+     * Trims events to fit within a specified size limit for beacon harvests.
+     * Keeps the most recent events and discards older ones.
+     * @param {Array} events - Events to trim
+     * @param {number} maxSize - Maximum payload size in bytes
+     * @returns {Array} Trimmed events that fit within size limit
+     * @private
+     */
+    trimEventsToFit(events: EventAttributes[], maxSize: number): EventAttributes[];
+    /**
+     * Drains events from the event buffer and optionally includes retry queue data.
+     * Uses fresh-events-first approach with payload limits.
+     * Filters out QOE_AGGREGATE events based on the harvest interval multiplier,
+     * always including them on the first and final harvest cycles.
+     * @param {object} options - Harvest options
+     * @returns {Array} Drained events
+     * @private
+     */
+    drainEvents(options?: HarvestOptions): EventAttributes[];
+    /**
+     * Sends a chunk of events using the optimized HTTP client.
+     * @param {Array} chunk - Events to send
+     * @param {object} options - Harvest options
+     * @param {boolean} isLastChunk - Whether this is the last chunk
+     * @returns {Promise<object>} Send result
+     * @private
+     */
+    sendChunk(chunk: EventAttributes[], options: HarvestOptions, isLastChunk: boolean): Promise<{
+        success: boolean;
+        status: number;
+        error?: string;
+        chunk: EventAttributes[];
+        eventCount: number;
+    }>;
+    /**
+     * Handles request failure and implements failover logic for US region.
+     * @param {Array} chunk - Failed chunk to add to retry queue
+     * @private
+     */
+    handleRequestFailure(chunk: EventAttributes[]): void;
+    /**
+     * Handles harvest failure scenarios.
+     * @param {Error} error - Harvest error
+     * @private
+     */
+    handleHarvestFailure(error: Error): void;
+    /**
+     * Updates the harvest interval and restarts the scheduler to apply the new interval.
+     * @param {number} newInterval - The new harvest interval in milliseconds
+     * @returns {boolean} - True if interval was updated successfully, false otherwise
+     */
+    updateHarvestInterval(newInterval: number): void;
+    /**
+     * Sets up page lifecycle event handlers.
+     * @private
+     */
+    setupPageLifecycleHandlers(): void;
+}
+export {};

package/dist/types/browser/index.d.ts

@@ -0,0 +1,34 @@
+import Core from "../core";
+import Constants from "../constants";
+import Chrono from "../chrono";
+import Log from "../log";
+import Emitter from "../emitter";
+import Tracker from "../tracker";
+import VideoTracker from "../videotracker";
+import VideoTrackerState from "../videotrackerstate";
+import { NrVideoEventAggregator } from "../eventAggregator";
+import { RetryQueueHandler } from "../retryQueueHandler";
+import { OptimizedHttpClient } from "../optimizedHttpClient";
+import { HarvestScheduler } from "./harvestScheduler";
+import { videoAnalyticsHarvester } from "./agent";
+import { getRegisteredHarvester } from "../recordEvent";
+import { recordEvent } from "../recordEvent";
+import { version } from "../../package.json";
+declare const nrvideo: {
+    Constants: typeof Constants;
+    Chrono: typeof Chrono;
+    Log: typeof Log;
+    Emitter: typeof Emitter;
+    Tracker: typeof Tracker;
+    VideoTracker: typeof VideoTracker;
+    VideoTrackerState: typeof VideoTrackerState;
+    Core: typeof Core;
+    version: string;
+    NrVideoEventAggregator: typeof NrVideoEventAggregator;
+    RetryQueueHandler: typeof RetryQueueHandler;
+    OptimizedHttpClient: typeof OptimizedHttpClient;
+    HarvestScheduler: typeof HarvestScheduler;
+    recordEvent: typeof recordEvent;
+};
+export { Core, Constants, Chrono, Log, Emitter, Tracker, VideoTracker, VideoTrackerState, NrVideoEventAggregator, RetryQueueHandler, OptimizedHttpClient, HarvestScheduler, videoAnalyticsHarvester, getRegisteredHarvester, recordEvent, version, };
+export default nrvideo;

package/dist/types/chrono.d.ts

@@ -0,0 +1,52 @@
+/**
+ * This class calculates time lapses between two points on time.
+ */
+declare class Chrono {
+    /** Start time */
+    startTime: number;
+    /** Stop time */
+    stopTime: number;
+    /** accumulation of all the start and stop intervals */
+    accumulator: number;
+    /**
+     * If you set an offset in a chrono, its value will be added getDeltaTime and stop.
+     *
+     * @example
+     * let chrono = new Chrono()
+     * chrono.offset = 500
+     * chrono.start()
+     * process.sleep(500)
+     * chrono.stop() // Will return 1000
+     *
+     * @type {number}
+     */
+    offset: number;
+    /**
+     * Constructor
+     */
+    constructor();
+    /** Reset chrono values. */
+    reset(): void;
+    /**
+     * Returns the time between start() and the last stop() in ms. Returns null if start wasn't
+     * called.
+     * @return {(number|null)} Time lapse in ms.
+     */
+    getDeltaTime(): number | null;
+    /**
+     * Starts the chrono.
+     */
+    start(): void;
+    /**
+     * Stops the timer and returns delta time.
+     * @return {(number|null)} Returns the delta time
+     */
+    stop(): number | null;
+    getDuration(): number;
+    /**
+     * Creates a copy of the chrono.
+     * @returns {Chrono} Cloned chrono
+     */
+    clone(): Chrono;
+}
+export default Chrono;

package/dist/types/connectedDevice/connectedDeviceAgent.d.ts

@@ -0,0 +1,63 @@
+import ConnectedDeviceHarvester from "./connectedDeviceHarvester";
+import { EventAttributes, Harvester } from "../utils/eventBuilder";
+/**
+ * Vega-side analytics agent. Mirror of `VideoAnalyticsAgent` in `agent.js`.
+ */
+declare class ConnectedDeviceAnalyticsAgent implements Harvester {
+    isInitialized: boolean;
+    harvester: ConnectedDeviceHarvester | null;
+    constructor();
+    /**
+     * Lazy initialization. Reads `info` from `globalThis.__NRVIDEO_CD__` and
+     * constructs the wrapped `ConnectedDeviceHarvester`. If `info` is not yet populated,
+     * returns without flipping `isInitialized` so the next `addEvent` retries.
+     */
+    initialize(): void;
+    /**
+     * Buffers an event for the wrapped ConnectedDeviceHarvester. Triggers lazy init on
+     * the first call. Drops events silently if init has not yet succeeded
+     * (defensive — under normal flow, `setVideoConfig` runs synchronously
+     * inside `super()` before any player event can fire).
+     *
+     *
+     * @param {object} eventObject
+     * @returns {boolean}
+     */
+    addEvent(eventObject: EventAttributes): boolean;
+    /**
+     * Forwards to the underlying ConnectedDeviceHarvester. No-op if not yet initialized.
+     * @see ConnectedDeviceHarvester#forceQoeNextHarvest
+     */
+    forceQoeNextHarvest(): void;
+    /**
+     * API-parity alias for `forceQoeNextHarvest`. Lets `videotracker.js` call a
+     * single method name on whichever harvester `getHarvester()` returns —
+     * Browser exposes `forceNextQoeCycle`, Vega exposes both names.
+     */
+    forceNextQoeCycle(): void;
+    /**
+     * Forwards to the underlying ConnectedDeviceHarvester. No-op if not yet initialized.
+     * @see ConnectedDeviceHarvester#setBeforeDrainCallback
+     * @param {Function|null} cb
+     */
+    setBeforeDrainCallback(cb: (() => void) | null): void;
+    /**
+     * Forwards to the underlying ConnectedDeviceHarvester. Triggers lazy init so
+     * `videotracker.js`'s drain callback (registered in sendStart) can refresh
+     * QoE on the buffered event before send.
+     *
+     * @param {object} freshKpis
+     * @param {string} [viewId]
+     */
+    refreshQoeKpis(freshKpis: EventAttributes, viewId?: string): void;
+    /**
+     * Forwards to the underlying ConnectedDeviceHarvester. Triggers lazy init so
+     * `tracker.setHarvestInterval(...)` works for VegaTracker the same way it
+     * does for other trackers.
+     *
+     * @param {number} interval
+     */
+    setHarvestInterval(interval: number): void;
+}
+export declare const connectedDeviceAnalyticsHarvester: ConnectedDeviceAnalyticsAgent;
+export {};

package/dist/types/connectedDevice/connectedDeviceConstants.d.ts

@@ -0,0 +1,51 @@
+export type VegaEndpoint = "us" | "eu" | "staging" | "gov" | "jp";
+/**
+ * Maps region key (lowercase) directly to the regional mobile collector base URL.
+ * Accepts global.region.key values: us, eu, gov, jp, staging.
+ */
+export declare const ENDPOINT_URL: Record<VegaEndpoint, string>;
+/** Default harvest cadence in ms. */
+export declare const DEFAULT_HARVEST_TIME = 60000;
+/** Default in-memory event-buffer cap (informational; aggregator enforces
+ *  MAX_EVENTS_PER_BATCH / MAX_PAYLOAD_SIZE). */
+export declare const DEFAULT_BUFFER_SIZE = 100;
+/** Maximum number of /v5/connect attempts before giving up. */
+export declare const CD_CONNECT_MAX_ATTEMPTS = 3;
+/** Fixed delay between /v5/connect retry attempts in ms.
+ *  10s gives the device network stack enough time to recover after
+ *  wake-from-sleep before the next attempt fires. */
+export declare const CD_CONNECT_RETRY_DELAY_MS = 10000;
+/** Hard timeout for POST /v5/connect. A hung connect holds _isFetchingToken=true
+ *  forever, blocking all future reconnect attempts. */
+export declare const CD_CONNECT_TIMEOUT_MS = 10000;
+/** Hard timeout for POST /v3/data. A hung data send holds isHarvesting=true,
+ *  freezing the chained harvest timer until the fetch resolves. */
+export declare const CD_DATA_TIMEOUT_MS = 30000;
+/**
+ * Positional 2-tuple sent as the body of `POST /v5/connect`.
+ *   [
+ *     appInfo[3]     = [appName, appVersion, bundleId],
+ *     deviceInfo[10] = [osName, osVersion, deviceModel, agentName,
+ *                       agentVersion, deviceUuid, "", "",
+ *                       manufacturer, sizeMeta]
+ *   ]
+ *
+ * DATA_TOKENS_PAYLOAD shape — empty strings are rejected with a 401,
+ * every slot must carry a non-empty token. Uses `osName='Android'` +
+ * `agentName='AndroidAgent'` for collector auth; the real device identity
+ * is recorded in slot [1] / slot [8] of `/v3/data`.
+ */
+export declare const CD_DATA_TOKENS_PAYLOAD: any[];
+/**
+ * Slot [1] of the `POST /v3/data` 10-tuple. Real device identity tuple
+ * (Vega + Amazon by default). Customer-supplied `info.deviceInfo` overrides
+ * the runtime fields; static slots (osName, agentName, etc.) stay fixed.
+ */
+export declare const CD_DEVICE_INFO: any[];
+export declare const CD_METADATA: {
+    osBuild: string;
+    osName: string;
+    platform: string;
+    appBuild: string;
+    architecture: string;
+};

package/dist/types/connectedDevice/connectedDeviceHarvester.d.ts

@@ -0,0 +1,198 @@
+import { NrVideoEventAggregator } from "../eventAggregator";
+import { VegaEndpoint } from "./connectedDeviceConstants";
+import { HarvestTimer } from "../utils/harvestTimer";
+import { EventAttributes } from "../utils/eventBuilder";
+export interface ConnectedDeviceHarvesterOptions {
+    accountId?: string;
+    applicationToken: string;
+    endpoint: string;
+    deviceInfo?: Record<string, any>;
+}
+interface DeviceInfo {
+    uuid: any;
+    osVersion: any;
+    deviceModel: any;
+    deviceManufacturer: any;
+    osBuild: any;
+    appBuild: any;
+    architecture: any;
+}
+/**
+ * Generic NR mobile-collector harvester for the connected-device pipeline
+ * (`/v5/connect` + `/v3/data`).
+ *
+ * The class is **not Vega-specific** — it owns the HTTP client, dataToken,
+ * harvest setInterval, and event buffer for any consumer that needs to ship
+ * to NR's mobile collector. Vega-specific routing/lifecycle is provided by
+ * the wrapper `ConnectedDeviceAnalyticsAgent` in `connectedDeviceAgent.js`.
+ *
+ */
+export default class ConnectedDeviceHarvester {
+    accountId?: string;
+    applicationToken: string;
+    endpoint: VegaEndpoint;
+    harvestInterval: number;
+    maxBufferSize: number;
+    deviceInfo: DeviceInfo;
+    eventBuffer: NrVideoEventAggregator;
+    dataToken: string | null;
+    isHarvesting: boolean;
+    isDisposed: boolean;
+    _isFetchingToken: boolean;
+    timer: HarvestTimer;
+    qoeCycleCount: number;
+    forceQoeNextCycle: boolean;
+    beforeDrainCallback: (() => void) | null;
+    _lastSentQoeKpis: Record<string, any>;
+    _connectAttempt: number;
+    /**
+     * @param {object} opts
+     * @param {string} [opts.accountId]         Captured for parity with CAF; not transmitted.
+     * @param {string} opts.applicationToken    Sent as `X-App-License-Key` header.
+     * @param {string} opts.endpoint            One of `US`, `EU`, `staging`.
+     * @param {object} [opts.deviceInfo]        Customer-collected device identity. Any of:
+     *   uuid, osVersion, deviceModel, deviceManufacturer, osBuild, appBuild, architecture.
+     *   Each field optional — missing values fall back to placeholders from
+     *   `connectedDeviceConstants.js`. Extra fields are ignored. The customer is
+     *   expected to source these from a platform device-info library (e.g.
+     *   `@amazon-devices/react-native-device-info` on Kepler) and pass the
+     *   resulting object once at construction. `osBuild` is the OS image build
+     *   (e.g., `getBuildIdSync()`); `appBuild` is the consumer app's build
+     *   number (e.g., `getBuildNumber()`).
+     */
+    constructor({ accountId, applicationToken, endpoint, deviceInfo, }?: Partial<ConnectedDeviceHarvesterOptions>);
+    /**
+     * Returns the regional mobile collector base URL for the configured endpoint.
+     * Each region routes to its own datacenter — EU events terminate on EU
+     * infrastructure rather than transiting through the US host.
+     *
+     * @returns {string}
+     */
+    getEndpointBaseUrl(): string;
+    /**
+     * Two-phase init: fetch dataToken, then start harvest interval.
+     * @returns {Promise<void>}
+     */
+    initialise(): Promise<void>;
+    /**
+     * POST `/v5/connect` to obtain a dataToken. Retries up to
+     * CD_CONNECT_MAX_ATTEMPTS times with a fixed CD_CONNECT_RETRY_DELAY_MS
+     * wait between attempts.
+     *
+     * Iterative loop keeps the call stack flat across all attempts.
+     * `_isFetchingToken` guard ensures only one connect sequence runs at a
+     * time — if `initialise()` (startup) and the 401-refresh path in
+     * `sendBufferedEvents` both call this concurrently, the second call
+     * returns immediately without issuing a duplicate POST.
+     *
+     * @returns {Promise<void>}
+     */
+    fetchDataTokens(): Promise<void>;
+    /**
+     * Starts the periodic harvest timer.
+     * Idempotent — safe to call repeatedly.
+     */
+    startHarvestInterval(): void;
+    /**
+     * Smart-harvest handler. Invoked by `NrVideoEventAggregator` when the buffer
+     * crosses 60% (`type='smart'`) or 90% (`type='overflow'`) of capacity, before
+     * `makeRoom()` would start FIFO-evicting events. Drains the buffer immediately
+     * and resets the periodic clock so the next scheduled tick fires
+     * `harvestInterval` after this drain completes.
+     *
+     * @param {'smart'|'overflow'} type
+     * @param {number} threshold - The threshold percentage that triggered the harvest (60 or 90).
+     * @returns {Promise<void>}
+     */
+    triggerSmartHarvest(type: string, threshold: number): Promise<void>;
+    /**
+     * Buffers an event for the next harvest cycle.
+     *
+     * @param {object} eventObject
+     * @returns {boolean}
+     */
+    addEvent(eventObject: EventAttributes): boolean;
+    /**
+     * Forces the next harvest cycle to ship QOE_AGGREGATE regardless of cycle
+     * multiplier or dirty check. Used at CONTENT_END for final QoE flush.
+     */
+    forceQoeNextHarvest(): void;
+    /**
+     * Registers a callback invoked at the start of every send cycle, before
+     * the buffer is drained. Lets the tracker refresh QoE KPIs in the buffer
+     * before they ship.
+     * @param {Function|null} cb
+     */
+    setBeforeDrainCallback(cb: (() => void) | null): void;
+    /**
+     * Updates QoE KPI fields on the existing QOE_AGGREGATE event in the buffer.
+     * Mirror of `VideoAnalyticsAgent#refreshQoeKpis` (`agent.js`) so VegaTracker's
+     * QoE drain wiring can route here through `getHarvester()`.
+     *
+     * @param {object} freshKpis - Object with latest KPI values
+     * @param {string} [viewId] - The viewId of the player whose QoE event to update
+     */
+    refreshQoeKpis(freshKpis: EventAttributes, viewId?: string): void;
+    /**
+     * Updates the harvest cadence at runtime. If the periodic timer is already
+     * running, it is cleared and restarted with the new interval. Mirror of
+     * `VideoAnalyticsAgent#setHarvestInterval` (`agent.js`).
+     *
+     * @param {number} interval - New cadence in ms.
+     */
+    setHarvestInterval(interval: number): void;
+    /**
+     * Drains the buffer and POSTs to `/v3/data`. Applies the QoE cycle filter
+     * and cross-cycle dirty check before send.
+     *
+     * Mirror of `harvestScheduler.js` drain + send logic, adapted for the CAF
+     * 10-tuple wire format and plain `fetch` transport.
+     *
+     *
+     * @returns {Promise<void>}
+     */
+    sendBufferedEvents(): Promise<void>;
+    /**
+     * Build slot [1] of /v3/data — the 10-element device-info tuple. Customer-
+     * supplied fields override the static defaults from CD_DEVICE_INFO; missing
+     * or empty fields fall through to the placeholders that ship in
+     * connectedDeviceConstants.js.
+     * @returns {Array}
+     * @private
+     */
+    _buildDeviceInfo(): any[];
+    /**
+     * Build slot [8] of /v3/data — the session-metadata object. Spreads the
+     * static `CD_METADATA` defaults (`osName`, `platform`, `appBuild`) and
+     * overrides only `osBuild` and `architecture` from the customer-supplied
+     * deviceInfo. Device-identity fields (osVersion, deviceModel,
+     * deviceManufacturer, osMajorVersion, platformVersion) live in slot [1]
+     * (`CD_DEVICE_INFO`) and are intentionally not duplicated here.
+     * @returns {object}
+     * @private
+     */
+    _buildMetadata(): Record<string, any>;
+    /**
+     * Wraps `fetch` with an AbortController deadline. If no response arrives
+     * within `timeoutMs`, the controller aborts the request and the returned
+     * Promise rejects with an AbortError. The caller's existing `catch` block
+     * handles it identically to any other network failure — connect retries for
+     * /v5/connect, event re-queue for /v3/data.
+     *
+     * `clearTimeout` in `.finally()` cancels the pending abort when the fetch
+     * completes before the deadline, so the abort never fires spuriously.
+     *
+     * @param {string} url
+     * @param {RequestInit} options
+     * @param {number} timeoutMs
+     * @returns {Promise<Response>}
+     * @private
+     */
+    _fetchWithTimeout(url: string, options: RequestInit, timeoutMs: number): Promise<Response>;
+    /**
+     * Stops the harvest interval and attempts one final best-effort send.
+     * @returns {Promise<void>}
+     */
+    dispose(): Promise<void>;
+}
+export {};

package/dist/types/connectedDevice/index.d.ts

@@ -0,0 +1,30 @@
+import Core from "../core";
+import Constants from "../constants";
+import Chrono from "../chrono";
+import Log from "../log";
+import Emitter from "../emitter";
+import Tracker from "../tracker";
+import VideoTracker from "../videotracker";
+import VideoTrackerState from "../videotrackerstate";
+import { NrVideoEventAggregator } from "../eventAggregator";
+import ConnectedDeviceHarvester from "./connectedDeviceHarvester";
+import { connectedDeviceAnalyticsHarvester } from "./connectedDeviceAgent";
+import { getRegisteredHarvester } from "../recordEvent";
+import { recordEvent } from "../recordEvent";
+import { version } from "../../package.json";
+declare const nrvideo: {
+    Constants: typeof Constants;
+    Chrono: typeof Chrono;
+    Log: typeof Log;
+    Emitter: typeof Emitter;
+    Tracker: typeof Tracker;
+    VideoTracker: typeof VideoTracker;
+    VideoTrackerState: typeof VideoTrackerState;
+    Core: typeof Core;
+    version: string;
+    NrVideoEventAggregator: typeof NrVideoEventAggregator;
+    ConnectedDeviceHarvester: typeof ConnectedDeviceHarvester;
+    recordEvent: typeof recordEvent;
+};
+export { Core, Constants, Chrono, Log, Emitter, Tracker, VideoTracker, VideoTrackerState, NrVideoEventAggregator, ConnectedDeviceHarvester, connectedDeviceAnalyticsHarvester, getRegisteredHarvester, recordEvent, version, };
+export default nrvideo;

package/dist/types/constants.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Constants for the library.
+ * @class Constants
+ * @static
+ */
+declare class Constants {
+    /**
+     * Enum for types/positions of ads.
+     * @example var type = Constants.AdPositions.PRE
+     * @enum {String}
+     */
+    static AdPositions: {
+        /** For ads shown before the content. */
+        PRE: string;
+        /** For ads shown during the content. */
+        MID: string;
+        /** For ads shown after the content. */
+        POST: string;
+    };
+    static COLLECTOR: Record<string, string | string[]>;
+    static VALID_EVENT_TYPES: string[];
+    static MAX_PAYLOAD_SIZE: number;
+    static MAX_BEACON_SIZE: number;
+    static MAX_EVENTS_PER_BATCH: number;
+    static INTERVAL: number;
+    static DEFAULT_QOE_INTERVAL_FACTOR: number;
+    static QOE_KPI_KEYS: string[];
+    static QOE_AGGREGATE_KEYS: string[];
+}
+export default Constants;