@nextlytics/core 0.2.0-canary.40 → 0.2.0

package/dist/anonymous-user.cjs

@@ -0,0 +1,118 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var anonymous_user_exports = {};
+__export(anonymous_user_exports, {
+  resolveAnonymousUser: () => resolveAnonymousUser
+});
+module.exports = __toCommonJS(anonymous_user_exports);
+const BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+const ANON_ID_LENGTH = 10;
+const DEFAULTS = {
+  gdprMode: true,
+  useCookies: false,
+  dailySalt: true,
+  cookieName: "__nextlytics_anon",
+  cookieMaxAge: 60 * 60 * 24 * 365 * 2
+  // 2 years
+};
+function isSecureRequest(headers) {
+  const proto = headers.get("x-forwarded-proto");
+  if (proto) return proto === "https";
+  return false;
+}
+function getDailySalt() {
+  const now = /* @__PURE__ */ new Date();
+  return `${now.getUTCFullYear()}-${now.getUTCMonth()}-${now.getUTCDate()}`;
+}
+function bytesToBase62(bytes, length) {
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    const idx = (bytes[i * 2] * 256 + bytes[i * 2 + 1]) % 62;
+    result += BASE62_CHARS[idx];
+  }
+  return result;
+}
+async function hashToShortId(input) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(input);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  return bytesToBase62(new Uint8Array(hashBuffer), ANON_ID_LENGTH);
+}
+async function generateGdprAnonId(serverContext, useDailySalt) {
+  const ip = serverContext.ip || "unknown";
+  const userAgent = serverContext.requestHeaders["user-agent"] || "unknown";
+  const host = serverContext.host || "unknown";
+  const parts = useDailySalt ? [getDailySalt(), ip, userAgent, host] : [ip, userAgent, host];
+  return hashToShortId(parts.join("|"));
+}
+function generateRandomAnonId() {
+  const bytes = new Uint8Array(ANON_ID_LENGTH * 2);
+  crypto.getRandomValues(bytes);
+  return bytesToBase62(bytes, ANON_ID_LENGTH);
+}
+async function resolveAnonymousUser(params) {
+  const { ctx, serverContext, config, response } = params;
+  const { headers, cookies } = ctx;
+  const gdprMode = config.anonymousUsers?.gdprMode ?? DEFAULTS.gdprMode;
+  const useCookies = config.anonymousUsers?.useCookies ?? DEFAULTS.useCookies;
+  const dailySalt = config.anonymousUsers?.dailySalt ?? DEFAULTS.dailySalt;
+  const cookieName = config.anonymousUsers?.cookieName ?? DEFAULTS.cookieName;
+  const cookieMaxAge = config.anonymousUsers?.cookieMaxAge ?? DEFAULTS.cookieMaxAge;
+  let anonId;
+  let shouldSetCookie = false;
+  if (useCookies) {
+    const existingCookie = cookies.get(cookieName);
+    if (existingCookie?.value) {
+      anonId = existingCookie.value;
+    } else {
+      anonId = gdprMode ? await generateGdprAnonId(serverContext, dailySalt) : generateRandomAnonId();
+      shouldSetCookie = true;
+    }
+  } else {
+    if (gdprMode) {
+      anonId = await generateGdprAnonId(serverContext, dailySalt);
+    } else {
+      anonId = generateRandomAnonId();
+    }
+  }
+  if (config.callbacks?.getAnonymousUserId) {
+    try {
+      const overrideResult = await config.callbacks.getAnonymousUserId({
+        ctx,
+        originalAnonymousUserId: anonId
+      });
+      anonId = overrideResult.anonId;
+    } catch {
+    }
+  }
+  if (shouldSetCookie && response) {
+    response.cookies.set(cookieName, anonId, {
+      maxAge: cookieMaxAge,
+      httpOnly: true,
+      secure: isSecureRequest(headers),
+      sameSite: "lax",
+      path: "/"
+    });
+  }
+  return { anonId };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveAnonymousUser
+});

package/dist/anonymous-user.d.mts

@@ -0,0 +1,22 @@
+import { NextResponse } from 'next/server';
+import { RequestContext, ServerEventContext, NextlyticsConfig, AnonymousUserResult } from './types.mjs';
+import 'next/dist/server/web/spec-extension/cookies';
+
+type ResolveAnonymousUserParams = {
+    ctx: RequestContext;
+    serverContext: ServerEventContext;
+    config: NextlyticsConfig;
+    /** Optional response for setting cookies. If not provided, cookies won't be set. */
+    response?: NextResponse | null;
+};
+/**
+ * Resolve anonymous user ID based on config.
+ *
+ * Modes:
+ * - gdprMode=true (default): Hash-based ID (Fathom-like)
+ * - gdprMode=false + useCookies=true: Persistent cookie-based ID
+ * - gdprMode=false + useCookies=false: Random ID per request
+ */
+declare function resolveAnonymousUser(params: ResolveAnonymousUserParams): Promise<AnonymousUserResult>;
+
+export { type ResolveAnonymousUserParams, resolveAnonymousUser };

package/dist/anonymous-user.js

@@ -1,26 +1,3 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var anonymous_user_exports = {};
-__export(anonymous_user_exports, {
-  resolveAnonymousUser: () => resolveAnonymousUser
-});
-module.exports = __toCommonJS(anonymous_user_exports);
 const BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 const ANON_ID_LENGTH = 10;
 const DEFAULTS = {
@@ -112,7 +89,6 @@ async function resolveAnonymousUser(params) {
   }
   return { anonId };
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   resolveAnonymousUser
-});
+};

package/dist/backends/clickhouse.cjs

@@ -0,0 +1,110 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var clickhouse_exports = {};
+__export(clickhouse_exports, {
+  clickhouseBackend: () => clickhouseBackend
+});
+module.exports = __toCommonJS(clickhouse_exports);
+var import_db = require("./lib/db");
+function clickhouseBackend(config) {
+  const baseUrl = config.url.replace(/\/$/, "");
+  const database = config.database ?? "default";
+  const table = config.tableName ?? "analytics";
+  const asyncInsert = config.asyncInsert ?? true;
+  const acceptUpdates = config.acceptUpdates ?? false;
+  const updateLookbackMinutes = config.updateLookbackMinutes ?? 60;
+  const authHeader = "Basic " + btoa((config.username ?? "default") + ":" + (config.password ?? ""));
+  function printCreateTableStatement() {
+    console.error(`[Nextlytics ClickHouse] Table "${database}.${table}" does not exist. Run:
+`);
+    console.error((0, import_db.generateChCreateTableSQL)(database, table));
+  }
+  async function query(sql) {
+    const params = new URLSearchParams({
+      database,
+      query: sql
+    });
+    const res = await fetch(`${baseUrl}/?${params}`, {
+      method: "GET",
+      headers: { Authorization: authHeader }
+    });
+    if (!res.ok) {
+      throw new Error(`ClickHouse query error ${res.status}: ${await res.text()}`);
+    }
+    const text = await res.text();
+    if (!text.trim()) return [];
+    return text.trim().split("\n").map((line) => JSON.parse(line));
+  }
+  async function insert(row) {
+    const params = new URLSearchParams({
+      database,
+      query: `INSERT INTO ${table} FORMAT JSONEachRow`,
+      date_time_input_format: "best_effort"
+    });
+    if (asyncInsert) {
+      params.set("async_insert", "1");
+      params.set("wait_for_async_insert", "0");
+    }
+    const res = await fetch(`${baseUrl}/?${params}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: authHeader
+      },
+      body: JSON.stringify(row)
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      if ((0, import_db.isChTableNotFoundError)(text)) {
+        printCreateTableStatement();
+      }
+      throw new Error(`ClickHouse error ${res.status}: ${text}`);
+    }
+  }
+  return {
+    name: "clickhouse",
+    supportsUpdates: acceptUpdates,
+    async onEvent(event) {
+      const row = (0, import_db.eventToJsonRow)(event);
+      await insert(row);
+    },
+    async updateEvent(eventId, patch) {
+      if (!acceptUpdates || !patch.clientContext) return;
+      const cols = import_db.tableColumns.map((c) => c.name).join(", ");
+      const rows = await query(
+        `SELECT ${cols} FROM ${table} WHERE event_id = '${eventId}' AND timestamp > now() - INTERVAL ${updateLookbackMinutes} MINUTE FORMAT JSONEachRow`
+      );
+      if (rows.length === 0) return;
+      const existing = rows[0];
+      const clientCtx = (0, import_db.extractClientContext)(patch.clientContext);
+      const updated = {
+        ...existing,
+        referer: clientCtx.referer ?? existing.referer,
+        user_agent: clientCtx.user_agent ?? existing.user_agent,
+        locale: clientCtx.locale ?? existing.locale,
+        client_context: clientCtx.rest ?? existing.client_context
+      };
+      await insert(updated);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clickhouseBackend
+});

package/dist/backends/clickhouse.d.mts

@@ -0,0 +1,58 @@
+import { NextlyticsBackend } from '../types.mjs';
+import 'next/dist/server/web/spec-extension/cookies';
+import 'next/server';
+
+/**
+ * ClickHouse backend for Nextlytics
+ *
+ * Sends events to ClickHouse via HTTP API with async inserts.
+ *
+ * ## ClickHouse Cloud Usage
+ *
+ * ```typescript
+ * import { clickhouseBackend } from "@nextlytics/core/backends/clickhouse"
+ *
+ * const analytics = Nextlytics({
+ *   backends: [
+ *     clickhouseBackend({
+ *       url: "https://xxx.clickhouse.cloud:8443",
+ *       username: "default",
+ *       password: process.env.CLICKHOUSE_PASSWORD!,
+ *     })
+ *   ]
+ * })
+ * ```
+ *
+ * ## Self-hosted ClickHouse
+ *
+ * ```typescript
+ * clickhouseBackend({
+ *   url: "http://localhost:8123",
+ *   username: "default",
+ *   password: "",
+ *   database: "analytics",
+ * })
+ * ```
+ */
+
+type ClickHouseBackendConfig = {
+    /** ClickHouse HTTP API URL */
+    url: string;
+    /** Username (default: "default") */
+    username?: string;
+    /** Password */
+    password?: string;
+    /** Database name (default: "default") */
+    database?: string;
+    /** Table name (default: "analytics") */
+    tableName?: string;
+    /** Enable async inserts (default: true) */
+    asyncInsert?: boolean;
+    /** Enable updates via select+insert (uses ReplacingMergeTree deduplication) */
+    acceptUpdates?: boolean;
+    /** Lookback window in minutes for update SELECT queries (default: 60) */
+    updateLookbackMinutes?: number;
+};
+declare function clickhouseBackend(config: ClickHouseBackendConfig): NextlyticsBackend;
+
+export { type ClickHouseBackendConfig, clickhouseBackend };

package/dist/backends/clickhouse.js

@@ -1,27 +1,10 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var clickhouse_exports = {};
-__export(clickhouse_exports, {
-  clickhouseBackend: () => clickhouseBackend
-});
-module.exports = __toCommonJS(clickhouse_exports);
-var import_db = require("./lib/db");
+import {
+  tableColumns,
+  eventToJsonRow,
+  generateChCreateTableSQL,
+  isChTableNotFoundError,
+  extractClientContext
+} from "./lib/db";
 function clickhouseBackend(config) {
   const baseUrl = config.url.replace(/\/$/, "");
   const database = config.database ?? "default";
@@ -33,7 +16,7 @@ function clickhouseBackend(config) {
   function printCreateTableStatement() {
     console.error(`[Nextlytics ClickHouse] Table "${database}.${table}" does not exist. Run:
 `);
-    console.error((0, import_db.generateChCreateTableSQL)(database, table));
+    console.error(generateChCreateTableSQL(database, table));
   }
   async function query(sql) {
     const params = new URLSearchParams({
@@ -71,7 +54,7 @@ function clickhouseBackend(config) {
     });
     if (!res.ok) {
       const text = await res.text();
-      if ((0, import_db.isChTableNotFoundError)(text)) {
+      if (isChTableNotFoundError(text)) {
         printCreateTableStatement();
       }
       throw new Error(`ClickHouse error ${res.status}: ${text}`);
@@ -81,18 +64,18 @@ function clickhouseBackend(config) {
     name: "clickhouse",
     supportsUpdates: acceptUpdates,
     async onEvent(event) {
-      const row = (0, import_db.eventToJsonRow)(event);
+      const row = eventToJsonRow(event);
       await insert(row);
     },
     async updateEvent(eventId, patch) {
       if (!acceptUpdates || !patch.clientContext) return;
-      const cols = import_db.tableColumns.map((c) => c.name).join(", ");
+      const cols = tableColumns.map((c) => c.name).join(", ");
       const rows = await query(
         `SELECT ${cols} FROM ${table} WHERE event_id = '${eventId}' AND timestamp > now() - INTERVAL ${updateLookbackMinutes} MINUTE FORMAT JSONEachRow`
       );
       if (rows.length === 0) return;
       const existing = rows[0];
-      const clientCtx = (0, import_db.extractClientContext)(patch.clientContext);
+      const clientCtx = extractClientContext(patch.clientContext);
       const updated = {
         ...existing,
         referer: clientCtx.referer ?? existing.referer,
@@ -104,7 +87,6 @@ function clickhouseBackend(config) {
     }
   };
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   clickhouseBackend
-});
+};

package/dist/backends/ga.cjs

@@ -0,0 +1,207 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ga_exports = {};
+__export(ga_exports, {
+  googleAnalyticsBackend: () => googleAnalyticsBackend
+});
+module.exports = __toCommonJS(ga_exports);
+const GA_TEMPLATE_ID = "ga-gtag";
+function parseGaCookie(cookieValue) {
+  const match = cookieValue.match(/^GA\d+\.\d+\.(.+)$/);
+  return match ? match[1] : null;
+}
+function getClientId(event, gaCookieClientId, source) {
+  if (source === "gaCookie" && gaCookieClientId) {
+    return gaCookieClientId;
+  }
+  if (!event.anonymousUserId) {
+    throw new Error("anonymousUserId is required for GA backend (no _ga cookie available)");
+  }
+  return event.anonymousUserId;
+}
+function toGA4EventName(type) {
+  if (type === "pageView") return "page_view";
+  if (type === "apiCall") return "api_call";
+  return type.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+function buildEventParams(event) {
+  const params = {
+    // Required for engagement metrics
+    engagement_time_msec: 1
+  };
+  const { serverContext } = event;
+  if (serverContext) {
+    params.page_location = `https://${serverContext.host}${serverContext.path}`;
+  }
+  const { clientContext } = event;
+  if (clientContext) {
+    if (clientContext.referer) {
+      params.page_referrer = clientContext.referer;
+    }
+    if (clientContext.locale) {
+      params.language = clientContext.locale;
+    }
+    if (clientContext.screen?.width && clientContext.screen?.height) {
+      params.screen_resolution = `${clientContext.screen.width}x${clientContext.screen.height}`;
+    }
+  }
+  if (event.properties) {
+    Object.assign(params, event.properties);
+  }
+  return params;
+}
+function getUserAgent(event) {
+  return event.clientContext?.userAgent ?? event.serverContext?.requestHeaders?.["user-agent"];
+}
+function getClientIp(event) {
+  return event.serverContext?.ip;
+}
+async function sendToMeasurementProtocol(opts) {
+  const endpoint = opts.debugMode ? "https://www.google-analytics.com/debug/mp/collect" : "https://www.google-analytics.com/mp/collect";
+  const url = `${endpoint}?measurement_id=${opts.measurementId}&api_secret=${opts.apiSecret}`;
+  const payload = {
+    client_id: opts.clientId,
+    events: [
+      {
+        name: opts.eventName,
+        params: opts.eventParams
+      }
+    ]
+  };
+  if (opts.userId) {
+    payload.user_id = opts.userId;
+  }
+  if (opts.userProperties && Object.keys(opts.userProperties).length > 0) {
+    payload.user_properties = Object.fromEntries(
+      Object.entries(opts.userProperties).map(([k, v]) => [k, { value: v }])
+    );
+  }
+  const headers = {};
+  if (opts.userAgent) {
+    headers["User-Agent"] = opts.userAgent;
+  }
+  if (opts.clientIp) {
+    headers["X-Forwarded-For"] = opts.clientIp;
+  }
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      body: JSON.stringify(payload),
+      headers: Object.keys(headers).length > 0 ? headers : void 0
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      console.warn(`[GA] Measurement Protocol error: ${res.status} ${res.statusText}`, body);
+    }
+  } catch (err) {
+    console.warn("[GA] Measurement Protocol request failed:", err);
+  }
+}
+function googleAnalyticsBackend(opts) {
+  const { measurementId, debugMode, apiSecret, clientIdSource = "gaCookie" } = opts;
+  return (ctx) => {
+    const gaCookie = ctx.cookies.get("_ga");
+    const gaCookieClientId = gaCookie ? parseGaCookie(gaCookie.value) : null;
+    return {
+      name: "google-analytics",
+      returnsClientActions: true,
+      supportsUpdates: false,
+      getClientSideTemplates() {
+        return {
+          [GA_TEMPLATE_ID]: {
+            items: [
+              {
+                async: "true",
+                src: "https://www.googletagmanager.com/gtag/js?id={{measurementId}}",
+                singleton: true
+              },
+              {
+                body: [
+                  "window.dataLayer = window.dataLayer || [];",
+                  "function gtag(){dataLayer.push(arguments);}",
+                  "gtag('js', new Date());",
+                  "gtag('config', '{{measurementId}}', {{json(config)}});",
+                  "gtag('event', 'page_view');"
+                ].join("\n")
+              }
+            ]
+          }
+        };
+      },
+      async onEvent(event) {
+        const clientId = getClientId(event, gaCookieClientId, clientIdSource);
+        const userId = event.userContext?.userId;
+        const {
+          email: _email,
+          name: _name,
+          phone: _phone,
+          ...customTraits
+        } = event.userContext?.traits ?? {};
+        const userProperties = Object.keys(customTraits).length > 0 ? customTraits : void 0;
+        if (event.type === "pageView") {
+          const config = {
+            send_page_view: false,
+            client_id: clientId
+          };
+          if (debugMode) {
+            config.debug_mode = true;
+          }
+          if (userId) {
+            config.user_id = userId;
+          }
+          if (userProperties) {
+            config.user_properties = userProperties;
+          }
+          return {
+            items: [
+              {
+                type: "script-template",
+                templateId: GA_TEMPLATE_ID,
+                params: {
+                  measurementId,
+                  config
+                }
+              }
+            ]
+          };
+        }
+        if (apiSecret) {
+          await sendToMeasurementProtocol({
+            measurementId,
+            apiSecret,
+            clientId,
+            userId,
+            userProperties,
+            eventName: toGA4EventName(event.type),
+            eventParams: buildEventParams(event),
+            userAgent: getUserAgent(event),
+            clientIp: getClientIp(event),
+            debugMode
+          });
+        }
+      },
+      updateEvent() {
+      }
+    };
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  googleAnalyticsBackend
+});

package/dist/backends/ga.d.mts

@@ -0,0 +1,21 @@
+import { NextlyticsBackendFactory } from '../types.mjs';
+import 'next/dist/server/web/spec-extension/cookies';
+import 'next/server';
+
+type GoogleAnalyticsBackendOptions = {
+    /** GA4 Measurement ID (e.g. "G-XXXXXXXXXX") */
+    measurementId: string;
+    /** Enable GA4 debug mode (shows events in DebugView) */
+    debugMode?: boolean;
+    /** API secret for Measurement Protocol (GA4 Admin → Data Streams → MP secrets) */
+    apiSecret?: string;
+    /**
+     * Source for client_id.
+     * - "gaCookie" (default): Use _ga cookie set by gtag.js, fall back to anonymousUserId
+     * - "anonymousUserId": Always use Nextlytics anonymousUserId
+     */
+    clientIdSource?: "gaCookie" | "anonymousUserId";
+};
+declare function googleAnalyticsBackend(opts: GoogleAnalyticsBackendOptions): NextlyticsBackendFactory;
+
+export { type GoogleAnalyticsBackendOptions, googleAnalyticsBackend };