@glomex/integration-analytics 1.1480.0 → 1.1481.0

package/dist/npaw/npaw-turbo-player-ad-adapter.d.ts

@@ -0,0 +1,43 @@
+import { type IntegrationElement, type IntegrationElementEventMap } from '@glomex/integration-web-component';
+import type { AdapterAd } from './npaw-types';
+declare module './npaw-turbo-player-ad-adapter' {
+    interface NpawTurboPlayerAdAdapter extends AdapterAd {
+        player: IntegrationElement;
+    }
+}
+type AdapterEventListeners = {
+    [K in keyof IntegrationElementEventMap]?: (event: IntegrationElementEventMap[K]) => void;
+};
+export declare class NpawTurboPlayerAdAdapter {
+    _refs?: AdapterEventListeners;
+    getVersion(): string;
+    getPlayerVersion(): string;
+    getPlayhead(): number;
+    getTitle(): string;
+    getTitle2(): string | undefined;
+    getCreativeId(): string | null;
+    getProvider(): string | null;
+    getAdInsertionType(): string;
+    getDuration(): number | null;
+    getBreaksTime(): null;
+    getResource(): string;
+    getGivenAds(): number | null;
+    getAudioEnabled(): boolean;
+    getIsSkippable(): boolean;
+    getIsFullscreen(): boolean;
+    getIsVisible(): boolean;
+    getPosition(): string | null;
+    registerListeners(): void;
+    unregisterListeners(): void;
+    _isSupportedAd(): boolean | undefined;
+    impressionListener(): void;
+    pausedListener(): void;
+    resumedListener(): void;
+    bufferingStartListener(): void;
+    bufferingEndListener(): void;
+    completeListener(): void;
+    clickListener(): void;
+    skippedListener(): void;
+    errorListener(event: IntegrationElementEventMap['aderror']): void;
+}
+export {};

package/dist/npaw/npaw-turbo-player-ad-adapter.js

@@ -0,0 +1,142 @@
+import { IntegrationEvent } from '@glomex/integration-web-component';
+import { version } from './package-info';
+export class NpawTurboPlayerAdAdapter {
+    _refs;
+    getVersion() {
+        return `turbo-ad-v${version}`;
+    }
+    getPlayerVersion() {
+        return this.player.version;
+    }
+    getPlayhead() {
+        return this.player.adCurrentTime;
+    }
+    getTitle() {
+        return this.player.currentAd?.title || '';
+    }
+    getTitle2() {
+        return this.player.currentAd?.advertiserName || undefined;
+    }
+    getCreativeId() {
+        return this.player.currentAd?.creativeId || null;
+    }
+    getProvider() {
+        return this.player.currentAd?.adSystem || null;
+    }
+    getAdInsertionType() {
+        return 'client-side';
+    }
+    getDuration() {
+        return this.player.currentAd?.duration || this.player.adDuration || null;
+    }
+    getBreaksTime() {
+        return null; // maybe returning the ad markers
+    }
+    getResource() {
+        return this.player.currentAd?.adUrl || 'unknown';
+    }
+    getGivenAds() {
+        return this.player.currentAd?.totalAds || null;
+    }
+    getAudioEnabled() {
+        return Boolean(!this.player.adMuted);
+    }
+    getIsSkippable() {
+        return this.player.currentAd?.skippable || false;
+    }
+    getIsFullscreen() {
+        return this.player.presentationMode === 'fullscreen';
+    }
+    getIsVisible() {
+        return this.getNpawUtils().calculateAdViewability(this.player);
+    }
+    getPosition() {
+        if (this.player.currentAd?.breakName === 'preroll') {
+            return this.getNpawReference().Constants.AdPosition.Preroll;
+        }
+        if (this.player.currentAd?.breakName === 'midroll') {
+            return this.getNpawReference().Constants.AdPosition.Midroll;
+        }
+        if (this.player.currentAd?.breakName === 'postroll') {
+            return this.getNpawReference().Constants.AdPosition.Postroll;
+        }
+        return null;
+    }
+    registerListeners() {
+        this._refs = {
+            [IntegrationEvent.AD_IMPRESSION]: this.impressionListener.bind(this),
+            [IntegrationEvent.AD_RESUMED]: this.resumedListener.bind(this),
+            [IntegrationEvent.AD_PAUSED]: this.pausedListener.bind(this),
+            [IntegrationEvent.AD_BUFFERING_START]: this.bufferingStartListener.bind(this),
+            [IntegrationEvent.AD_BUFFERING_END]: this.bufferingEndListener.bind(this),
+            [IntegrationEvent.AD_CLICK]: this.clickListener.bind(this),
+            [IntegrationEvent.AD_SKIPPED]: this.skippedListener.bind(this),
+            [IntegrationEvent.AD_COMPLETE]: this.completeListener.bind(this),
+            [IntegrationEvent.AD_ERROR]: this.errorListener.bind(this)
+        };
+        for (const type of Object.keys(this._refs)) {
+            const handler = this._refs?.[type];
+            // If your IntegrationElement has typed addEventListener<K extends keyof IntegrationElementEventMap>(
+            //   type: K, listener: (ev: IntegrationElementEventMap[K]) => any
+            // ), this will be fully type-safe
+            this.player.addEventListener(type, handler);
+        }
+    }
+    unregisterListeners() {
+        for (const type of Object.keys(this._refs || {})) {
+            const handler = this._refs?.[type];
+            this.player.removeEventListener(type, handler);
+        }
+        this._refs = undefined;
+    }
+    _isSupportedAd() {
+        // for now we do not track non-linear ads
+        return this.player.currentAd?.isLinear;
+    }
+    impressionListener() {
+        if (!this._isSupportedAd())
+            return;
+        this.fireStart({}, 'impressionListener');
+        this.fireJoin({}, 'impressionListener');
+    }
+    pausedListener() {
+        if (!this._isSupportedAd())
+            return;
+        this.firePause({}, IntegrationEvent.AD_PAUSED);
+    }
+    resumedListener() {
+        if (!this._isSupportedAd())
+            return;
+        this.fireResume({}, IntegrationEvent.AD_RESUMED);
+    }
+    bufferingStartListener() {
+        if (!this._isSupportedAd())
+            return;
+        this.fireBufferBegin({}, true, IntegrationEvent.AD_BUFFERING_START);
+    }
+    bufferingEndListener() {
+        if (!this._isSupportedAd())
+            return;
+        this.fireBufferEnd({}, IntegrationEvent.AD_BUFFERING_END);
+    }
+    completeListener() {
+        if (!this._isSupportedAd())
+            return;
+        this.fireStop({}, IntegrationEvent.AD_COMPLETE);
+    }
+    clickListener() {
+        if (!this._isSupportedAd())
+            return;
+        this.fireClick(this.player.currentAd?.clickThroughUrl || '');
+    }
+    skippedListener() {
+        if (!this._isSupportedAd())
+            return;
+        this.fireSkip();
+    }
+    errorListener(event) {
+        if (!this._isSupportedAd())
+            return;
+        this.fireError(event.detail.error.code, event.detail.error.message);
+    }
+}

package/dist/npaw/npaw-turbo-player-adapter.d.ts

@@ -0,0 +1,47 @@
+import type { IntegrationElement } from '@glomex/integration-web-component';
+import { type IntegrationElementEventMap } from '@glomex/integration-web-component';
+import { NpawTurboPlayerAdAdapter } from './npaw-turbo-player-ad-adapter';
+import type { AdapterContent } from './npaw-types';
+declare module './npaw-turbo-player-adapter' {
+    interface NpawTurboPlayerAdapter extends AdapterContent {
+        player: IntegrationElement;
+    }
+}
+type AdapterEventListeners = {
+    [K in keyof IntegrationElementEventMap]?: (event: IntegrationElementEventMap[K]) => void;
+};
+export declare class NpawTurboPlayerAdapter {
+    _refs?: AdapterEventListeners;
+    adsAdapters: {
+        npawTurboPlayerAdAdapter: typeof NpawTurboPlayerAdAdapter;
+    };
+    getPlayerName(): string;
+    getVersion(): string;
+    getPlayerVersion(): string;
+    getResource(): string | null;
+    getTitle(): string | null;
+    getDuration(): number;
+    getPlayhead(): number;
+    getPlayrate(): number;
+    getIsLive(): boolean;
+    getBitrate(): number | null;
+    getLatency(): number | undefined;
+    getRendition(): string;
+    getThroughput(): number | undefined;
+    getDroppedFrames(): number | undefined;
+    getTotalBytes(): number | null;
+    registerListeners(): void;
+    unregisterListeners(): void;
+    contentStart(): void;
+    contentImpression(): void;
+    playListener(): void;
+    pauseListener(): void;
+    seekingListener(): void;
+    seekedListener(): void;
+    contentBufferStart(): void;
+    contentBufferEnd(): void;
+    contentStop(): void;
+    contentSelect(): void;
+    contentError(event: IntegrationElementEventMap['contenterror']): void;
+}
+export {};

package/dist/npaw/npaw-turbo-player-adapter.js

@@ -0,0 +1,136 @@
+import { IntegrationEvent, Mimetype, PlaybackMode } from '@glomex/integration-web-component';
+import { NpawTurboPlayerAdAdapter } from './npaw-turbo-player-ad-adapter';
+import { version } from './package-info';
+export class NpawTurboPlayerAdapter {
+    _refs;
+    adsAdapters = {
+        npawTurboPlayerAdAdapter: NpawTurboPlayerAdAdapter
+    };
+    getPlayerName() {
+        return 'turbo-player';
+    }
+    getVersion() {
+        return `turbo-v${version}`;
+    }
+    getPlayerVersion() {
+        return this.player.version;
+    }
+    getResource() {
+        return this.player.source?.src || null;
+    }
+    getTitle() {
+        return this.player.content?.title || null;
+    }
+    getDuration() {
+        return this.player.duration;
+    }
+    getPlayhead() {
+        return this.getIsLive() ? this.player.wallClockTime : this.player.currentTime;
+    }
+    getPlayrate() {
+        return 1;
+    }
+    getIsLive() {
+        return this.player.content?.sources[0]?.playbackMode === PlaybackMode.LIVE;
+    }
+    getBitrate() {
+        return this.player.getVideoPlaybackQuality()?.bitrate || null;
+    }
+    getLatency() {
+        return this.player.getVideoPlaybackQuality()?.liveLatency;
+    }
+    getRendition() {
+        const { width, height, bandwidth } = this.player.getVideoPlaybackQuality() || {};
+        if (width && height && bandwidth) {
+            return this.getNpawUtils().buildRenditionString(width, height, bandwidth);
+        }
+        // without a value youbora triggers "init" event instead of "start"
+        return 'unknown';
+    }
+    getThroughput() {
+        return this.player.getVideoPlaybackQuality()?.throughput;
+    }
+    getDroppedFrames() {
+        return this.player.getVideoPlaybackQuality()?.droppedVideoFrames;
+    }
+    getTotalBytes() {
+        return this.player.getVideoPlaybackQuality()?.bytes || null;
+    }
+    registerListeners() {
+        this._refs = {
+            [IntegrationEvent.CONTENT_PLAY]: this.playListener.bind(this),
+            [IntegrationEvent.CONTENT_PAUSE]: this.pauseListener.bind(this),
+            [IntegrationEvent.CONTENT_SEEKING]: this.seekingListener.bind(this),
+            [IntegrationEvent.CONTENT_SEEKED]: this.seekedListener.bind(this),
+            [IntegrationEvent.CONTENT_BUFFERING_START]: this.contentBufferStart.bind(this),
+            [IntegrationEvent.CONTENT_BUFFERING_END]: this.contentBufferEnd.bind(this),
+            [IntegrationEvent.CONTENT_START]: this.contentStart.bind(this),
+            [IntegrationEvent.CONTENT_IMPRESSION]: this.contentImpression.bind(this),
+            [IntegrationEvent.CONTENT_STOP]: this.contentStop.bind(this),
+            [IntegrationEvent.CONTENT_SELECT]: this.contentSelect.bind(this),
+            [IntegrationEvent.CONTENT_ERROR]: this.contentError.bind(this)
+        };
+        for (const type of Object.keys(this._refs)) {
+            const handler = this._refs?.[type];
+            // If your IntegrationElement has typed addEventListener<K extends keyof IntegrationElementEventMap>(
+            //   type: K, listener: (ev: IntegrationElementEventMap[K]) => any
+            // ), this will be fully type-safe
+            this.player.addEventListener(type, handler);
+        }
+        this.plugin.setAdsAdapter(this.getAdapterClass('npawTurboPlayerAdAdapter'), this.getVideo().getVideoKey());
+    }
+    unregisterListeners() {
+        for (const type of Object.keys(this._refs || {})) {
+            const handler = this._refs?.[type];
+            this.player.removeEventListener(type, handler);
+        }
+        this._refs = undefined;
+        this.plugin.removeAdsAdapter(this.getVideo().getVideoKey());
+    }
+    contentStart() {
+        const { options } = this.getVideo();
+        const streamingProtocol = this.player.source?.mimetype === Mimetype.DASH
+            ? 'DASH'
+            : this.player.source?.mimetype === Mimetype.HLS
+                ? 'HLS'
+                : undefined;
+        options['content.id'] = this.player.source?.id || this.player.content?.id;
+        options['content.streamingProtocol'] = streamingProtocol;
+        options['content.playbackType'] = this.player.source?.playbackMode;
+        options['content.tvShow'] = this.player.content?.show?.name;
+        options['content.season'] = this.player.content?.show?.seasonNumber;
+        options['content.language'] = this.player.content?.language;
+        this.fireStart({}, IntegrationEvent.CONTENT_START);
+    }
+    contentImpression() {
+        this.fireJoin({}, IntegrationEvent.CONTENT_IMPRESSION);
+    }
+    playListener() {
+        this.fireResume({}, IntegrationEvent.CONTENT_PLAY);
+        this.plugin.getAdsAdapter().fireAdBreakStop({});
+    }
+    pauseListener() {
+        this.firePause({}, 'pauseListener');
+    }
+    seekingListener() {
+        this.fireSeekBegin({}, true, IntegrationEvent.CONTENT_SEEKING);
+    }
+    seekedListener() {
+        this.fireSeekEnd({}, IntegrationEvent.CONTENT_SEEKED);
+    }
+    contentBufferStart() {
+        this.fireBufferBegin({}, true, IntegrationEvent.CONTENT_BUFFERING_START);
+    }
+    contentBufferEnd() {
+        this.fireBufferEnd({}, IntegrationEvent.CONTENT_BUFFERING_END);
+    }
+    contentStop() {
+        this.fireStop({}, IntegrationEvent.CONTENT_STOP);
+    }
+    contentSelect() {
+        this.fireStop({}, IntegrationEvent.CONTENT_SELECT);
+    }
+    contentError(event) {
+        this.fireFatalError(event.detail.error.code, event.detail.error.message, undefined, 'fatal', IntegrationEvent.CONTENT_ERROR);
+    }
+}

package/dist/npaw/npaw-types.d.ts

@@ -0,0 +1,202 @@
+/**
+ * Interfaces gathered from the npm module npaw-plugin by generating source from the contained sourcemap.
+ *
+ * @see https://www.npmjs.com/package/npaw-plugin
+ */
+export interface Adapter {
+    flags: AdapterFlags;
+    monitor: PlayheadMonitor | null;
+    player: unknown;
+    plugin: {
+        getAdsAdapter(): AdapterAd;
+        setAdsAdapter(adapterClass: unknown, videoKey: string): void;
+        removeAdsAdapter(videoKey?: string): void;
+    };
+    getVideo(): {
+        getVideoKey(): string;
+        removeAdsAdapter(videoKey?: string): void;
+        options: Record<string, unknown>;
+    };
+    getNpawUtils(): {
+        calculateAdViewability(player: HTMLElement): boolean;
+        buildRenditionString(width: number, height: number, bitrate: number): string;
+    };
+    getNpawReference(): {
+        Constants: {
+            AdPosition: {
+                Preroll: string;
+                Midroll: string;
+                Postroll: string;
+            };
+        };
+    };
+    setPlayer(player: unknown): void;
+    registerListeners(): void;
+    unregisterListeners(): void;
+    monitorPlayhead(monitorBuffers: boolean, monitorSeeks: boolean, interval?: number): void;
+    stopMonitor(): void;
+    monitorReadyState(intervalMilliseconds?: number): void;
+    startReadyStateMonitor(): void;
+    stopReadyStateMonitor(): void;
+    checkReadyState(readyState: number | null | undefined, triggeredEvent?: string): void;
+    getPlugin(): unknown;
+    getLog(): unknown;
+    isStarted(): boolean;
+    getAdapterClass(className: string): unknown;
+    getAdapterName(adapterObject?: unknown): string;
+    getAdapterNameFromClass(adapterClass?: unknown): string;
+    getAdapterClasses(): Record<string, unknown>;
+    getPlayhead(): number | null;
+    getDuration(): number | null;
+    getBitrate(): number | null;
+    getTotalBytes(): number | null;
+    getTitle(): string | null;
+    getResource(): string | null;
+    getPlayerVersion(): string | null;
+    getPlayerName(): string | null;
+    getVersion(): string;
+    getVideoObject(): unknown | null;
+    getLastUsedCdn(): string | undefined;
+    checkExistsPlayer(): boolean;
+    checkExistsObjectOnPage(object: unknown): boolean;
+    fireInit(params?: Record<string, unknown>, triggeredEvent?: string): void;
+    fireStart(params?: Record<string, unknown>, triggeredEvent?: string): void;
+    fireJoin(params?: Record<string, unknown>, triggeredEvent?: string): void;
+    firePause(params?: Record<string, unknown>, triggeredEvent?: string): void;
+    fireResume(params?: Record<string, unknown>, triggeredEvent?: string): void;
+    fireBufferBegin(params?: Record<string, unknown>, convertFromSeek?: boolean, triggeredEvent?: string, triggeredByStateProperty?: boolean): void;
+    fireBufferEnd(params?: Record<string, unknown>, triggeredEvent?: string): void;
+    cancelBuffer(params?: Record<string, unknown>): void;
+    fireStop(params?: Record<string, unknown>, triggeredEvent?: string): void;
+    firePlayerLog(playerEvent: string, playerData: unknown): void;
+    setIsAds(value: boolean): void;
+    fireCasted(params?: Record<string, unknown>, triggeredEvent?: string): void;
+    fireError(code?: string | number | Record<string, unknown>, msg?: string, metadata?: Record<string, unknown>, level?: string, triggeredEvent?: string, fatalError?: boolean, duration?: number): void;
+    fireFatalError(code?: string | number | Record<string, unknown>, msg?: string, metadata?: Record<string, unknown>, level?: string, triggeredEvent?: string, duration?: number): void;
+    isLegacyBufferBehaviourEnabled(): boolean;
+}
+export interface AdapterContent extends Adapter {
+    getPlayrate(): number;
+    getFramesPerSecond(): number | undefined;
+    getDroppedFrames(): number | undefined;
+    getThroughput(): number | undefined;
+    getRendition(): unknown | undefined;
+    getTitle2(): string | undefined;
+    getIsLive(): boolean | undefined;
+    getCdnTraffic(): number | undefined;
+    getP2PTraffic(): number | undefined;
+    getUploadTraffic(): number | undefined;
+    getIsP2PEnabled(): boolean | undefined;
+    getSegmentDuration(): number | undefined;
+    getHouseholdId(): string | undefined;
+    getLatency(): number | undefined;
+    getPacketLoss(): number | undefined;
+    getPacketSent(): number | undefined;
+    getMetrics(): Record<string, unknown> | undefined;
+    getAudioCodec(): string | undefined;
+    getVideoCodec(): string | undefined;
+    setUrlToParse(url: string): void;
+    getURLToParse(): string | undefined;
+    fireSeekBegin(params?: Record<string, unknown>, convertFromBuffer?: boolean, triggeredEvent?: string): void;
+    fireSeekEnd(params?: Record<string, unknown>, triggeredEvent?: string): void;
+    cancelSeek(params?: Record<string, unknown>): void;
+    fireEvent(eventName: string, dimensions?: Record<string, unknown>, values?: Record<string, unknown>, topLevelDimensions?: Record<string, unknown>, hasEndDatetime?: boolean): void;
+    fireEventEnd(eventName: string): void;
+    storeNewRendition(rendition: unknown): void;
+}
+export type AdPosition = string | number | null;
+export interface AdBreaksCount {
+    pre?: number;
+    mid?: number;
+    post?: number;
+}
+/**
+ * Structure of ads requested. This is intentionally generic because the source
+ * only states "structure of ads requested" without a concrete schema.
+ */
+export type AdPattern = unknown;
+export type AdInsertionType = string | null;
+export interface AdapterAd extends AdapterContent {
+    /** Current ad position */
+    getPosition(): AdPosition;
+    /** Given ad structure (number of pre/mid/post breaks) */
+    getGivenBreaks(): AdBreaksCount | null;
+    /** Expected ad structure (number of pre/mid/post breaks) */
+    getExpectedBreaks(): AdBreaksCount | null;
+    /** Structure of ads requested */
+    getExpectedPattern(): AdPattern | null;
+    /** Playheads (in seconds or ms, depending on implementation) of ad break start times */
+    getBreaksTime(): number[] | null;
+    /** Number of ads given for the current break */
+    getGivenAds(): number | null;
+    /** Number of ads requested for the current break */
+    getExpectedAds(): number | null;
+    /**
+     * Whether the ad is visible on screen (standard: >50% pixels visible)
+     * Defaults to true in the base mixin.
+     */
+    getIsVisible(): boolean;
+    /** Whether audio is enabled when the ad begins */
+    getAudioEnabled(): boolean | null;
+    /** Whether the ad is skippable */
+    getIsSkippable(): boolean | null;
+    /** Whether the player is fullscreen when the ad begins */
+    getIsFullscreen(): boolean | null;
+    /** Ad campaign identifier/name */
+    getCampaign(): string | null;
+    /** Ad creative ID */
+    getCreativeId(): string | null;
+    /** Ad provider name */
+    getProvider(): string | null;
+    /** Ad insertion type (client-side/server-side) */
+    getAdInsertionType(): AdInsertionType;
+    /**
+     * Fire a click event.
+     * If a string is passed, it is treated as the URL: params = { url: string }.
+     */
+    fireClick(params?: Record<string, unknown> | string): void;
+    /**
+     * Fire a quartile event (0..3). Increments `lastQuartileSent` internally.
+     */
+    fireQuartile(quartile: number): void;
+    /** Start visibility/view tracking chrono for ads */
+    startChronoView(): void;
+    /** Stop visibility/view tracking chrono for ads */
+    stopChronoView(): void;
+    /**
+     * Fire a manifest-related event. If first arg is string, it is treated as errorType
+     * and `message` is used as errorMessage.
+     */
+    fireManifest(params?: Record<string, unknown> | string, message?: string): void;
+    /**
+     * Mark ad as skipped and fire stop with params.skipped = true
+     */
+    fireSkip(params?: Record<string, unknown>): void;
+    /** Alias to fireAdBreakStart */
+    fireBreakStart(params?: Record<string, unknown>): void;
+    /** Alias to fireAdBreakStop */
+    fireBreakStop(params?: Record<string, unknown>): void;
+    /** Fire Ad Break (Pod) start */
+    fireAdBreakStart(params?: Record<string, unknown>): void;
+    /** Fire Ad Break (Pod) stop */
+    fireAdBreakStop(params?: Record<string, unknown>): void;
+}
+interface PlayheadMonitor {
+    stop(): void;
+    skipNextTick(): void;
+    progress(): void;
+}
+interface AdapterFlags {
+    initCalled: boolean;
+    isStarted: boolean;
+    isStopped: boolean;
+    isJoined: boolean;
+    isBuffering: boolean;
+    isSeeking: boolean;
+    isPaused: boolean;
+    isAdPaused: boolean;
+    isEnded: boolean;
+    isVideoStateBuffering: boolean;
+    lastQuartileSent: number;
+}
+export {};

package/dist/npaw/npaw-types.js

@@ -0,0 +1,6 @@
+/**
+ * Interfaces gathered from the npm module npaw-plugin by generating source from the contained sourcemap.
+ *
+ * @see https://www.npmjs.com/package/npaw-plugin
+ */
+export {};

package/dist/npaw/package-info.d.ts

@@ -0,0 +1,2 @@
+declare const version: string;
+export { version };

package/dist/npaw/package-info.js

@@ -0,0 +1,3 @@
+import packageJson from '../../package.json';
+const { version } = packageJson;
+export { version };

package/dist/sensic/index.d.ts

@@ -0,0 +1,89 @@
+import { type IntegrationElement } from '@glomex/integration-web-component';
+/**
+ * Configuration options for Sensic analytics integration
+ */
+export interface SensicOptions {
+    /** Sensic media identifier */
+    media: string;
+    /** Platform type: 'web' or 'tv' */
+    platform: 'web' | 'tv';
+    /**
+     * Two-letter country code for loading the appropriate Sensic script.
+     * Any country code is supported as long as the corresponding Sensic script exists.
+     * The country code also determines the default data mapping for custom parameters and stream ID.
+     * @example 'at' - Austria (uses GfK AT specific data mapping)
+     * @example 'de' - Germany
+     */
+    country: string;
+    /** Optional callback for warning messages */
+    warnCallback?: (error: Error) => void;
+    /**
+     * Callback to build custom parameters for tracking.
+     * Called on each stream start (VoD content, live content, and linear ads).
+     * Receives the country-specific custom params as input, allowing override/extension.
+     *
+     * @param customParams - The country-specific custom params (e.g., AT params for Austria)
+     * @returns Custom parameters as key-value pairs, or `null`/`undefined` to skip tracking this stream
+     * @default Returns country-specific params unchanged
+     *
+     * @example
+     * ```ts
+     * buildCustomParams: (customParams) => ({
+     *   ...customParams,
+     *   genre: integration.content?.genre ?? '',
+     *   showId: integration.content?.show?.id ?? ''
+     * })
+     * ```
+     */
+    buildCustomParams?: (customParams: Record<string, string>) => Record<string, string> | null | undefined;
+    /**
+     * Callback to build the stream ID for tracking.
+     * Called on each stream start (VoD content, live content, and linear ads).
+     * Receives the country-specific stream ID as input, allowing override.
+     *
+     * @param streamId - The country-specific stream ID
+     * @returns The stream ID to use for tracking
+     * @default Returns country-specific stream ID unchanged
+     *
+     * @example
+     * ```ts
+     * buildStreamId: (streamId) => streamId || integration.content?.id ?? ''
+     * ```
+     */
+    buildStreamId?: (streamId: string) => string;
+}
+/** @deprecated Use SensicOptions instead */
+export interface SensicProviderOptions {
+    /** Sensic media identifier */
+    media: string;
+    /** Platform type: 'web' or 'tv' */
+    platform: 'web' | 'tv';
+    /** Optional callback for warning messages */
+    warnCallback?: (error: Error) => void;
+}
+/**
+ * Connects Sensic analytics integration to a turbo player integration.
+ *
+ * Sensic (formerly GfK) provides streaming measurement for video content.
+ * This integration automatically tracks playback events and reports them
+ * to Sensic's S2S (Server-to-Server) measurement system.
+ *
+ * @param integration - The integration element to connect to
+ * @param options - Sensic configuration options
+ * @returns A cleanup function to disconnect the integration
+ *
+ * @example
+ * ```ts
+ * import { connectToSensic } from '@glomex/integration-analytics/sensic';
+ *
+ * const disconnect = connectToSensic(integration, {
+ *   media: 'your-media-id',
+ *   platform: 'web',
+ *   country: 'de'
+ * });
+ *
+ * // Later, to disconnect:
+ * disconnect();
+ * ```
+ */
+export declare const connectToSensic: (integration: IntegrationElement, options: SensicOptions) => (() => void);