@nodewrite-labs/analytics-sdk 0.0.0-stage → 0.1.0

package/dist/payload/admin-view.js

@@ -0,0 +1,290 @@
+import {
+  PayloadAnalyticsEventStore,
+  adminSections,
+  analyticsModulesFromConfig
+} from "../chunk-GVOESWHZ.js";
+import "../chunk-Q4JRXZ6M.js";
+import "../chunk-F7BY2JQ3.js";
+
+// src/payload/admin/view.tsx
+import { DefaultTemplate } from "@payloadcms/next/templates";
+import { jsx, jsxs } from "react/jsx-runtime";
+var WEEK_MS = 7 * 24 * 60 * 60 * 1e3;
+var reportStyle = `
+.analytics-report {
+  box-sizing: border-box;
+  display: grid;
+  gap: 1.5rem;
+  max-width: 72rem;
+  padding: 1.5rem 1rem 3rem;
+  color: inherit;
+}
+.analytics-report h1,
+.analytics-report h2 {
+  margin: 0;
+}
+.analytics-report a {
+  color: inherit;
+}
+.analytics-filters {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(12rem, 1fr));
+  gap: 0.75rem;
+  align-items: end;
+}
+.analytics-filters label {
+  display: grid;
+  gap: 0.25rem;
+}
+.analytics-filters input,
+.analytics-filters button {
+  font: inherit;
+  min-height: 2.5rem;
+  padding: 0.4rem 0.6rem;
+}
+.analytics-totals {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(12rem, 1fr));
+  gap: 0.75rem;
+  margin: 0.75rem 0 0;
+}
+.analytics-scroll {
+  overflow-x: auto;
+  margin-top: 0.75rem;
+}
+.analytics-report table {
+  width: 100%;
+  border-collapse: collapse;
+}
+.analytics-report th,
+.analytics-report td {
+  text-align: start;
+  padding: 0.5rem 0.75rem;
+  border-bottom: 1px solid currentColor;
+  vertical-align: top;
+}
+.analytics-back {
+  justify-self: start;
+}
+@media (max-width: 40rem) {
+  .analytics-report {
+    padding: 1rem 0.75rem 2rem;
+  }
+}
+`;
+async function AnalyticsAdminView(props) {
+  if (!props.initPageResult.req.user) return null;
+  const modules = analyticsModulesFromConfig(props.payload.config);
+  const range = resolveRange(props.searchParams);
+  const country = modules.country ? firstParam(props.searchParams?.country) : null;
+  const path = firstParam(props.searchParams?.path);
+  const session = modules.sessions ? firstParam(props.searchParams?.session) : null;
+  const store = new PayloadAnalyticsEventStore(props.payload, modules);
+  const summary = await store.summarizeAnalytics(
+    {
+      from: range.from,
+      to: range.to,
+      country,
+      path,
+      sessionId: session
+    },
+    modules
+  );
+  const sections = adminSections(summary, modules, { session });
+  const visibleEntities = props.visibleEntities ?? props.initPageResult.visibleEntities;
+  return /* @__PURE__ */ jsx(
+    DefaultTemplate,
+    {
+      i18n: props.i18n,
+      payload: props.payload,
+      req: props.initPageResult.req,
+      viewType: props.viewType,
+      visibleEntities,
+      children: /* @__PURE__ */ jsxs("div", { className: "analytics-report", children: [
+        /* @__PURE__ */ jsx("style", { children: reportStyle }),
+        /* @__PURE__ */ jsx("h1", { children: "Analytics" }),
+        /* @__PURE__ */ jsx(
+          FilterForm,
+          {
+            from: range.from,
+            to: range.to,
+            country,
+            path,
+            session,
+            modules
+          }
+        ),
+        session ? /* @__PURE__ */ jsx("a", { className: "analytics-back", href: reportHref({ from: range.from, to: range.to, country, path }), children: "All sessions" }) : null,
+        sections.map((section) => /* @__PURE__ */ jsx(
+          SectionBlock,
+          {
+            section,
+            hrefForSession: (id) => reportHref({ from: range.from, to: range.to, country, path, session: id })
+          },
+          section.kind
+        ))
+      ] })
+    }
+  );
+}
+function FilterForm({
+  from,
+  to,
+  country,
+  path,
+  session,
+  modules
+}) {
+  return /* @__PURE__ */ jsxs("form", { className: "analytics-filters", method: "get", action: "/admin/analytics", children: [
+    /* @__PURE__ */ jsxs("label", { children: [
+      "From",
+      /* @__PURE__ */ jsx("input", { name: "from", type: "text", defaultValue: from, autoComplete: "off" })
+    ] }),
+    /* @__PURE__ */ jsxs("label", { children: [
+      "To",
+      /* @__PURE__ */ jsx("input", { name: "to", type: "text", defaultValue: to, autoComplete: "off" })
+    ] }),
+    modules.country ? /* @__PURE__ */ jsxs("label", { children: [
+      "Country",
+      /* @__PURE__ */ jsx("input", { name: "country", type: "text", defaultValue: country ?? "", maxLength: 2, autoComplete: "off" })
+    ] }) : null,
+    /* @__PURE__ */ jsxs("label", { children: [
+      "Path",
+      /* @__PURE__ */ jsx("input", { name: "path", type: "text", defaultValue: path ?? "", maxLength: 2048, autoComplete: "off" })
+    ] }),
+    session ? /* @__PURE__ */ jsx("input", { type: "hidden", name: "session", value: session }) : null,
+    /* @__PURE__ */ jsx("button", { type: "submit", children: "Apply" })
+  ] });
+}
+function SectionBlock({
+  section,
+  hrefForSession
+}) {
+  switch (section.kind) {
+    case "totals":
+      return /* @__PURE__ */ jsxs("section", { children: [
+        /* @__PURE__ */ jsx("h2", { children: "Totals" }),
+        /* @__PURE__ */ jsxs("dl", { className: "analytics-totals", children: [
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx("dt", { children: "Total views" }),
+            /* @__PURE__ */ jsx("dd", { children: section.totalViews })
+          ] }),
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx("dt", { children: "Average duration" }),
+            /* @__PURE__ */ jsx("dd", { children: formatSeconds(section.averageDurationSeconds) })
+          ] })
+        ] })
+      ] });
+    case "paths":
+      return /* @__PURE__ */ jsx(
+        DataTable,
+        {
+          title: "Paths",
+          columns: ["Path", "Views", "Average duration"],
+          rows: section.rows.map((row) => [row.path, String(row.views), formatSeconds(row.averageDurationSeconds)])
+        }
+      );
+    case "countries":
+      return /* @__PURE__ */ jsx(
+        DataTable,
+        {
+          title: "Countries",
+          columns: ["Country", "Views"],
+          rows: section.rows.map((row) => [row.country, String(row.views)])
+        }
+      );
+    case "cities":
+      return /* @__PURE__ */ jsx(
+        DataTable,
+        {
+          title: "Cities",
+          columns: ["City", "Views"],
+          rows: section.rows.map((row) => [row.city, String(row.views)])
+        }
+      );
+    case "namedClicks":
+      return /* @__PURE__ */ jsx(
+        DataTable,
+        {
+          title: "Named clicks",
+          columns: ["Event", "Count"],
+          rows: section.rows.map((row) => [row.eventName, String(row.count)])
+        }
+      );
+    case "sessions":
+      return /* @__PURE__ */ jsxs("section", { children: [
+        /* @__PURE__ */ jsx("h2", { children: "Sessions" }),
+        /* @__PURE__ */ jsx("div", { className: "analytics-scroll", children: /* @__PURE__ */ jsxs("table", { children: [
+          /* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsxs("tr", { children: [
+            /* @__PURE__ */ jsx("th", { scope: "col", children: "Session" }),
+            /* @__PURE__ */ jsx("th", { scope: "col", children: "Started" }),
+            /* @__PURE__ */ jsx("th", { scope: "col", children: "Pages" })
+          ] }) }),
+          /* @__PURE__ */ jsx("tbody", { children: section.rows.length === 0 ? /* @__PURE__ */ jsx("tr", { children: /* @__PURE__ */ jsx("td", { colSpan: 3, children: "None in this range." }) }) : section.rows.map((row) => /* @__PURE__ */ jsxs("tr", { children: [
+            /* @__PURE__ */ jsx("td", { children: /* @__PURE__ */ jsx("a", { href: hrefForSession(row.id), children: row.id }) }),
+            /* @__PURE__ */ jsx("td", { children: row.startedAt }),
+            /* @__PURE__ */ jsx("td", { children: row.pageCount })
+          ] }, row.id)) })
+        ] }) })
+      ] });
+    case "trail":
+      return /* @__PURE__ */ jsx(
+        DataTable,
+        {
+          title: "Session events",
+          columns: ["Time", "Kind", "Path", "Event"],
+          rows: section.events.map((event) => [
+            event.occurredAt,
+            event.kind === "click" ? "Click" : "View",
+            event.path,
+            event.eventName ?? ""
+          ])
+        }
+      );
+  }
+}
+function DataTable({ title, columns, rows }) {
+  return /* @__PURE__ */ jsxs("section", { children: [
+    /* @__PURE__ */ jsx("h2", { children: title }),
+    /* @__PURE__ */ jsx("div", { className: "analytics-scroll", children: /* @__PURE__ */ jsxs("table", { children: [
+      /* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsx("tr", { children: columns.map((column) => /* @__PURE__ */ jsx("th", { scope: "col", children: column }, column)) }) }),
+      /* @__PURE__ */ jsx("tbody", { children: rows.length === 0 ? /* @__PURE__ */ jsx("tr", { children: /* @__PURE__ */ jsx("td", { colSpan: columns.length, children: "None in this range." }) }) : rows.map((row, index) => /* @__PURE__ */ jsx("tr", { children: row.map((cell, cellIndex) => /* @__PURE__ */ jsx("td", { children: cell }, `${columns[cellIndex] ?? cellIndex}`)) }, `${title}-${index}`)) })
+    ] }) })
+  ] });
+}
+function reportHref(query) {
+  const params = new URLSearchParams();
+  params.set("from", query.from);
+  params.set("to", query.to);
+  if (query.country) params.set("country", query.country);
+  if (query.path) params.set("path", query.path);
+  if (query.session) params.set("session", query.session);
+  return `/admin/analytics?${params.toString()}`;
+}
+function resolveRange(searchParams) {
+  const now = /* @__PURE__ */ new Date();
+  const to = parseTime(firstParam(searchParams?.to), now);
+  const from = parseTime(firstParam(searchParams?.from), new Date(to.getTime() - WEEK_MS));
+  return { from: from.toISOString(), to: to.toISOString() };
+}
+function parseTime(value, fallback) {
+  if (value === null) return fallback;
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime())) return fallback;
+  return parsed;
+}
+function firstParam(value) {
+  const first = Array.isArray(value) ? value[0] : value;
+  if (typeof first !== "string") return null;
+  const trimmed = first.trim();
+  return trimmed.length === 0 ? null : trimmed;
+}
+function formatSeconds(value) {
+  if (!Number.isFinite(value)) return "0 seconds";
+  const rounded = Math.round(value * 10) / 10;
+  const text = Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(1);
+  return `${text} ${rounded === 1 ? "second" : "seconds"}`;
+}
+export {
+  AnalyticsAdminView
+};

package/dist/payload/index.d.ts

@@ -0,0 +1,70 @@
+import { Access, Config, Payload } from 'payload';
+import { AnalyticsModules, AnalyticsServerOptions } from '../index.js';
+import { AnalyticsSummary, AnalyticsEventStore, NewAnalyticsEvent, StoredAnalyticsEvent, AnalyticsSummaryQuery } from '../index.js';
+
+/**
+ * Read is allowed for a signed-in user, or by the function the plugin was given.
+ * Create, update, and delete stay closed. The ingest endpoint writes with overrideAccess.
+ */
+declare function analyticsEventsAccess(read?: Access): {
+    read: Access;
+    create: Access;
+    update: Access;
+    delete: Access;
+};
+
+interface AdminSectionsQuery {
+    session?: string | null;
+}
+type AdminSection = {
+    kind: "totals";
+    totalViews: number;
+    averageDurationSeconds: number;
+} | {
+    kind: "paths";
+    rows: AnalyticsSummary["byPath"];
+} | {
+    kind: "countries";
+    rows: NonNullable<AnalyticsSummary["byCountry"]>;
+} | {
+    kind: "cities";
+    rows: NonNullable<AnalyticsSummary["byCity"]>;
+} | {
+    kind: "namedClicks";
+    rows: NonNullable<AnalyticsSummary["byEventName"]>;
+} | {
+    kind: "sessions";
+    rows: NonNullable<AnalyticsSummary["sessions"]>;
+} | {
+    kind: "trail";
+    events: NonNullable<AnalyticsSummary["events"]>;
+};
+/**
+ * Blocks for the admin screen, in display order.
+ * A module that is off contributes no block.
+ * A session query replaces the session list with one trail of that session's events, in time order.
+ */
+declare function adminSections(summary: AnalyticsSummary, modules: AnalyticsModules, query: AdminSectionsQuery): AdminSection[];
+
+/**
+ * Adds the analytics collection, the ingest endpoint, and the admin screen.
+ * Existing collections, endpoints, and views stay in place.
+ */
+declare function analyticsPlugin(options: AnalyticsServerOptions & {
+    read?: Access;
+}): (config: Config) => Config;
+
+/**
+ * AnalyticsEventStore on Payload's Local API.
+ * Rows in the requested range are grouped by summarizeAnalyticsEvents.
+ */
+declare class PayloadAnalyticsEventStore implements AnalyticsEventStore {
+    private readonly payload;
+    private readonly modules;
+    constructor(payload: Payload, modules: AnalyticsModules);
+    insertAnalyticsEvent(event: NewAnalyticsEvent, occurredAt: string): Promise<StoredAnalyticsEvent>;
+    recordAnalyticsDuration(id: string, durationSeconds: number): Promise<void>;
+    summarizeAnalytics(query: AnalyticsSummaryQuery, modules: AnalyticsModules): Promise<AnalyticsSummary>;
+}
+
+export { PayloadAnalyticsEventStore, adminSections, analyticsEventsAccess, analyticsPlugin };

package/dist/payload/index.js

@@ -0,0 +1,100 @@
+import {
+  recordAnalyticsEvent
+} from "../chunk-GWOVVKP3.js";
+import {
+  ANALYTICS_CUSTOM_KEY,
+  PayloadAnalyticsEventStore,
+  adminSections,
+  analyticsEventsAccess,
+  analyticsEventsCollection
+} from "../chunk-GVOESWHZ.js";
+import "../chunk-Q4JRXZ6M.js";
+import "../chunk-F7BY2JQ3.js";
+
+// src/payload/endpoint.ts
+async function handleAnalyticsEvent(request, deps) {
+  const result = await recordAnalyticsEvent(
+    { body: request.body, headers: headerRecord(request.headers) },
+    deps
+  );
+  if (result.status === 204 || result.body === null) {
+    return new Response(null, { status: result.status });
+  }
+  return Response.json(result.body, { status: result.status });
+}
+function analyticsEventsEndpoint(options) {
+  return {
+    path: "/analytics/events",
+    method: "post",
+    handler: (req) => handlePayloadAnalyticsEvent(req, options)
+  };
+}
+async function handlePayloadAnalyticsEvent(req, options) {
+  const store = new PayloadAnalyticsEventStore(req.payload, options.modules);
+  let body;
+  try {
+    body = typeof req.json === "function" ? await req.json() : req.data;
+  } catch {
+    body = void 0;
+  }
+  return handleAnalyticsEvent({ body, headers: req.headers }, { store, options });
+}
+function headerRecord(headers) {
+  if (headers instanceof Headers) {
+    const record = {};
+    headers.forEach((value, key) => {
+      record[key] = value;
+    });
+    return record;
+  }
+  return headers;
+}
+
+// src/payload/plugin.ts
+function analyticsPlugin(options) {
+  return (config) => {
+    const admin = config.admin ?? {};
+    const components = admin.components ?? {};
+    return {
+      ...config,
+      collections: [...config.collections ?? [], analyticsEventsCollection(options.read)],
+      endpoints: [...config.endpoints ?? [], analyticsEventsEndpoint(options)],
+      admin: {
+        ...admin,
+        components: {
+          ...components,
+          views: {
+            ...components.views,
+            analytics: {
+              Component: {
+                path: "@nodewrite-labs/analytics-sdk/payload/admin-view",
+                exportName: "AnalyticsAdminView"
+              },
+              path: "/analytics"
+            }
+          },
+          afterNavLinks: [
+            ...components.afterNavLinks ?? [],
+            {
+              path: "@nodewrite-labs/analytics-sdk/payload/nav-link",
+              exportName: "AnalyticsNavLink"
+            }
+          ]
+        }
+      },
+      custom: {
+        ...config.custom,
+        [ANALYTICS_CUSTOM_KEY]: {
+          enabled: options.enabled,
+          modules: options.modules
+        }
+      }
+    };
+  };
+}
+export {
+  PayloadAnalyticsEventStore,
+  adminSections,
+  analyticsEventsAccess,
+  analyticsPlugin
+};

package/dist/payload/nav-link.d.ts

@@ -0,0 +1,5 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+declare function AnalyticsNavLink(): react_jsx_runtime.JSX.Element;
+
+export { AnalyticsNavLink };

package/dist/payload/nav-link.js

@@ -0,0 +1,8 @@
+// src/payload/admin/nav-link.tsx
+import { jsx } from "react/jsx-runtime";
+function AnalyticsNavLink() {
+  return /* @__PURE__ */ jsx("a", { href: "/admin/analytics", children: "Analytics" });
+}
+export {
+  AnalyticsNavLink
+};

package/dist/postgres/index.d.ts

@@ -0,0 +1,17 @@
+import { Pool } from 'pg';
+import { AnalyticsEventStore, NewAnalyticsEvent, StoredAnalyticsEvent, AnalyticsSummaryQuery, AnalyticsSummary } from '../index.js';
+import { AnalyticsModules } from '../index.js';
+
+declare class PostgresAnalyticsEventStore implements AnalyticsEventStore {
+    private readonly pool;
+    private readonly modules;
+    constructor(pool: Pool, modules: AnalyticsModules);
+    insertAnalyticsEvent(event: NewAnalyticsEvent, occurredAt: string): Promise<StoredAnalyticsEvent>;
+    recordAnalyticsDuration(id: string, durationSeconds: number): Promise<void>;
+    summarizeAnalytics(query: AnalyticsSummaryQuery, modules: AnalyticsModules): Promise<AnalyticsSummary>;
+}
+
+declare const analyticsEventSchemaSql: string;
+declare function applyAnalyticsSchema(pool: Pool): Promise<void>;
+
+export { PostgresAnalyticsEventStore, analyticsEventSchemaSql, applyAnalyticsSchema };

package/dist/postgres/index.js

@@ -0,0 +1,156 @@
+import {
+  acceptDurationSeconds,
+  summarizeAnalyticsEvents
+} from "../chunk-Q4JRXZ6M.js";
+import {
+  AnalyticsEventKind
+} from "../chunk-F7BY2JQ3.js";
+
+// src/postgres/store.ts
+import { randomUUID } from "crypto";
+var INSERT_EVENT = `
+  insert into analytics_event (
+    id,
+    kind,
+    path,
+    locale,
+    occurred_at,
+    duration_seconds,
+    country,
+    city,
+    session_id,
+    event_name
+  ) values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+  returning
+    id,
+    kind,
+    path,
+    locale,
+    occurred_at,
+    duration_seconds,
+    country,
+    city,
+    session_id,
+    event_name
+`;
+var SELECT_IN_RANGE = `
+  select
+    id,
+    kind,
+    path,
+    locale,
+    occurred_at,
+    duration_seconds,
+    country,
+    city,
+    session_id,
+    event_name
+  from analytics_event
+  where occurred_at >= $1 and occurred_at <= $2
+`;
+var PostgresAnalyticsEventStore = class {
+  constructor(pool, modules) {
+    this.pool = pool;
+    this.modules = modules;
+  }
+  pool;
+  modules;
+  async insertAnalyticsEvent(event, occurredAt) {
+    const id = randomUUID();
+    const result = await this.pool.query(INSERT_EVENT, [
+      id,
+      event.kind,
+      event.path,
+      event.locale,
+      occurredAt,
+      durationColumn(event.durationSeconds),
+      this.modules.country ? event.country : null,
+      this.modules.city ? event.city : null,
+      this.modules.sessions ? event.sessionId : null,
+      this.modules.clicks ? event.eventName : null
+    ]);
+    return requiredRow(result.rows[0]);
+  }
+  async recordAnalyticsDuration(id, durationSeconds) {
+    const accepted = acceptDurationSeconds(durationSeconds);
+    if (accepted === null) return;
+    await this.pool.query(
+      "update analytics_event set duration_seconds = $1 where id = $2 and kind = $3",
+      [Math.round(accepted), id, AnalyticsEventKind.VIEW]
+    );
+  }
+  async summarizeAnalytics(query, modules) {
+    const result = await this.pool.query(SELECT_IN_RANGE, [query.from, query.to]);
+    const rows = [];
+    for (const row of result.rows) {
+      const mapped = mapRow(row);
+      if (mapped) rows.push(mapped);
+    }
+    return summarizeAnalyticsEvents(rows, query, modules);
+  }
+};
+function durationColumn(value) {
+  if (value === null) return null;
+  const accepted = acceptDurationSeconds(value);
+  if (accepted === null) return null;
+  return Math.round(accepted);
+}
+function requiredRow(row) {
+  const mapped = row ? mapRow(row) : null;
+  if (!mapped) throw new Error("analytics_event insert did not return a row");
+  return mapped;
+}
+function mapRow(row) {
+  if (row.kind !== AnalyticsEventKind.VIEW && row.kind !== AnalyticsEventKind.CLICK) return null;
+  return {
+    id: String(row.id),
+    kind: row.kind,
+    path: row.path,
+    locale: row.locale,
+    occurredAt: toIso(row.occurred_at),
+    durationSeconds: durationFromColumn(row.duration_seconds),
+    country: row.country,
+    city: row.city,
+    sessionId: row.session_id,
+    eventName: row.event_name
+  };
+}
+function durationFromColumn(value) {
+  if (value === null) return null;
+  const numeric = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(numeric)) return null;
+  return numeric;
+}
+function toIso(value) {
+  if (value instanceof Date) return value.toISOString();
+  return new Date(value).toISOString();
+}
+
+// src/postgres/schema.ts
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+var here = dirname(fileURLToPath(import.meta.url));
+function readSchema() {
+  const candidates = [join(here, "schema.sql"), join(here, "..", "..", "src", "postgres", "schema.sql")];
+  for (const candidate of candidates) {
+    try {
+      return readFileSync(candidate, "utf8");
+    } catch (error) {
+      if (!isMissingFile(error)) throw error;
+    }
+  }
+  throw new Error("analytics schema.sql was not found");
+}
+function isMissingFile(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+var analyticsEventSchemaSql = readSchema();
+async function applyAnalyticsSchema(pool) {
+  await pool.query(analyticsEventSchemaSql);
+}
+export {
+  PostgresAnalyticsEventStore,
+  analyticsEventSchemaSql,
+  applyAnalyticsSchema
+};

package/dist/server/index.d.ts

@@ -0,0 +1,44 @@
+import { AnalyticsEventStore } from '../index.js';
+import { AnalyticsServerOptions } from '../index.js';
+
+interface RequestGeo {
+    country: string | null;
+    city: string | null;
+}
+/** Reads `country` and `city` from the request object the app passed in. */
+declare function readRequestGeo(request: object): RequestGeo;
+
+type AnalyticsHeaderBag = Headers | Record<string, string | string[] | undefined>;
+
+interface AnalyticsEventRequest {
+    body?: unknown;
+    headers?: AnalyticsHeaderBag;
+    request?: Request;
+    country?: unknown;
+    city?: unknown;
+}
+interface RecordAnalyticsEventDeps {
+    store: AnalyticsEventStore;
+    options: AnalyticsServerOptions;
+    now?: () => string;
+}
+interface RecordAnalyticsEventResult {
+    status: number;
+    body: {
+        id: string;
+    } | null;
+}
+/**
+ * Validates one analytics request and writes it through the store.
+ *
+ * A stored view or click returns status 200 and `{ id }`.
+ * Status 204 and a null body means analytics is disabled, clicks are off, or a duration was recorded.
+ * Status 400 and a null body means the request cannot be stored.
+ * `occurredAt` comes from `deps.now`, otherwise the server clock.
+ * Pass a Fetch `Request`, or `{ body, country, city }`. `request` is read when `body` is omitted.
+ * Country and city are the properties on that object. The JSON body is not a source for them.
+ */
+declare function recordAnalyticsEvent(request: AnalyticsEventRequest | Request, deps: RecordAnalyticsEventDeps): Promise<RecordAnalyticsEventResult>;
+
+export { readRequestGeo, recordAnalyticsEvent };
+export type { AnalyticsEventRequest, AnalyticsHeaderBag, RecordAnalyticsEventDeps, RecordAnalyticsEventResult, RequestGeo };