@dotcms/analytics 1.2.0 → 1.2.1-next.2

package/lib/core/shared/constants/dot-analytics.constants.js

@@ -0,0 +1,53 @@
+const I = "/api/v1/analytics/content/event", c = {
+  PAGEVIEW: "pageview",
+  CONTENT_IMPRESSION: "content_impression",
+  CONTENT_CLICK: "content_click",
+  CONVERSION: "conversion"
+}, s = [
+  "utm_source",
+  "utm_medium",
+  "utm_campaign",
+  "utm_term",
+  "utm_content"
+], o = 30, e = "dot_analytics_session_id", N = "dot_analytics_user_id", E = 15, _ = 5e3, L = ["click"], O = {
+  eventBatchSize: E,
+  // Max events per batch - auto-sends when reached
+  flushInterval: _
+  // Time between flushes - sends whatever is queued
+}, i = [
+  "title",
+  "url",
+  "path",
+  "hash",
+  "search",
+  "width",
+  "height",
+  "referrer"
+], t = 0.5, T = 750, n = 100, S = 100, A = 250, C = {
+  visibilityThreshold: t,
+  dwellMs: T,
+  maxNodes: n,
+  throttleMs: S
+}, U = "content_impression", M = "content_click", D = 300, R = "a, button", a = "dotcms-analytics-contentlet";
+export {
+  L as ACTIVITY_EVENTS,
+  a as ANALYTICS_CONTENTLET_CLASS,
+  I as ANALYTICS_ENDPOINT,
+  i as ANALYTICS_JS_DEFAULT_PROPERTIES,
+  R as CLICKABLE_ELEMENTS_SELECTOR,
+  M as CLICK_EVENT_TYPE,
+  D as DEFAULT_CLICK_THROTTLE_MS,
+  C as DEFAULT_IMPRESSION_CONFIG,
+  T as DEFAULT_IMPRESSION_DWELL_MS,
+  n as DEFAULT_IMPRESSION_MAX_NODES,
+  A as DEFAULT_IMPRESSION_MUTATION_OBSERVER_DEBOUNCE_MS,
+  S as DEFAULT_IMPRESSION_THROTTLE_MS,
+  t as DEFAULT_IMPRESSION_VISIBILITY_THRESHOLD,
+  O as DEFAULT_QUEUE_CONFIG,
+  o as DEFAULT_SESSION_TIMEOUT_MINUTES,
+  c as DotCMSPredefinedEventType,
+  s as EXPECTED_UTM_KEYS,
+  U as IMPRESSION_EVENT_TYPE,
+  e as SESSION_STORAGE_KEY,
+  N as USER_ID_KEY
+};

package/lib/core/shared/constants/index.d.ts

@@ -1,4 +1,4 @@
 /**
  * Central export point for all DotCMS Analytics constants
  */
-export * from './dot-content-analytics.constants';
+export * from './dot-analytics.constants';

package/lib/core/shared/dot-analytics.logger.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Log level type for the DotLogger
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+/**
+ * Log level constants for convenient usage
+ */
+export declare const LOG_LEVELS: {
+    readonly DEBUG: "debug";
+    readonly INFO: "info";
+    readonly WARN: "warn";
+    readonly ERROR: "error";
+};
+/**
+ * Custom logger for DotCMS SDK
+ * Provides structured logging with context identification and configurable log level filtering
+ *
+ * @example
+ * ```typescript
+ * const logger = new DotLogger('Analytics', 'Impression', 'info');
+ * logger.debug('This will not show'); // Below threshold
+ * logger.info('Tracker initialized'); // Shows
+ * logger.error('Failed to track'); // Shows
+ * ```
+ */
+export declare class DotLogger {
+    private readonly packageName;
+    private readonly context;
+    private readonly minLevel;
+    constructor(packageName: string, context: string, minLevel?: LogLevel);
+    /**
+     * Creates the formatted prefix for log messages
+     * Format: [DotCMS PackageName | Context] [LEVEL]
+     */
+    private getPrefix;
+    /**
+     * Checks if a log level should be displayed based on the minimum threshold
+     */
+    private shouldLog;
+    /**
+     * Log a DEBUG level message
+     * Used for detailed debugging information
+     */
+    debug(...args: unknown[]): void;
+    /**
+     * Log an INFO level message
+     * Used for general informational messages
+     */
+    info(...args: unknown[]): void;
+    /**
+     * Log a WARN level message
+     * Used for warning messages that don't prevent operation
+     */
+    warn(...args: unknown[]): void;
+    /**
+     * Log an ERROR level message
+     * Always logs regardless of threshold for critical errors
+     */
+    error(...args: unknown[]): void;
+    /**
+     * Create a console group for organizing related log messages
+     * Respects the minimum log level threshold
+     */
+    group(label: string): void;
+    /**
+     * End the current console group
+     * Respects the minimum log level threshold
+     */
+    groupEnd(): void;
+    /**
+     * Start a timer with the given label
+     * Useful for performance measurements
+     */
+    time(label: string): void;
+    /**
+     * End a timer and log the elapsed time
+     * Useful for performance measurements
+     */
+    timeEnd(label: string): void;
+    /**
+     * Log a message (alias for info)
+     * Provided for backward compatibility
+     */
+    log(...args: unknown[]): void;
+}

package/lib/core/shared/dot-analytics.logger.js

@@ -0,0 +1,90 @@
+const o = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+class r {
+  constructor(e, i, t = "warn") {
+    this.packageName = e, this.context = i, this.minLevel = t;
+  }
+  /**
+   * Creates the formatted prefix for log messages
+   * Format: [DotCMS PackageName | Context] [LEVEL]
+   */
+  getPrefix(e) {
+    return `[DotCMS ${this.packageName} | ${this.context}] [${e.toUpperCase()}]`;
+  }
+  /**
+   * Checks if a log level should be displayed based on the minimum threshold
+   */
+  shouldLog(e) {
+    return o[e] >= o[this.minLevel];
+  }
+  /**
+   * Log a DEBUG level message
+   * Used for detailed debugging information
+   */
+  debug(...e) {
+    this.shouldLog("debug") && console.log(this.getPrefix("debug"), ...e);
+  }
+  /**
+   * Log an INFO level message
+   * Used for general informational messages
+   */
+  info(...e) {
+    this.shouldLog("info") && console.info(this.getPrefix("info"), ...e);
+  }
+  /**
+   * Log a WARN level message
+   * Used for warning messages that don't prevent operation
+   */
+  warn(...e) {
+    this.shouldLog("warn") && console.warn(this.getPrefix("warn"), ...e);
+  }
+  /**
+   * Log an ERROR level message
+   * Always logs regardless of threshold for critical errors
+   */
+  error(...e) {
+    console.error(this.getPrefix("error"), ...e);
+  }
+  /**
+   * Create a console group for organizing related log messages
+   * Respects the minimum log level threshold
+   */
+  group(e) {
+    this.shouldLog("debug") && console.group(`${this.getPrefix("debug")} ${e}`);
+  }
+  /**
+   * End the current console group
+   * Respects the minimum log level threshold
+   */
+  groupEnd() {
+    this.shouldLog("debug") && console.groupEnd();
+  }
+  /**
+   * Start a timer with the given label
+   * Useful for performance measurements
+   */
+  time(e) {
+    this.shouldLog("debug") && console.time(`${this.getPrefix("debug")} ${e}`);
+  }
+  /**
+   * End a timer and log the elapsed time
+   * Useful for performance measurements
+   */
+  timeEnd(e) {
+    this.shouldLog("debug") && console.timeEnd(`${this.getPrefix("debug")} ${e}`);
+  }
+  /**
+   * Log a message (alias for info)
+   * Provided for backward compatibility
+   */
+  log(...e) {
+    this.info(...e);
+  }
+}
+export {
+  r as DotLogger
+};

package/lib/core/shared/http/dot-analytics.http.d.ts

@@ -0,0 +1,9 @@
+import { DotCMSAnalyticsConfig, DotCMSAnalyticsRequestBody } from '../models';
+/**
+ * Send analytics events to the server using fetch API
+ * @param payload - The event payload data
+ * @param config - The analytics configuration
+ * @param keepalive - Use keepalive mode for page unload scenarios (default: false)
+ * @returns A promise that resolves when the request is complete
+ */
+export declare const sendAnalyticsEvent: (payload: DotCMSAnalyticsRequestBody, config: DotCMSAnalyticsConfig, keepalive?: boolean) => Promise<void>;

package/lib/core/shared/http/dot-analytics.http.js

@@ -0,0 +1,34 @@
+import { ANALYTICS_ENDPOINT as f } from "../constants/dot-analytics.constants.js";
+import { createPluginLogger as T } from "../utils/dot-analytics.utils.js";
+const h = async (n, a, i = !1) => {
+  const r = T("HTTP", a), c = `${a.server}${f}`, g = JSON.stringify(n);
+  r.info(`Sending ${n.events.length} event(s)${i ? " (keepalive)" : ""}`, {
+    payload: n
+  });
+  try {
+    const e = {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: g
+    };
+    if (i) {
+      e.keepalive = !0, e.credentials = "omit", fetch(c, e);
+      return;
+    }
+    const t = await fetch(c, e);
+    if (!t.ok) {
+      const p = t.statusText || "Unknown Error", o = `HTTP ${t.status}: ${p}`;
+      try {
+        const s = await t.json();
+        s.message ? r.warn(`${s.message} (${o})`) : r.warn(`${o} - No error message in response`);
+      } catch (s) {
+        r.warn(`${o} - Failed to parse error response:`, s);
+      }
+    }
+  } catch (e) {
+    r.error("Error sending event:", e);
+  }
+};
+export {
+  h as sendAnalyticsEvent
+};

package/lib/core/shared/models/data.model.d.ts

@@ -89,7 +89,7 @@ export interface DotCMSEventUtmData {
     id?: string;
 }
 /**
- * Page data structure for DotCMS analytics.
+ * Page data structure for DotCMS analytics (used in pageview events).
  * Contains comprehensive information about the current page and its context
  * within the DotCMS environment.
  */
@@ -101,3 +101,41 @@ export type DotCMSEventPageData = Pick<DotCMSBrowserData, 'url' | 'doc_path' | '
     /** Persona identifier */
     persona?: string;
 };
+/**
+ * Minimal page data for content impression events.
+ * Contains only essential page information (title and url) to keep payload lightweight.
+ */
+export type DotCMSContentImpressionPageData = Pick<DotCMSEventPageData, 'title' | 'url'>;
+/**
+ * Data structure for content impression events.
+ * Tracks when a contentlet becomes visible in the viewport.
+ */
+export interface DotCMSImpressionEventData {
+    /** Contentlet identification data extracted from data-dot-analytics-* attributes */
+    contentlet: {
+        /** Unique identifier of the contentlet */
+        identifier: string;
+        /** Inode of the contentlet */
+        inode: string;
+        /** Content type name */
+        contentType: string;
+        /** Title of the contentlet */
+        title: string;
+        /** Base type of the contentlet (e.g., CONTENT, WIDGET) */
+        baseType: string;
+    };
+    /** Viewport position and visibility metrics */
+    viewport: {
+        /** Percentage offset from top of viewport (0-100) */
+        offsetPercentage: number;
+        /** Percentage of element visible in viewport (0-1) */
+        visibilityRatio: number;
+    };
+    /** Timing information about the impression */
+    timing: {
+        /** Time in milliseconds the element was continuously visible */
+        dwellTime: number;
+        /** ISO 8601 timestamp when the impression was fired */
+        timestamp: string;
+    };
+}

package/lib/core/shared/models/event.model.d.ts

@@ -1,5 +1,5 @@
-import { DotCMSEventPageData, DotCMSEventUtmData } from './data.model';
-import { DotCMSCustomEventType, DotCMSEventType, DotCMSPredefinedEventType } from '../constants/dot-content-analytics.constants';
+import { DotCMSContentImpressionPageData, DotCMSEventPageData, DotCMSEventUtmData } from './data.model';
+import { DotCMSCustomEventType, DotCMSEventType, DotCMSPredefinedEventType } from '../constants/dot-analytics.constants';
 /**
  * JSON value type for analytics custom data.
  * Represents any valid JSON value that can be serialized and sent to the analytics server.
@@ -50,15 +50,120 @@ export type DotCMSCustomEventData = {
     /** Custom data associated with the event (any valid JSON) */
     custom: JsonObject;
 };
+/**
+ * Element information for analytics events.
+ * Base type for element metadata in click and conversion events.
+ */
+export type DotCMSElementData = {
+    /** Text content of the element */
+    text: string;
+    /** Type of element (anchor, button, input, etc.) */
+    type: string;
+    /** Element ID (required by backend, empty string if not present) */
+    id: string;
+    /** Element classes (required by backend, empty string if not present) */
+    class: string;
+    /** Link destination as written in HTML (relative path, only for <a> elements, empty string for buttons) */
+    href: string;
+    /** Additional element attributes in key:value format (e.g., ['data-category:val', 'data-campaign:val2']) */
+    attributes: string[];
+};
+/**
+ * Partial content impression data sent by producer plugins.
+ * Contains only impression-specific data (content and position).
+ * The enricher plugin will add page data automatically.
+ */
+export type DotCMSContentImpressionPayload = {
+    /** Content information */
+    content: {
+        /** Content identifier */
+        identifier: string;
+        /** Content inode */
+        inode: string;
+        /** Content title */
+        title: string;
+        /** Content type name */
+        content_type: string;
+    };
+    /** Position information in the viewport and DOM */
+    position: {
+        /** Viewport offset percentage from top */
+        viewport_offset_pct: number;
+        /** DOM index position */
+        dom_index: number;
+    };
+};
+/**
+ * Partial content click data sent by producer plugins.
+ * Extends impression payload with element metadata.
+ */
+export type DotCMSContentClickPayload = DotCMSContentImpressionPayload & {
+    /** Clicked element information */
+    element: DotCMSElementData;
+};
+/**
+ * Conversion payload sent when tracking conversions.
+ * Contains conversion name and optional custom data.
+ */
+export type DotCMSConversionPayload = {
+    /** Name of the conversion event */
+    name: string;
+    /** Optional custom user data (any valid JSON) */
+    custom?: JsonObject;
+};
+/**
+ * Complete data structure for content impression events after enrichment.
+ * Includes minimal page data (title and url) added by the enricher plugin.
+ */
+export type DotCMSContentImpressionEventData = DotCMSContentImpressionPayload & {
+    /** Minimal page data where the impression occurred (added by enricher) */
+    page: DotCMSContentImpressionPageData;
+};
+/**
+ * Complete data structure for content click events after enrichment.
+ * Includes minimal page data (title and url) added by the enricher plugin.
+ */
+export type DotCMSContentClickEventData = DotCMSContentClickPayload & {
+    /** Minimal page data where the click occurred (added by enricher) */
+    page: DotCMSContentImpressionPageData;
+};
+/**
+ * Complete data structure for conversion events after enrichment.
+ * Includes page data added by the enricher plugin.
+ */
+export type DotCMSConversionEventData = {
+    /** Conversion information */
+    conversion: {
+        /** Name of the user-defined conversion */
+        name: string;
+    };
+    /** Page data where the conversion occurred (added by enricher) */
+    page: DotCMSContentImpressionPageData;
+    /** Optional custom user data (any valid JSON) */
+    custom?: JsonObject;
+};
 /**
  * Pageview event structure.
  */
 export type DotCMSPageViewEvent = DotCMSEventBase<typeof DotCMSPredefinedEventType.PAGEVIEW, DotCMSPageViewEventData>;
+/**
+ * Content impression event structure.
+ */
+export type DotCMSContentImpressionEvent = DotCMSEventBase<typeof DotCMSPredefinedEventType.CONTENT_IMPRESSION, DotCMSContentImpressionEventData>;
+/**
+ * Content click event structure.
+ */
+export type DotCMSContentClickEvent = DotCMSEventBase<typeof DotCMSPredefinedEventType.CONTENT_CLICK, DotCMSContentClickEventData>;
+/**
+ * Conversion event structure.
+ */
+export type DotCMSConversionEvent = DotCMSEventBase<typeof DotCMSPredefinedEventType.CONVERSION, DotCMSConversionEventData>;
 /**
  * Custom event structure.
  */
 export type DotCMSCustomEvent = DotCMSEventBase<DotCMSCustomEventType, DotCMSCustomEventData>;
 /**
  * Union type for all possible analytics events.
+ * Used primarily for type documentation and validation.
  */
-export type DotCMSEvent = DotCMSPageViewEvent | DotCMSCustomEvent;
+export type DotCMSEvent = DotCMSPageViewEvent | DotCMSContentImpressionEvent | DotCMSContentClickEvent | DotCMSConversionEvent | DotCMSCustomEvent;

package/lib/core/shared/models/library.model.d.ts

@@ -1,7 +1,7 @@
-import { DotCMSAnalyticsEventContext, DotCMSEventPageData, DotCMSEventUtmData } from './data.model';
-import { JsonObject } from './event.model';
+import { DotCMSAnalyticsEventContext, DotCMSContentImpressionPageData, DotCMSEventPageData, DotCMSEventUtmData } from './data.model';
+import { DotCMSContentImpressionPayload, JsonObject } from './event.model';
 import { DotCMSAnalyticsRequestBody } from './request.model';
-import { DotCMSCustomEventType } from '../constants';
+import { LogLevel } from '../dot-analytics.logger';
 /**
  * Configuration for event queue management.
  * Controls how events are batched before sending to the server.
@@ -12,22 +12,62 @@ export interface QueueConfig {
     /** Time in milliseconds between flushes - sends pending events (default: 5000) */
     flushInterval?: number;
 }
+/**
+ * Configuration for content impression tracking.
+ * Controls how content visibility is detected and tracked.
+ */
+export interface ImpressionConfig {
+    /** Minimum percentage of element visible (0.0 to 1.0) - default: 0.5 */
+    visibilityThreshold?: number;
+    /** Minimum time in milliseconds element must be visible - default: 750 */
+    dwellMs?: number;
+    /** Maximum number of elements to track (performance limit) - default: 1000 */
+    maxNodes?: number;
+    /** Throttle time in milliseconds for intersection callbacks - default: 100 */
+    throttleMs?: number;
+}
+/**
+ * Interface for contentlet data extracted from DOM elements
+ */
+export interface ContentletData {
+    identifier: string;
+    inode: string;
+    contentType: string;
+    title: string;
+    baseType: string;
+}
+/**
+ * Interface for viewport metrics
+ */
+export interface ViewportMetrics {
+    offsetPercentage: number;
+    visibilityRatio: number;
+}
 /**
  * Main interface for the DotCMS Analytics SDK.
- * Provides the core methods for tracking page views and custom events.
+ * Provides the core methods for tracking page views, custom events, and conversions.
  */
 export interface DotCMSAnalytics {
     /**
      * Track a page view event.
      * @param payload - Optional custom data to include with the page view (any valid JSON object)
      */
-    pageView: (payload?: JsonObject) => void;
+    pageView(): void;
+    pageView(payload: JsonObject): void;
     /**
      * Track a custom event.
      * @param eventName - The name/type of the event to track
      * @param payload - Custom data to include with the event (any valid JSON object)
      */
-    track: (eventName: string, payload: JsonObject) => void;
+    track(eventName: string): void;
+    track(eventName: string, payload: JsonObject): void;
+    /**
+     * Track a conversion event.
+     * @param name - Name of the conversion (e.g., 'purchase', 'download', 'signup')
+     * @param options - Optional custom data and element information
+     */
+    conversion(name: string): void;
+    conversion(name: string, options: JsonObject): void;
 }
 /**
  * Configuration interface for DotCMS Analytics SDK.
@@ -42,6 +82,16 @@ export interface DotCMSAnalyticsConfig {
      * Enable debug mode to get additional logging information.
      */
     debug: boolean;
+    /**
+     * Set the minimum log level for console output.
+     * - 'debug': Show all logs including detailed debugging information
+     * - 'info': Show informational messages, warnings, and errors
+     * - 'warn': Show only warnings and errors
+     * - 'error': Show only errors
+     *
+     * If not specified, falls back to debug flag (debug=true → 'debug', debug=false → 'warn')
+     */
+    logLevel?: LogLevel;
     /**
      * Automatically track page views when set to true.
      */
@@ -57,15 +107,28 @@ export interface DotCMSAnalyticsConfig {
      * - `QueueConfig`: Enable queuing with custom settings
      */
     queue?: QueueConfig | boolean;
+    /**
+     * Content impression tracking configuration (default: undefined - disabled):
+     * - `undefined` or `false`: Impression tracking disabled
+     * - `true`: Enable with default settings (threshold: 0.5, dwell: 750ms, maxNodes: 1000)
+     * - `ImpressionConfig`: Enable with custom settings
+     */
+    impressions?: ImpressionConfig | boolean;
+    /**
+     * Content click tracking configuration (default: undefined - disabled):
+     * - `undefined` or `false`: Click tracking disabled
+     * - `true`: Enable click tracking
+     */
+    clicks?: boolean;
 }
 /**
  * Track event payload with context.
- * This is the payload for custom track events after the identity plugin adds context.
+ * This is the payload for track events after the identity plugin adds context.
  * Used in the track:dot-analytics enricher plugin.
  */
 export interface AnalyticsTrackPayloadWithContext extends AnalyticsBasePayload {
-    /** The custom event name (any string except 'pageview') */
-    event: DotCMSCustomEventType;
+    /** The event name (can be predefined or custom) */
+    event: string;
     /** Analytics context added by identity plugin */
     context: DotCMSAnalyticsEventContext;
 }
@@ -84,29 +147,16 @@ type AnalyticsBasePayloadType = 'page' | 'track';
  * Analytics.js hook parameter types for DotCMS.
  * Represents the payload structure used by Analytics.js lifecycle hooks
  * for intercepting and modifying analytics events.
+ *
+ * Properties are flexible (Record<string, unknown>) to support both:
+ * - Page events: with page-specific fields (title, url, path, etc.)
+ * - Track events: with any custom event data structure
  */
 export interface AnalyticsBasePayload {
     /** The type of analytics event */
     type: AnalyticsBasePayloadType;
-    /** Properties associated with the event */
-    properties: {
-        /** Page title */
-        title: string;
-        /** Page URL */
-        url: string;
-        /** Page path */
-        path: string;
-        /** URL hash fragment */
-        hash: string;
-        /** URL search parameters */
-        search: string;
-        /** Viewport width */
-        width: number;
-        /** Viewport height */
-        height: number;
-        /** Referrer URL */
-        referrer?: string;
-    };
+    /** Properties associated with the event (flexible structure) */
+    properties: Record<string, unknown>;
     /** Configuration options for the event */
     options: Record<string, unknown>;
     /** User identifier */
@@ -146,6 +196,17 @@ export type EnrichedAnalyticsPayload = AnalyticsBasePayloadWithContext & {
     /** Local timestamp when the event occurred */
     local_time: string;
 };
+/**
+ * Enriched track event payload with fields added to root based on event type.
+ * Used by the enricher plugin for track events.
+ */
+export interface EnrichedTrackPayload extends AnalyticsTrackPayloadWithContext {
+    local_time: string;
+    page?: DotCMSContentImpressionPageData | DotCMSEventPageData;
+    content?: DotCMSContentImpressionPayload['content'];
+    position?: DotCMSContentImpressionPayload['position'];
+    utm?: DotCMSEventUtmData;
+}
 /**
  * Analytics.js instance structure for DotCMS.
  * Represents the internal structure of an Analytics.js instance,

package/lib/core/shared/models/request.model.d.ts

@@ -1,24 +1,32 @@
 import { DotCMSAnalyticsEventContext } from './data.model';
-import { DotCMSCustomEvent, DotCMSEvent, DotCMSPageViewEvent } from './event.model';
+import { DotCMSEvent } from './event.model';
 /**
  * Analytics request body for DotCMS Analytics.
  * Generic structure sent to the DotCMS analytics server.
+ *
+ * This structure contains properly typed events that match the DotCMS event specifications.
+ * Events can be pageviews, content impressions, or custom events, each with their own data structure.
  */
-export interface DotCMSRequestBody<T extends DotCMSEvent> {
+export interface DotCMSRequestBody {
     /** Context information shared across all events */
     context: DotCMSAnalyticsEventContext;
     /** Array of analytics events to be tracked */
-    events: T[];
+    events: DotCMSEvent[];
 }
 /**
- * Specific request body type for PageView events
+ * Main type for analytics request bodies.
+ * Flexible enough to accept any event type (pageview, content_impression, custom, etc.)
  */
-export type DotCMSPageViewRequestBody = DotCMSRequestBody<DotCMSPageViewEvent>;
+export type DotCMSAnalyticsRequestBody = DotCMSRequestBody;
 /**
- * Specific request body type for Custom events
+ * Specific request body type for PageView events (for type documentation)
  */
-export type DotCMSCustomEventRequestBody = DotCMSRequestBody<DotCMSCustomEvent>;
+export type DotCMSPageViewRequestBody = DotCMSRequestBody;
 /**
- * Union type for all possible request bodies
+ * Specific request body type for ContentImpression events (for type documentation)
  */
-export type DotCMSAnalyticsRequestBody = DotCMSPageViewRequestBody | DotCMSCustomEventRequestBody;
+export type DotCMSContentImpressionRequestBody = DotCMSRequestBody;
+/**
+ * Specific request body type for Custom events (for type documentation)
+ */
+export type DotCMSCustomEventRequestBody = DotCMSRequestBody;