@stacksee/analytics 0.5.0 → 0.8.0

package/dist/providers/bento/client.d.ts

@@ -0,0 +1,47 @@
+import { BaseEvent, EventContext } from '../../core/events/types.js';
+import { BaseAnalyticsProvider } from '../base.provider.js';
+interface BentoClient {
+    view(): void;
+    identify(email: string): void;
+    track(event: string, data?: Record<string, unknown>): void;
+    tag(tag: string): void;
+    updateFields(fields: Record<string, unknown>): void;
+    getEmail(): string | null;
+    getName(): string | null;
+}
+export interface BentoClientConfig {
+    /**
+     * Your Bento Site UUID from Account Settings
+     */
+    siteUuid: string;
+    /**
+     * Enable debug logging
+     */
+    debug?: boolean;
+    /**
+     * Enable/disable the provider
+     */
+    enabled?: boolean;
+}
+declare global {
+    interface Window {
+        bento?: BentoClient;
+    }
+}
+export declare class BentoClientProvider extends BaseAnalyticsProvider {
+    name: string;
+    private bento?;
+    private initialized;
+    private config;
+    private scriptLoaded;
+    constructor(config: BentoClientConfig);
+    initialize(): Promise<void>;
+    private loadBentoScript;
+    private waitForBento;
+    identify(userId: string, traits?: Record<string, unknown>): void;
+    track(event: BaseEvent, context?: EventContext): void;
+    pageView(properties?: Record<string, unknown>, context?: EventContext): void;
+    pageLeave(properties?: Record<string, unknown>, context?: EventContext): void;
+    reset(): void;
+}
+export {};

package/dist/providers/bento/server.d.ts

@@ -0,0 +1,58 @@
+import { BaseEvent, EventContext } from '../../core/events/types.js';
+import { BaseAnalyticsProvider } from '../base.provider.js';
+export interface BentoAnalyticsOptions {
+    /**
+     * Your Bento Site UUID from Team Settings
+     */
+    siteUuid: string;
+    /**
+     * Authentication credentials
+     */
+    authentication: {
+        /**
+         * Your Bento Publishable Key from Team Settings
+         */
+        publishableKey: string;
+        /**
+         * Your Bento Secret Key from Team Settings
+         */
+        secretKey: string;
+    };
+    /**
+     * Optional client configuration
+     */
+    clientOptions?: {
+        /**
+         * Base URL for the Bento API (optional)
+         */
+        baseUrl?: string;
+    };
+    /**
+     * Whether to log errors (optional)
+     */
+    logErrors?: boolean;
+}
+export interface BentoServerConfig extends BentoAnalyticsOptions {
+    /**
+     * Enable debug logging
+     */
+    debug?: boolean;
+    /**
+     * Enable/disable the provider
+     */
+    enabled?: boolean;
+}
+export declare class BentoServerProvider extends BaseAnalyticsProvider {
+    name: string;
+    private client?;
+    private initialized;
+    private config;
+    private currentUserEmail?;
+    constructor(config: BentoServerConfig);
+    initialize(): Promise<void>;
+    identify(userId: string, traits?: Record<string, unknown>): void;
+    track(event: BaseEvent, context?: EventContext): Promise<void>;
+    pageView(properties?: Record<string, unknown>, context?: EventContext): void;
+    reset(): Promise<void>;
+    shutdown(): Promise<void>;
+}

package/dist/providers/client.d.ts

@@ -1,3 +1,10 @@
 export { BaseAnalyticsProvider } from './base.provider.js';
 export { PostHogClientProvider } from './posthog/client.js';
 export type { PostHogConfig } from 'posthog-js';
+export { BentoClientProvider } from './bento/client.js';
+export type { BentoClientConfig } from './bento/client.js';
+export { PirschClientProvider } from './pirsch/client.js';
+export type { PirschClientConfig } from './pirsch/client.js';
+export { ProxyProvider } from './proxy/client.js';
+export type { ProxyProviderConfig } from './proxy/client.js';
+export type { ProxyBatchConfig, ProxyRetryConfig, ProxyEvent, ProxyPayload, ProxyTrackEvent, ProxyIdentifyEvent, ProxyPageViewEvent, ProxyResetEvent, } from './proxy/types.js';

package/dist/providers/client.js

@@ -1,6 +1,373 @@
-import { B as e } from "../base.provider-AfFL5W_P.js";
-import { P as t } from "../client-DTHZYkxx.js";
+var u = Object.defineProperty;
+var f = (h, n, i) => n in h ? u(h, n, { enumerable: !0, configurable: !0, writable: !0, value: i }) : h[n] = i;
+var r = (h, n, i) => f(h, typeof n != "symbol" ? n + "" : n, i);
+import { B as o } from "../base.provider-AfFL5W_P.js";
+import { i as l } from "../client-DTHZYkxx.js";
+import { P as E } from "../client-DTHZYkxx.js";
+class y extends o {
+  constructor(i) {
+    super({ debug: i.debug, enabled: i.enabled });
+    r(this, "name", "Bento-Client");
+    r(this, "bento");
+    r(this, "initialized", !1);
+    r(this, "config");
+    r(this, "scriptLoaded", !1);
+    this.config = i;
+  }
+  async initialize() {
+    if (this.isEnabled() && !this.initialized) {
+      if (!l()) {
+        this.log("Skipping initialization - not in browser environment");
+        return;
+      }
+      if (!this.config.siteUuid || typeof this.config.siteUuid != "string")
+        throw new Error("Bento requires a siteUuid");
+      try {
+        this.scriptLoaded || await this.loadBentoScript(), await this.waitForBento(), this.bento = window.bento, this.initialized = !0, this.log("Initialized successfully", this.config);
+      } catch (i) {
+        throw console.error("[Bento-Client] Failed to initialize:", i), i;
+      }
+    }
+  }
+  async loadBentoScript() {
+    return new Promise((i, e) => {
+      if (document.querySelector(
+        'script[src*="bentonow.com"]'
+      )) {
+        this.scriptLoaded = !0, i();
+        return;
+      }
+      const t = document.createElement("script");
+      t.src = `https://cdn.bentonow.com/v1/${this.config.siteUuid}/bento.js`, t.async = !0, t.onload = () => {
+        this.scriptLoaded = !0, i();
+      }, t.onerror = () => {
+        e(new Error("Failed to load Bento script"));
+      }, document.head.appendChild(t);
+    });
+  }
+  async waitForBento(i = 50, e = 100) {
+    for (let s = 0; s < i; s++) {
+      if (window.bento)
+        return;
+      await new Promise((t) => setTimeout(t, e));
+    }
+    throw new Error("Bento SDK not available after loading script");
+  }
+  identify(i, e) {
+    if (!this.isEnabled() || !this.initialized || !this.bento) return;
+    const s = (e == null ? void 0 : e.email) || i;
+    if (this.bento.identify(s), e) {
+      const t = { ...e };
+      delete t.email, Object.keys(t).length > 0 && this.bento.updateFields(t);
+    }
+    this.log("Identified user", { userId: i, email: s, traits: e });
+  }
+  track(i, e) {
+    var t, a;
+    if (!this.isEnabled() || !this.initialized || !this.bento) return;
+    const s = {
+      ...i.properties,
+      category: i.category,
+      timestamp: i.timestamp || Date.now(),
+      ...i.userId && { userId: i.userId },
+      ...i.sessionId && { sessionId: i.sessionId },
+      ...(e == null ? void 0 : e.page) && {
+        page: {
+          path: e.page.path,
+          title: e.page.title,
+          referrer: e.page.referrer
+        }
+      },
+      ...(e == null ? void 0 : e.device) && { device: e.device },
+      ...(e == null ? void 0 : e.utm) && { utm: e.utm },
+      // Include user email and traits as regular event properties
+      ...((t = e == null ? void 0 : e.user) == null ? void 0 : t.email) && { user_email: e.user.email },
+      ...((a = e == null ? void 0 : e.user) == null ? void 0 : a.traits) && { user_traits: e.user.traits }
+    };
+    this.bento.track(i.action, s), this.log("Tracked event", { event: i, context: e });
+  }
+  pageView(i, e) {
+    if (!(!this.isEnabled() || !this.initialized || !this.bento || !l())) {
+      if (this.bento.view(), i || e != null && e.page) {
+        const s = {
+          ...i,
+          ...(e == null ? void 0 : e.page) && {
+            path: e.page.path,
+            title: e.page.title,
+            referrer: e.page.referrer
+          }
+        };
+        this.bento.track("$pageview", s);
+      }
+      this.log("Tracked page view", { properties: i, context: e });
+    }
+  }
+  pageLeave(i, e) {
+    if (!this.isEnabled() || !this.initialized || !this.bento || !l())
+      return;
+    const s = {
+      ...i,
+      ...(e == null ? void 0 : e.page) && {
+        path: e.page.path,
+        title: e.page.title,
+        referrer: e.page.referrer
+      }
+    };
+    this.bento.track("$pageleave", s), this.log("Tracked page leave", { properties: i, context: e });
+  }
+  reset() {
+    !this.isEnabled() || !this.initialized || !this.bento || !l() || this.log("Reset user session - Note: Bento doesn't have a native reset method");
+  }
+}
+class w extends o {
+  constructor(i) {
+    super({ debug: i.debug, enabled: i.enabled });
+    r(this, "name", "Pirsch-Client");
+    r(this, "client");
+    r(this, "initialized", !1);
+    r(this, "config");
+    this.config = i;
+  }
+  async initialize() {
+    if (this.isEnabled() && !this.initialized) {
+      if (!l()) {
+        this.log("Skipping initialization - not in browser environment");
+        return;
+      }
+      if (!this.config.identificationCode || typeof this.config.identificationCode != "string")
+        throw new Error("Pirsch requires an identificationCode");
+      try {
+        const { Pirsch: i } = await import("../web-CvEQewPd.js").then((e) => e.w);
+        this.client = new i({
+          identificationCode: this.config.identificationCode,
+          ...this.config.hostname && { hostname: this.config.hostname }
+        }), this.initialized = !0, this.log("Initialized successfully", this.config);
+      } catch (i) {
+        throw console.error(
+          "[Pirsch-Client] Failed to initialize. Make sure pirsch-sdk is installed:",
+          i
+        ), i;
+      }
+    }
+  }
+  identify(i, e) {
+    !this.isEnabled() || !this.initialized || !this.client || (this.client.event("user_identified", 0, {
+      userId: i,
+      ...e
+    }).catch((s) => {
+      console.error("[Pirsch-Client] Failed to track identify event:", s);
+    }), this.log("Identified user via event", { userId: i, traits: e }));
+  }
+  async track(i, e) {
+    var t, a;
+    if (!this.isEnabled() || !this.initialized || !this.client) return;
+    const s = {
+      ...i.properties,
+      category: i.category,
+      ...i.userId && { userId: i.userId },
+      ...i.sessionId && { sessionId: i.sessionId },
+      ...(e == null ? void 0 : e.page) && {
+        page_path: e.page.path,
+        page_title: e.page.title,
+        page_referrer: e.page.referrer
+      },
+      ...(e == null ? void 0 : e.device) && { device: e.device },
+      ...(e == null ? void 0 : e.utm) && { utm: e.utm },
+      ...((t = e == null ? void 0 : e.user) == null ? void 0 : t.email) && { user_email: e.user.email },
+      ...((a = e == null ? void 0 : e.user) == null ? void 0 : a.traits) && { user_traits: e.user.traits }
+    };
+    try {
+      await this.client.event(i.action, 0, s), this.log("Tracked event", { event: i, context: e });
+    } catch (d) {
+      console.error("[Pirsch-Client] Failed to track event:", d);
+    }
+  }
+  pageView(i, e) {
+    if (!(!this.isEnabled() || !this.initialized || !this.client || !l())) {
+      if (this.client.hit().catch((s) => {
+        console.error("[Pirsch-Client] Failed to track page view:", s);
+      }), i && Object.keys(i).length > 0) {
+        const s = {
+          ...i,
+          ...(e == null ? void 0 : e.page) && {
+            path: e.page.path,
+            title: e.page.title,
+            referrer: e.page.referrer
+          }
+        };
+        this.client.event("page_view", 0, s).catch((t) => {
+          console.error(
+            "[Pirsch-Client] Failed to track page view event:",
+            t
+          );
+        });
+      }
+      this.log("Tracked page view", { properties: i, context: e });
+    }
+  }
+  pageLeave(i, e) {
+    if (!this.isEnabled() || !this.initialized || !this.client || !l())
+      return;
+    const s = {
+      ...i,
+      ...(e == null ? void 0 : e.page) && {
+        path: e.page.path,
+        title: e.page.title
+      }
+    };
+    this.client.event("page_leave", 0, s).catch((t) => {
+      console.error("[Pirsch-Client] Failed to track page leave:", t);
+    }), this.log("Tracked page leave", { properties: i, context: e });
+  }
+  reset() {
+    !this.isEnabled() || !this.initialized || !this.client || !l() || (this.client.event("session_reset", 0, {}).catch((i) => {
+      console.error("[Pirsch-Client] Failed to track session reset:", i);
+    }), this.log("Reset user session"));
+  }
+}
+class m extends o {
+  constructor(i) {
+    var e, s, t, a, d;
+    super({ debug: i.debug, enabled: i.enabled });
+    r(this, "name", "Proxy");
+    r(this, "config");
+    r(this, "queue", []);
+    r(this, "flushTimer");
+    r(this, "batchSize");
+    r(this, "batchInterval");
+    r(this, "retryAttempts");
+    r(this, "retryBackoff");
+    r(this, "retryInitialDelay");
+    this.config = i, this.batchSize = ((e = i.batch) == null ? void 0 : e.size) ?? 10, this.batchInterval = ((s = i.batch) == null ? void 0 : s.interval) ?? 5e3, this.retryAttempts = ((t = i.retry) == null ? void 0 : t.attempts) ?? 3, this.retryBackoff = ((a = i.retry) == null ? void 0 : a.backoff) ?? "exponential", this.retryInitialDelay = ((d = i.retry) == null ? void 0 : d.initialDelay) ?? 1e3, typeof window < "u" && (window.addEventListener("beforeunload", () => {
+      this.flush(!0);
+    }), document.addEventListener("visibilitychange", () => {
+      document.visibilityState === "hidden" && this.flush(!0);
+    }));
+  }
+  async initialize() {
+    this.isEnabled() && this.log("Initialized successfully", { endpoint: this.config.endpoint });
+  }
+  identify(i, e) {
+    this.isEnabled() && (this.queueEvent({
+      type: "identify",
+      userId: i,
+      traits: e
+    }), this.log("Queued identify event", { userId: i, traits: e }));
+  }
+  async track(i, e) {
+    this.isEnabled() && (this.queueEvent({
+      type: "track",
+      event: i,
+      context: this.enrichContext(e)
+    }), this.log("Queued track event", { event: i, context: e }));
+  }
+  pageView(i, e) {
+    this.isEnabled() && (this.queueEvent({
+      type: "pageView",
+      properties: i,
+      context: this.enrichContext(e)
+    }), this.log("Queued page view event", { properties: i, context: e }));
+  }
+  async reset() {
+    this.isEnabled() && (this.queueEvent({
+      type: "reset"
+    }), this.log("Queued reset event"));
+  }
+  async shutdown() {
+    await this.flush(!0), this.log("Shutdown complete");
+  }
+  /**
+   * Manually flush all queued events
+   */
+  async flush(i = !1) {
+    if (this.queue.length === 0) return;
+    const e = [...this.queue];
+    this.queue = [], this.flushTimer && (clearTimeout(this.flushTimer), this.flushTimer = void 0), await this.sendEvents(e, i);
+  }
+  queueEvent(i) {
+    if (this.queue.push(i), this.queue.length >= this.batchSize) {
+      this.flush().catch((e) => {
+        console.error("[Proxy] Failed to flush events:", e);
+      });
+      return;
+    }
+    this.flushTimer || (this.flushTimer = setTimeout(() => {
+      this.flush().catch((e) => {
+        console.error("[Proxy] Failed to flush events:", e);
+      });
+    }, this.batchInterval));
+  }
+  async sendEvents(i, e = !1) {
+    const s = { events: i };
+    if (e && typeof navigator < "u" && navigator.sendBeacon) {
+      const t = new Blob([JSON.stringify(s)], {
+        type: "application/json"
+      });
+      navigator.sendBeacon(this.config.endpoint, t) || console.warn("[Proxy] Failed to send events via beacon");
+      return;
+    }
+    await this.sendWithRetry(s);
+  }
+  async sendWithRetry(i, e = 0) {
+    try {
+      const s = await fetch(this.config.endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.config.headers
+        },
+        body: JSON.stringify(i),
+        // Don't include credentials by default
+        credentials: "same-origin"
+      });
+      if (!s.ok)
+        throw new Error(`HTTP ${s.status}: ${s.statusText}`);
+      this.log(`Sent ${i.events.length} events successfully`);
+    } catch (s) {
+      if (e < this.retryAttempts) {
+        const t = this.calculateRetryDelay(e);
+        return this.log(`Retry attempt ${e + 1} after ${t}ms`, { error: s }), await new Promise((a) => setTimeout(a, t)), this.sendWithRetry(i, e + 1);
+      }
+      throw console.error("[Proxy] Failed to send events after retries:", s), s;
+    }
+  }
+  calculateRetryDelay(i) {
+    return this.retryBackoff === "exponential" ? this.retryInitialDelay * 2 ** i : this.retryInitialDelay * (i + 1);
+  }
+  enrichContext(i) {
+    return typeof window > "u" ? i || {} : {
+      ...i,
+      page: {
+        path: window.location.pathname,
+        title: document.title,
+        referrer: document.referrer,
+        ...i == null ? void 0 : i.page,
+        url: window.location.href
+      },
+      user: {
+        ...i == null ? void 0 : i.user
+      },
+      device: {
+        ...i == null ? void 0 : i.device,
+        userAgent: navigator.userAgent,
+        language: navigator.language,
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        screen: {
+          width: window.screen.width,
+          height: window.screen.height
+        },
+        viewport: {
+          width: window.innerWidth,
+          height: window.innerHeight
+        }
+      }
+    };
+  }
+}
 export {
-  e as BaseAnalyticsProvider,
-  t as PostHogClientProvider
+  o as BaseAnalyticsProvider,
+  y as BentoClientProvider,
+  w as PirschClientProvider,
+  E as PostHogClientProvider,
+  m as ProxyProvider
 };

package/dist/providers/pirsch/client.d.ts

@@ -0,0 +1,34 @@
+import { BaseEvent, EventContext } from '../../core/events/types.js';
+import { BaseAnalyticsProvider } from '../base.provider.js';
+export interface PirschClientConfig {
+    /**
+     * Your Pirsch identification code from the dashboard
+     * Found in: Settings > Integrations > JavaScript Snippet
+     */
+    identificationCode: string;
+    /**
+     * The hostname/domain being tracked (e.g., "example.com")
+     */
+    hostname?: string;
+    /**
+     * Enable debug logging
+     */
+    debug?: boolean;
+    /**
+     * Enable/disable the provider
+     */
+    enabled?: boolean;
+}
+export declare class PirschClientProvider extends BaseAnalyticsProvider {
+    name: string;
+    private client?;
+    private initialized;
+    private config;
+    constructor(config: PirschClientConfig);
+    initialize(): Promise<void>;
+    identify(userId: string, traits?: Record<string, unknown>): void;
+    track(event: BaseEvent, context?: EventContext): Promise<void>;
+    pageView(properties?: Record<string, unknown>, context?: EventContext): void;
+    pageLeave(properties?: Record<string, unknown>, context?: EventContext): void;
+    reset(): void;
+}

package/dist/providers/pirsch/server.d.ts

@@ -0,0 +1,49 @@
+import { BaseEvent, EventContext } from '../../core/events/types.js';
+import { BaseAnalyticsProvider } from '../base.provider.js';
+import { PirschProxyHeader, Protocol } from 'pirsch-sdk';
+export interface PirschServerConfig {
+    /**
+     * The hostname/domain being tracked (required)
+     * Example: "example.com"
+     */
+    hostname: string;
+    /**
+     * Protocol to use (default: "https")
+     */
+    protocol?: Protocol;
+    /**
+     * Client ID for OAuth authentication
+     * Required if not using access key
+     */
+    clientId?: string;
+    /**
+     * Client secret or access key for authentication
+     * Access keys start with "pa_"
+     */
+    clientSecret: string;
+    /**
+     * Trusted proxy headers for IP extraction
+     */
+    trustedProxyHeaders?: PirschProxyHeader[];
+    /**
+     * Enable debug logging
+     */
+    debug?: boolean;
+    /**
+     * Enable/disable the provider
+     */
+    enabled?: boolean;
+}
+export declare class PirschServerProvider extends BaseAnalyticsProvider {
+    name: string;
+    private client?;
+    private initialized;
+    private config;
+    constructor(config: PirschServerConfig);
+    initialize(): Promise<void>;
+    identify(userId: string, traits?: Record<string, unknown>): void;
+    track(event: BaseEvent, context?: EventContext): Promise<void>;
+    pageView(properties?: Record<string, unknown>, context?: EventContext): void;
+    reset(): Promise<void>;
+    shutdown(): Promise<void>;
+}

package/dist/providers/proxy/client.d.ts

@@ -0,0 +1,56 @@
+import { BaseEvent, EventContext } from '../../core/events/types.js';
+import { BaseAnalyticsProvider } from '../base.provider.js';
+import { ProxyBatchConfig, ProxyRetryConfig } from './types.js';
+export interface ProxyProviderConfig {
+    /**
+     * The endpoint to send events to (e.g., '/api/events')
+     */
+    endpoint: string;
+    /**
+     * Batching configuration
+     */
+    batch?: ProxyBatchConfig;
+    /**
+     * Retry configuration
+     */
+    retry?: ProxyRetryConfig;
+    /**
+     * Custom headers to include in requests
+     */
+    headers?: Record<string, string>;
+    /**
+     * Enable debug logging
+     */
+    debug?: boolean;
+    /**
+     * Enable/disable the provider
+     */
+    enabled?: boolean;
+}
+export declare class ProxyProvider extends BaseAnalyticsProvider {
+    name: string;
+    private config;
+    private queue;
+    private flushTimer?;
+    private readonly batchSize;
+    private readonly batchInterval;
+    private readonly retryAttempts;
+    private readonly retryBackoff;
+    private readonly retryInitialDelay;
+    constructor(config: ProxyProviderConfig);
+    initialize(): Promise<void>;
+    identify(userId: string, traits?: Record<string, unknown>): void;
+    track(event: BaseEvent, context?: EventContext): Promise<void>;
+    pageView(properties?: Record<string, unknown>, context?: EventContext): void;
+    reset(): Promise<void>;
+    shutdown(): Promise<void>;
+    /**
+     * Manually flush all queued events
+     */
+    flush(useBeacon?: boolean): Promise<void>;
+    private queueEvent;
+    private sendEvents;
+    private sendWithRetry;
+    private calculateRetryDelay;
+    private enrichContext;
+}

package/dist/providers/proxy/server.d.ts

@@ -0,0 +1,55 @@
+import { ServerAnalytics } from '../../server.js';
+/**
+ * Configuration for ingesting proxy events
+ */
+export interface IngestProxyEventsConfig {
+    /**
+     * Enrich context with server-side data
+     */
+    enrichContext?: (request: Request) => Record<string, unknown>;
+    /**
+     * Extract IP address from request
+     * Default: Uses standard headers (X-Forwarded-For, X-Real-IP)
+     */
+    extractIp?: (request: Request) => string | undefined;
+    /**
+     * Error handler
+     */
+    onError?: (error: unknown) => void;
+}
+/**
+ * Ingests events from ProxyProvider and replays them through server analytics
+ *
+ * @example
+ * ```typescript
+ * // Next.js App Router
+ * export async function POST(req: Request) {
+ *   await ingestProxyEvents(req, serverAnalytics);
+ *   return new Response('OK');
+ * }
+ *
+ * // With custom IP extraction
+ * export async function POST(req: Request) {
+ *   await ingestProxyEvents(req, serverAnalytics, {
+ *     extractIp: (req) => req.headers.get('cf-connecting-ip') // Cloudflare
+ *   });
+ *   return new Response('OK');
+ * }
+ * ```
+ */
+export declare function ingestProxyEvents<TEventMap extends Record<string, Record<string, unknown>> = Record<string, Record<string, unknown>>, TUserTraits extends Record<string, unknown> = Record<string, unknown>>(request: Request, analytics: ServerAnalytics<TEventMap, TUserTraits>, config?: IngestProxyEventsConfig): Promise<void>;
+/**
+ * Creates a Request handler for common frameworks
+ *
+ * @example
+ * ```typescript
+ * // Next.js App Router
+ * export const POST = createProxyHandler(serverAnalytics);
+ *
+ * // With custom config
+ * export const POST = createProxyHandler(serverAnalytics, {
+ *   extractIp: (req) => req.headers.get('cf-connecting-ip')
+ * });
+ * ```
+ */
+export declare function createProxyHandler<TEventMap extends Record<string, Record<string, unknown>> = Record<string, Record<string, unknown>>, TUserTraits extends Record<string, unknown> = Record<string, unknown>>(analytics: ServerAnalytics<TEventMap, TUserTraits>, config?: IngestProxyEventsConfig): (request: Request) => Promise<Response>;