@momentumcms/plugins-analytics 0.1.0

package/package.json

@@ -0,0 +1,56 @@
+{
+	"name": "@momentumcms/plugins-analytics",
+	"version": "0.1.0",
+	"description": "Analytics and content tracking plugin for Momentum CMS",
+	"license": "MIT",
+	"author": "Momentum CMS Contributors",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/momentum-cms/momentum-cms.git",
+		"directory": "libs/plugins/analytics"
+	},
+	"homepage": "https://github.com/momentum-cms/momentum-cms#readme",
+	"bugs": {
+		"url": "https://github.com/momentum-cms/momentum-cms/issues"
+	},
+	"keywords": [
+		"cms",
+		"momentum-cms",
+		"analytics",
+		"tracking",
+		"content-performance"
+	],
+	"engines": {
+		"node": ">=18"
+	},
+	"type": "commonjs",
+	"main": "./index.cjs",
+	"types": "./src/index.d.ts",
+	"dependencies": {
+		"@angular/aria": "^21.1.2",
+		"@angular/cdk": "^21.1.2",
+		"@angular/common": "~21.1.0",
+		"@angular/core": "~21.1.0",
+		"@angular/forms": "~21.1.0",
+		"@angular/router": "~21.1.0",
+		"@aws-sdk/client-s3": "^3.983.0",
+		"@aws-sdk/s3-request-presigner": "^3.983.0",
+		"@momentumcms/core": "0.1.0",
+		"@momentumcms/logger": "0.1.0",
+		"@momentumcms/plugins-core": "0.1.0",
+		"@momentumcms/server-core": "0.1.0",
+		"@ng-icons/core": "^33.0.0",
+		"@ng-icons/heroicons": "^33.0.0",
+		"express": "^4.21.0",
+		"graphql": "^16.12.0",
+		"rxjs": "~7.8.0"
+	},
+	"peerDependencies": {
+		"pg": "^8.0.0"
+	},
+	"peerDependenciesMeta": {
+		"pg": {
+			"optional": true
+		}
+	}
+}

package/src/index.d.ts

@@ -0,0 +1,21 @@
+export type { AnalyticsEvent, AnalyticsCategory, AnalyticsContext, AnalyticsQueryOptions, AnalyticsQueryResult, } from './lib/analytics-event.types';
+export type { AnalyticsAdapter, AnalyticsConfig } from './lib/analytics-config.types';
+export { EventStore, type EventStoreOptions } from './lib/event-store';
+export { injectCollectionCollector, type AnalyticsEmitter, type CollectionCollectorOptions, } from './lib/collectors/collection-collector';
+export { createApiCollectorMiddleware } from './lib/collectors/api-collector';
+export { createIngestRouter, type IngestHandlerOptions } from './lib/ingest-handler';
+export { MemoryAnalyticsAdapter } from './lib/adapters/memory-adapter';
+export { postgresAnalyticsAdapter, type PostgresAnalyticsAdapterOptions, } from './lib/adapters/postgres-adapter';
+export { parseUserAgent, type ParsedUserAgent } from './lib/utils/parse-user-agent';
+export { createTracker, type TrackerConfig, type MomentumTracker, type ClientEvent, } from './lib/client/tracker';
+export { analyticsPlugin, type AnalyticsPluginInstance } from './lib/analytics-plugin';
+export { createAnalyticsQueryRouter, type AnalyticsSummary } from './lib/analytics-query-handler';
+export { createAnalyticsMiddleware, type AnalyticsMiddleware } from './lib/analytics-middleware';
+export { injectBlockAnalyticsFields } from './lib/collectors/block-field-injector';
+export { attachBlockTracking } from './lib/client/block-tracker';
+export { createRuleEngine, type RuleEngine, type RuleEngineConfig } from './lib/client/rule-engine';
+export { TrackingRules } from './lib/tracking-rules/tracking-rules-collection';
+export { createTrackingRulesRouter, type TrackingRulesEndpointOptions, type TrackingRulesRouterResult, } from './lib/tracking-rules/tracking-rules-endpoint';
+export type { TrackingRule, ClientTrackingRule, TrackingEventType, PropertyExtraction, } from './lib/tracking-rules/tracking-rule.types';
+export { createContentPerformanceRouter } from './lib/content-performance/content-performance-handler';
+export type { ContentPerformanceData, ContentPerformanceQuery, } from './lib/content-performance/content-performance.types';

package/src/lib/adapters/memory-adapter.d.ts

@@ -0,0 +1,15 @@
+/**
+ * In-Memory Analytics Adapter
+ *
+ * Stores analytics events in memory. Useful for testing and development.
+ */
+import type { AnalyticsAdapter } from '../analytics-config.types';
+import type { AnalyticsEvent, AnalyticsQueryOptions, AnalyticsQueryResult } from '../analytics-event.types';
+/**
+ * In-memory analytics adapter for development and testing.
+ */
+export declare class MemoryAnalyticsAdapter implements AnalyticsAdapter {
+    readonly events: AnalyticsEvent[];
+    store(events: AnalyticsEvent[]): Promise<void>;
+    query(options?: AnalyticsQueryOptions): Promise<AnalyticsQueryResult>;
+}

package/src/lib/adapters/postgres-adapter.d.ts

@@ -0,0 +1,31 @@
+/**
+ * PostgreSQL Analytics Adapter
+ *
+ * Stores analytics events in a PostgreSQL table with JSONB columns.
+ * Uses the `pg` package (same as @momentumcms/db-drizzle).
+ */
+import type { AnalyticsAdapter } from '../analytics-config.types';
+/**
+ * PostgreSQL analytics adapter options.
+ */
+export interface PostgresAnalyticsAdapterOptions {
+    /** PostgreSQL connection string */
+    connectionString: string;
+    /** Maximum pool size. @default 5 */
+    poolSize?: number;
+    /** Table name. @default '_momentum_analytics' */
+    tableName?: string;
+}
+/**
+ * PostgreSQL analytics adapter.
+ *
+ * @example
+ * ```typescript
+ * import { postgresAnalyticsAdapter } from '@momentumcms/plugins/analytics';
+ *
+ * const adapter = postgresAnalyticsAdapter({
+ *   connectionString: process.env.DATABASE_URL,
+ * });
+ * ```
+ */
+export declare function postgresAnalyticsAdapter(options: PostgresAnalyticsAdapterOptions): AnalyticsAdapter;

package/src/lib/analytics-auth.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Analytics Auth Utilities
+ *
+ * Shared authentication helpers for analytics endpoints.
+ * Uses type guards (no `as` assertions) to check req.user set by auth middleware.
+ */
+import type { Request, Response, NextFunction } from 'express';
+/**
+ * Express middleware that requires authentication.
+ * Returns 401 if no valid user session is present.
+ */
+export declare function requireAuth(req: Request, res: Response, next: NextFunction): void;
+/**
+ * Express middleware that requires admin role.
+ * Returns 401 if no session, 403 if not admin.
+ */
+export declare function requireAdmin(req: Request, res: Response, next: NextFunction): void;

package/src/lib/analytics-config.types.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Analytics Configuration Types
+ */
+import type { AnalyticsEvent, AnalyticsQueryOptions, AnalyticsQueryResult } from './analytics-event.types';
+/**
+ * Analytics storage adapter interface.
+ * Implement this to store analytics events in your preferred backend.
+ */
+export interface AnalyticsAdapter {
+    /** Store a batch of events */
+    store(events: AnalyticsEvent[]): Promise<void>;
+    /** Query events (for admin dashboard) */
+    query?(options: AnalyticsQueryOptions): Promise<AnalyticsQueryResult>;
+    /** Initialize adapter (create tables, etc.) */
+    initialize?(): Promise<void>;
+    /** Flush pending events and close connections */
+    shutdown?(): Promise<void>;
+}
+/**
+ * Analytics configuration.
+ */
+export interface AnalyticsConfig {
+    /** Enable/disable analytics. @default true */
+    enabled?: boolean;
+    /** Analytics storage adapter */
+    adapter: AnalyticsAdapter;
+    /** Server-side collection tracking. @default true */
+    trackCollections?: boolean;
+    /** API request tracking. @default true */
+    trackApi?: boolean;
+    /** Admin action tracking. @default true */
+    trackAdmin?: boolean;
+    /** Client-side ingest endpoint path. @default '/api/analytics/collect' */
+    ingestPath?: string;
+    /** Rate limit for ingest endpoint (requests per minute per IP). @default 100 */
+    ingestRateLimit?: number;
+    /** Batch flush interval in ms. @default 5000 */
+    flushInterval?: number;
+    /** Batch size before forced flush. @default 100 */
+    flushBatchSize?: number;
+    /** Collections to exclude from tracking */
+    excludeCollections?: string[];
+    /**
+     * Inject analytics toggle fields into block definitions.
+     * When enabled, admins can toggle impression/click tracking per block instance.
+     * @default true
+     */
+    blockTracking?: boolean;
+    /**
+     * Content performance endpoint and admin page.
+     * @default true
+     */
+    contentPerformance?: boolean;
+    /**
+     * Element tracking rules (admin-managed CSS selector listeners).
+     * - `true` (default): enable with default settings
+     * - `false`: disable
+     * - object: override cache TTL
+     */
+    trackingRules?: boolean | {
+        cacheTtl?: number;
+    };
+    /**
+     * Admin dashboard configuration.
+     * - `true` (default): use built-in dashboard
+     * - `false`: disable dashboard
+     * - object: override loadComponent and/or group
+     */
+    adminDashboard?: boolean | {
+        /** Override lazy component loader */
+        loadComponent?: unknown;
+        /** Sidebar section name. @default 'Tools' */
+        group?: string;
+    };
+}

package/src/lib/analytics-event.types.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Analytics Event Types
+ */
+/**
+ * Analytics event categories.
+ */
+export type AnalyticsCategory = 'admin' | 'api' | 'content' | 'page' | 'action' | 'custom';
+/**
+ * A single analytics event.
+ */
+export interface AnalyticsEvent {
+    /** Unique event ID */
+    id: string;
+    /** Event category */
+    category: AnalyticsCategory;
+    /** Event name (e.g., 'page_view', 'content_created', 'button_click') */
+    name: string;
+    /** ISO timestamp */
+    timestamp: string;
+    /** Session ID (for client events) */
+    sessionId?: string;
+    /** User/visitor identifier */
+    userId?: string;
+    /** Anonymous visitor ID (for non-authenticated frontend users) */
+    visitorId?: string;
+    /** Event-specific properties */
+    properties: Record<string, unknown>;
+    /** Context metadata */
+    context: AnalyticsContext;
+}
+/**
+ * Context metadata for analytics events.
+ */
+export interface AnalyticsContext {
+    /** Source: 'server' or 'client' */
+    source: 'server' | 'client';
+    /** Page URL */
+    url?: string;
+    /** Referrer URL */
+    referrer?: string;
+    /** Raw user agent string */
+    userAgent?: string;
+    /** Client IP address */
+    ip?: string;
+    /** Device type (mobile, tablet, desktop) */
+    device?: string;
+    /** Browser name (Chrome, Firefox, Safari, etc.) */
+    browser?: string;
+    /** Operating system (Windows, macOS, Linux, iOS, Android) */
+    os?: string;
+    /** For server events: collection slug */
+    collection?: string;
+    /** For server events: operation type */
+    operation?: string;
+    /** For API events: response time in ms */
+    duration?: number;
+    /** For API events: HTTP status code */
+    statusCode?: number;
+}
+/**
+ * Query options for retrieving analytics events.
+ */
+export interface AnalyticsQueryOptions {
+    /** Filter by category */
+    category?: AnalyticsCategory;
+    /** Filter by event name */
+    name?: string;
+    /** Filter by collection */
+    collection?: string;
+    /** Full-text search across event name, URL, collection */
+    search?: string;
+    /** Start date (ISO string) */
+    from?: string;
+    /** End date (ISO string) */
+    to?: string;
+    /** Maximum number of results */
+    limit?: number;
+    /** Page number (1-based) */
+    page?: number;
+}
+/**
+ * Result of an analytics query.
+ */
+export interface AnalyticsQueryResult {
+    events: AnalyticsEvent[];
+    total: number;
+    page: number;
+    limit: number;
+}

package/src/lib/analytics-middleware.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Analytics Express Middleware
+ *
+ * Convenience function to create all Express middleware from an analytics plugin instance.
+ * Returns the ingest router (for client-side events) and API collector middleware.
+ *
+ * @example
+ * ```typescript
+ * import { analyticsPlugin, createAnalyticsMiddleware, MemoryAnalyticsAdapter } from '@momentumcms/plugins/analytics';
+ *
+ * const analytics = analyticsPlugin({ adapter: new MemoryAnalyticsAdapter() });
+ *
+ * // In Express setup:
+ * const { ingestRouter, apiCollector } = createAnalyticsMiddleware(analytics);
+ * app.use('/api/analytics/collect', ingestRouter);
+ * app.use('/api', apiCollector);
+ * ```
+ */
+import type { Router, Request, Response, NextFunction } from 'express';
+import type { AnalyticsPluginInstance } from './analytics-plugin';
+/**
+ * Result of createAnalyticsMiddleware.
+ */
+export interface AnalyticsMiddleware {
+    /** Express router for the ingest endpoint (mount at your ingest path) */
+    ingestRouter: Router;
+    /** Express middleware that tracks API request timing/status (mount before API routes) */
+    apiCollector: (req: Request, res: Response, next: NextFunction) => void;
+}
+/**
+ * Creates all Express middleware from an analytics plugin instance.
+ *
+ * @deprecated The analytics plugin now auto-registers its middleware via the plugin system.
+ * Simply add `analyticsPlugin(config)` to your `plugins` array in momentum.config.ts
+ * and the framework will mount the ingest router and API collector automatically.
+ *
+ * @param plugin - The analytics plugin instance (returned by `analyticsPlugin()`)
+ * @returns Object with ingest router and API collector middleware
+ */
+export declare function createAnalyticsMiddleware(plugin: AnalyticsPluginInstance): AnalyticsMiddleware;

package/src/lib/analytics-plugin.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Analytics Plugin
+ *
+ * A Momentum CMS plugin that wires all analytics collectors together.
+ * Tracks collection CRUD, API requests, and accepts client-side events.
+ *
+ * @example
+ * ```typescript
+ * import { analyticsPlugin, MemoryAnalyticsAdapter } from '@momentumcms/plugins/analytics';
+ *
+ * export default defineMomentumConfig({
+ *   plugins: [
+ *     analyticsPlugin({
+ *       adapter: new MemoryAnalyticsAdapter(),
+ *       // Dashboard is included by default. Set false to disable.
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+import type { MomentumPlugin } from '@momentumcms/plugins/core';
+import type { AnalyticsConfig } from './analytics-config.types';
+import { EventStore } from './event-store';
+/**
+ * Analytics plugin with access to the event store.
+ */
+export interface AnalyticsPluginInstance extends MomentumPlugin {
+    /** The event store — use for manual event emission */
+    eventStore: EventStore;
+    /** The analytics configuration */
+    analyticsConfig: AnalyticsConfig;
+}
+/**
+ * Creates an analytics plugin.
+ *
+ * @param config - Analytics configuration
+ * @returns Plugin instance
+ */
+export declare function analyticsPlugin(config: AnalyticsConfig): AnalyticsPluginInstance;

package/src/lib/analytics-query-handler.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Analytics Query Handler
+ *
+ * Express router with endpoints for querying analytics data.
+ * Provides paginated event queries and pre-aggregated summary metrics.
+ */
+import { Router } from 'express';
+import type { EventStore } from './event-store';
+import type { AnalyticsAdapter } from './analytics-config.types';
+/**
+ * Pre-aggregated analytics summary.
+ */
+export interface AnalyticsSummary {
+    totalEvents: number;
+    byCategory: Record<string, number>;
+    byCollection: Record<string, number>;
+    contentOperations: {
+        created: number;
+        updated: number;
+        deleted: number;
+    };
+    apiMetrics: {
+        totalRequests: number;
+        avgDuration: number;
+    };
+    activeSessions: number;
+    activeVisitors: number;
+    /** Top pages by visit count */
+    topPages: Array<{
+        url: string;
+        count: number;
+    }>;
+    /** Top referrers by count */
+    topReferrers: Array<{
+        referrer: string;
+        count: number;
+    }>;
+    /** Device type breakdown */
+    deviceBreakdown: Record<string, number>;
+    /** Browser breakdown */
+    browserBreakdown: Record<string, number>;
+}
+/**
+ * Creates an Express router with analytics query endpoints.
+ */
+export declare function createAnalyticsQueryRouter(eventStore: EventStore, adapter: AnalyticsAdapter): Router;

package/src/lib/client/block-tracker.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Block-Level Analytics Tracker
+ *
+ * Attaches IntersectionObserver for impression tracking and mouseenter delegation
+ * for hover tracking on blocks that have `data-block-track` attributes.
+ *
+ * Only tracks blocks where the admin has enabled tracking via the
+ * `_analytics` group fields injected by the analytics plugin.
+ *
+ * @example
+ * ```typescript
+ * const tracker = createTracker({ endpoint: '/api/analytics/collect' });
+ * const cleanup = attachBlockTracking(tracker);
+ * // Later: cleanup() to disconnect observers and remove listeners
+ * ```
+ */
+import type { MomentumTracker } from './tracker';
+/**
+ * Attach block-level analytics tracking to the page.
+ *
+ * Finds all elements with `data-block-track` and:
+ * - Observes visibility via IntersectionObserver (for `impressions`)
+ * - Listens for mouseenter via event delegation (for `hover`)
+ *
+ * @param tracker - Momentum tracker instance for event emission
+ * @param container - DOM container to scope tracking (defaults to document.body)
+ * @returns Cleanup function to disconnect observers and remove listeners
+ */
+export declare function attachBlockTracking(tracker: MomentumTracker, container?: HTMLElement): () => void;

package/src/lib/client/rule-engine.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Rule Engine
+ *
+ * Client-side engine for admin-managed element tracking rules.
+ * Fetches active rules from the server, filters by current URL,
+ * and attaches event listeners/observers for matching elements.
+ *
+ * Supports SPA navigation by wrapping pushState/replaceState and
+ * listening for popstate to re-filter rules on route changes.
+ */
+import type { MomentumTracker } from './tracker';
+/**
+ * Rule engine configuration.
+ */
+export interface RuleEngineConfig {
+    /** Rules endpoint URL. @default '/api/analytics/tracking-rules' */
+    endpoint?: string;
+}
+/**
+ * Rule engine instance.
+ */
+export interface RuleEngine {
+    /** Fetch rules and start tracking for the current URL */
+    start(): Promise<void>;
+    /** Stop all tracking and clean up listeners */
+    stop(): void;
+    /** Re-filter rules and re-attach listeners for a new URL (SPA navigation) */
+    onNavigate(url: string): void;
+}
+/**
+ * A tracking rule as received from the server.
+ */
+interface ClientRule {
+    name: string;
+    selector: string;
+    eventType: string;
+    eventName: string;
+    urlPattern: string;
+    properties: Record<string, unknown>;
+    extractProperties?: unknown[];
+    active: boolean;
+    rateLimit?: number;
+}
+/**
+ * Match a URL pathname against a glob pattern.
+ * Supports `*` (any single path segment) and `**` (any path depth).
+ */
+export declare function matchUrlPattern(pattern: string, pathname: string): boolean;
+/**
+ * Validate and narrow a server response to a rules array.
+ * Rejects rules with selectors targeting sensitive form inputs.
+ */
+export declare function parseRulesResponse(data: unknown): ClientRule[];
+/**
+ * Create a client-side rule engine.
+ *
+ * @param tracker - Momentum tracker instance for event emission
+ * @param config - Rule engine configuration
+ * @returns Rule engine instance
+ *
+ * @example
+ * ```typescript
+ * const engine = createRuleEngine(tracker, { endpoint: '/api/analytics/tracking-rules' });
+ * await engine.start();
+ * // On SPA navigation:
+ * engine.onNavigate('/new-path');
+ * // Cleanup:
+ * engine.stop();
+ * ```
+ */
+export declare function createRuleEngine(tracker: MomentumTracker, config?: RuleEngineConfig): RuleEngine;
+export {};

package/src/lib/client/tracker.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Client-Side Analytics Tracker
+ *
+ * Lightweight JS snippet (~2KB) for tracking page views and custom actions.
+ * Designed to be served as a standalone script or imported in frontend apps.
+ *
+ * Features:
+ * - Auto-generates visitorId (localStorage) and sessionId (sessionStorage)
+ * - Batches events and flushes every 5s or on beforeunload
+ * - Uses navigator.sendBeacon() for reliable delivery on page exit
+ */
+/**
+ * Tracker configuration.
+ */
+export interface TrackerConfig {
+    /** Ingest endpoint URL. @default '/api/analytics/collect' */
+    endpoint?: string;
+    /** Flush interval in ms. @default 5000 */
+    flushInterval?: number;
+    /** Enable block-level analytics (impressions + clicks on blocks with `data-block-track`). @default false */
+    blockTracking?: boolean;
+    /**
+     * Enable element tracking rules (admin-managed CSS selector listeners).
+     * - `true`: enable with default endpoint
+     * - object: override rules endpoint URL
+     * @default false
+     */
+    trackingRules?: boolean | {
+        endpoint?: string;
+    };
+}
+/**
+ * Client event structure (before server enrichment).
+ */
+export interface ClientEvent {
+    name: string;
+    category?: string;
+    properties?: Record<string, unknown>;
+    context?: {
+        url?: string;
+        referrer?: string;
+    };
+    sessionId?: string;
+    visitorId?: string;
+}
+/**
+ * Momentum Analytics Tracker interface.
+ */
+export interface MomentumTracker {
+    /** Track a page view (auto-captures URL, referrer) */
+    pageView(properties?: Record<string, unknown>): void;
+    /** Track a custom action */
+    track(name: string, properties?: Record<string, unknown>): void;
+    /** Identify the current user */
+    identify(userId: string, traits?: Record<string, unknown>): void;
+    /** Flush pending events */
+    flush(): void;
+    /** Flush pending events and clean up all listeners, timers, and observers */
+    destroy(): void;
+}
+/**
+ * Create a Momentum Analytics tracker.
+ *
+ * @param config - Tracker configuration
+ * @returns Tracker instance
+ *
+ * @example
+ * ```typescript
+ * const tracker = createTracker({ endpoint: '/api/analytics/collect' });
+ * tracker.pageView();
+ * tracker.track('button_click', { buttonId: 'cta-signup' });
+ * ```
+ */
+export declare function createTracker(config?: TrackerConfig): MomentumTracker;

package/src/lib/collectors/api-collector.d.ts

@@ -0,0 +1,18 @@
+/**
+ * API Collector
+ *
+ * Express middleware that tracks API request timing and status codes.
+ */
+import type { Request, Response, NextFunction } from 'express';
+import type { AnalyticsEvent } from '../analytics-event.types';
+/**
+ * Callback type for analytics event emission.
+ */
+export type AnalyticsEmitter = (event: AnalyticsEvent) => void;
+/**
+ * Creates Express middleware that tracks API request metrics.
+ *
+ * @param emitter - Callback to emit analytics events
+ * @returns Express middleware function
+ */
+export declare function createApiCollectorMiddleware(emitter: AnalyticsEmitter): (req: Request, res: Response, next: NextFunction) => void;

package/src/lib/collectors/block-field-injector.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Block Field Injector
+ *
+ * Walks all collections and injects `_analytics` group fields into every
+ * BlockConfig, giving admins per-block-instance control over impression
+ * and hover tracking.
+ *
+ * Same mutation pattern as `injectCollectionCollector` — modifies the
+ * mutable collections array during plugin `onInit`.
+ */
+import type { CollectionConfig } from '@momentumcms/core';
+/**
+ * Inject analytics group fields into all block definitions across all collections.
+ *
+ * @param collections - Mutable collections array from PluginContext
+ */
+export declare function injectBlockAnalyticsFields(collections: CollectionConfig[]): void;

package/src/lib/collectors/collection-collector.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Collection Collector
+ *
+ * Injects afterChange and afterDelete hooks that emit analytics events
+ * for collection CRUD operations.
+ */
+import type { CollectionConfig } from '@momentumcms/core';
+import type { AnalyticsEvent } from '../analytics-event.types';
+/**
+ * Callback type for analytics event emission.
+ */
+export type AnalyticsEmitter = (event: AnalyticsEvent) => void;
+/**
+ * Options for the collection collector.
+ */
+export interface CollectionCollectorOptions {
+    /** Collections to exclude from tracking */
+    excludeCollections?: string[];
+}
+/**
+ * Inject collection tracking hooks into all collections.
+ *
+ * @param collections - Mutable collections array
+ * @param emitter - Callback to emit analytics events
+ * @param options - Collector options
+ */
+export declare function injectCollectionCollector(collections: CollectionConfig[], emitter: AnalyticsEmitter, options?: CollectionCollectorOptions): void;