@reopt-ai/data-sdk-client 0.1.5 → 0.2.0

package/dist/client-BCrui21p.d.cts

@@ -0,0 +1,744 @@
+import "@reopt-ai/data-contract/ingest";
+import { ExceptionEntry, ExceptionLevel, ExceptionStep } from "@reopt-ai/data-contract/events";
+import { ConsentCookieState, DeviceCookieState, ReoptBootstrap } from "@reopt-ai/data-contract/identity";
+//#region ../data-sdk-core/src/types.d.ts
+/**
+ * Types shared by every runtime. Nothing here refers to `window`, `document`
+ * or a Node built-in — the runtime-specific pieces are injected through
+ * {@link ReoptRuntime}.
+ */
+/** Consent categories. `analytics` is the one whose refusal stops everything. */
+type ConsentCategory = "analytics" | "marketing" | "functional" | "performance";
+interface ConsentConfig {
+  /** Default decision for every configured category. Default: `true` (opt-out model). */
+  defaultConsent?: boolean | undefined;
+  /** Categories the integration recognises. Default: `["analytics"]`. */
+  categories?: ConsentCategory[] | undefined;
+  /** Persist decisions through the runtime's storage. Default: `true`. */
+  persist?: boolean | undefined;
+}
+/** Minimal synchronous key/value store — `localStorage`-shaped on purpose. */
+interface StorageBackend {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+  removeItem(key: string): void;
+}
+interface RetryConfig {
+  /** Attempts after the first. Default: 3. */
+  maxRetries?: number | undefined;
+  /** First back-off, milliseconds. Default: 1000. */
+  baseDelay?: number | undefined;
+  /** Back-off ceiling, milliseconds. Default: 30000. */
+  maxDelay?: number | undefined;
+  /** ± fraction of the delay. Default: 0.1. */
+  jitter?: number | undefined;
+}
+interface CircuitBreakerConfig {
+  /** Consecutive transient failures before the circuit opens. Default: 5. */
+  failureThreshold?: number | undefined;
+  /** How long the circuit stays open before one probe is allowed. Default: 60000. */
+  recoveryTimeout?: number | undefined;
+}
+interface BatchConfig {
+  /** Events per request. Default: 100. */
+  size?: number | undefined;
+  /** Milliseconds to wait for a batch to fill before sending. Default: 1000. */
+  intervalMs?: number | undefined;
+  /**
+   * Serialized bytes per request. Default: 400 000, under the server's
+   * 512 000 hard cap with room for the JSON envelope. A 413 is a 4xx, and 4xx
+   * drops the batch — so overshooting the cap loses every event in it.
+   */
+  maxBytes?: number | undefined;
+}
+/** Browser credentials — public, ships in the page. */
+interface WriteKeyAuth {
+  writeKey: string;
+}
+/** Server credentials — must never reach a client bundle. */
+interface ClientCredentialsAuth {
+  clientId: string;
+  clientSecret: string;
+}
+type ReoptAuth = WriteKeyAuth | ClientCredentialsAuth;
+type FetchLike = (input: string, init: FetchInit) => Promise<FetchResponseLike>;
+interface FetchInit {
+  method: string;
+  headers: Record<string, string>;
+  body: string;
+  keepalive?: boolean | undefined;
+}
+interface FetchResponseLike {
+  ok: boolean;
+  status: number;
+  headers: {
+    get(name: string): string | null;
+  };
+  text(): Promise<string>;
+}
+/** Context the runtime fills in for a `$pageview` when the caller does not. */
+interface PageContext {
+  path?: string | undefined;
+  origin?: string | undefined;
+  title?: string | undefined;
+  referrer?: string | undefined;
+  utm?: UTMParams | undefined;
+  /** Extra properties the runtime derived from the page, e.g. a `normalizePath` hook's output. */
+  properties?: Record<string, unknown> | undefined;
+}
+/**
+ * Everything the engine needs from the world around it. The browser package
+ * fills this from cookies, `localStorage` and `window`; the server package
+ * from request cookies and headers; tests from plain objects.
+ */
+interface ReoptRuntime {
+  /** Resolved device id. Identity resolution is the runtime's job, not the engine's. */
+  deviceId: string;
+  /**
+   * Value for the `reopt-session-id` header — the `"<id>.<token>"` credential
+   * ingest handed back, if the runtime kept it. Unsigned values are ignored
+   * by ingest, so only send what came from `onSession`.
+   */
+  getSessionId?: (() => string | null | undefined) | undefined;
+  /** Ingest assigned (or confirmed) a session for this batch. The runtime persists it. */
+  onSession?: ((credential: {
+    id: string;
+    token: string;
+  }) => void) | undefined | undefined;
+  /** Durable store for the offline queue and consent. Absent = memory only. */
+  storage?: StorageBackend | undefined;
+  /** Clock. Defaults to `Date.now`; the browser package corrects for server skew. */
+  now?: (() => number) | undefined | undefined;
+  /** Id generator. Defaults to monotonic UUIDv7. */
+  createId?: (() => string) | undefined | undefined;
+  /** `fetch` implementation. Defaults to `globalThis.fetch`. */
+  fetch?: FetchLike | undefined;
+  /**
+   * Subscribe to "the process is about to go away" signals (pagehide,
+   * visibilitychange, SIGTERM). The engine flushes on each signal. Returns
+   * the unsubscribe function.
+   */
+  onFlushSignal?: (flush: () => void) => () => void | undefined | undefined;
+  /**
+   * Last-chance delivery used when a flush signal fires, e.g. `sendBeacon`.
+   * Return `true` if the runtime accepted the payload; `false` falls back to
+   * keepalive fetch.
+   */
+  sendLastChance?: ((url: string, body: string, headers: Record<string, string>) => boolean) | undefined | undefined;
+  /** Defaults for `$pageview` properties. */
+  getPageContext?: (() => PageContext) | undefined | undefined;
+  /**
+   * Mint and persist a fresh device id. Called by `reset()`; without it a
+   * reset keeps the old device, which is wrong on a shared machine.
+   */
+  regenerateDeviceId?: (() => string) | undefined | undefined;
+}
+interface ReoptCoreConfig {
+  auth: ReoptAuth;
+  /** Origin of the reopt-data deployment, or a same-origin proxy prefix like `/ingest`. */
+  baseUrl: string;
+  runtime: ReoptRuntime;
+  debug?: boolean | undefined;
+  batch?: BatchConfig | undefined;
+  /** Upper bound on queued events; the oldest are dropped past it. Default: 10000. */
+  maxQueueSize?: number | undefined;
+  retry?: RetryConfig | undefined;
+  circuitBreaker?: CircuitBreakerConfig | undefined;
+  consent?: ConsentConfig | undefined;
+  /** Prefix for storage keys. Default: `reopt_`. */
+  storagePrefix?: string | undefined;
+  /** Persist the queue through `runtime.storage`. Default: `true` when storage exists. */
+  enableOfflineBuffer?: boolean | undefined;
+  /** Flush on runtime flush signals. Default: `true` when the runtime provides them. */
+  autoFlushOnUnload?: boolean | undefined;
+}
+/**
+ * Identity a single event was recorded under, when it differs from the
+ * runtime's. The server SDK uses this to file events from many requests
+ * through one engine: each request's device travels with its events and
+ * becomes that batch's `reopt-device-id`.
+ */
+interface EventIdentity {
+  deviceId?: string | undefined;
+  sessionId?: string | null | undefined;
+}
+interface TrackEventOptions {
+  /** File this event under another visitor than the runtime's. Server SDK use. */
+  identity?: EventIdentity | undefined;
+  name: string;
+  properties?: Record<string, unknown> | undefined;
+  profileId?: string | number | undefined;
+  /** Consent category this event belongs to. Default: `analytics`. */
+  consentCategory?: ConsentCategory | undefined;
+}
+interface IdentifyOptions {
+  /** File this event under another visitor than the runtime's. Server SDK use. */
+  identity?: EventIdentity | undefined;
+  profileId: string | number;
+  firstName?: string | undefined;
+  lastName?: string | undefined;
+  email?: string | undefined;
+  avatar?: string | undefined;
+  properties?: Record<string, unknown> | undefined;
+  consentCategory?: ConsentCategory | undefined;
+}
+interface IncrementOptions {
+  /** File this event under another visitor than the runtime's. Server SDK use. */
+  identity?: EventIdentity | undefined;
+  profileId: string | number;
+  property: string;
+  value?: number | undefined;
+  consentCategory?: ConsentCategory | undefined;
+}
+interface DecrementOptions {
+  /** File this event under another visitor than the runtime's. Server SDK use. */
+  identity?: EventIdentity | undefined;
+  profileId: string | number;
+  property: string;
+  value?: number | undefined;
+  consentCategory?: ConsentCategory | undefined;
+}
+interface UTMParams {
+  utm_source?: string | undefined;
+  utm_medium?: string | undefined;
+  utm_campaign?: string | undefined;
+  utm_term?: string | undefined;
+  utm_content?: string | undefined;
+}
+interface PageViewOptions {
+  /** File this event under another visitor than the runtime's. Server SDK use. */
+  identity?: EventIdentity | undefined;
+  path?: string | undefined;
+  /** Scheme + host. */
+  origin?: string | undefined;
+  title?: string | undefined;
+  referrer?: string | undefined;
+  properties?: Record<string, unknown> | undefined;
+  utm?: UTMParams | undefined;
+  consentCategory?: ConsentCategory | undefined;
+}
+type EventPayload = {
+  type: "track";
+  eventId: string;
+  timestamp: number;
+  payload: {
+    name: string;
+    properties?: Record<string, unknown> | undefined;
+    profileId?: string | number | undefined;
+  };
+} | {
+  type: "identify";
+  eventId: string;
+  timestamp: number;
+  payload: {
+    profileId: string | number;
+    firstName?: string | undefined;
+    lastName?: string | undefined;
+    email?: string | undefined;
+    avatar?: string | undefined;
+    properties?: Record<string, unknown> | undefined;
+  };
+} | {
+  type: "increment";
+  eventId: string;
+  timestamp: number;
+  payload: {
+    profileId: string | number;
+    property: string;
+    value?: number;
+  };
+} | {
+  type: "decrement";
+  eventId: string;
+  timestamp: number;
+  payload: {
+    profileId: string | number;
+    property: string;
+    value?: number;
+  };
+};
+type QueueDropReason = "tracking_paused" | "consent_denied" | "validation_failed" | "payload_too_large";
+interface QueueResult {
+  eventId: string;
+  queued: boolean;
+  reason?: QueueDropReason | undefined;
+  errors?: Array<{
+    field: string;
+    message: string;
+  }> | undefined;
+}
+interface FlushResult {
+  status: "idle" | "success" | "failed" | "skipped";
+  sent: number;
+  failed: number;
+  pending: number;
+}
+interface FlushOptions {
+  /** Ask the transport to outlive the page (keepalive fetch / beacon). */
+  keepalive?: boolean | undefined;
+  /** Keep sending until the queue is empty or no progress is made. */
+  drain?: boolean | undefined;
+}
+//#endregion
+//#region ../data-sdk-core/src/consent.d.ts
+type ConsentState = Record<string, boolean>;
+//#endregion
+//#region ../data-sdk-core/src/transport.d.ts
+interface BatchDelivery {
+  sent: number;
+  failed: number;
+  /** The signed session credential ingest returned, when it did. */
+  session?: {
+    id: string;
+    token: string;
+  } | undefined;
+}
+interface SendOptions {
+  keepalive?: boolean | undefined;
+  /** Overrides the runtime's device/session for this request only. */
+  identity?: EventIdentity | undefined;
+}
+interface Transport {
+  readonly url: string;
+  headers(identity?: EventIdentity): Record<string, string>;
+  send(batch: EventPayload[], options?: SendOptions): Promise<BatchDelivery>;
+}
+//#endregion
+//#region ../data-sdk-core/src/client.d.ts
+/**
+ * The engine: queue → batch → transport, with retry, a circuit breaker and
+ * consent gates. Everything that differs between browser and server comes in
+ * through {@link ReoptRuntime}; the engine itself never touches `window`,
+ * `document`, `process` or a Node built-in.
+ */
+declare class ReoptCore {
+  protected readonly runtime: ReoptRuntime;
+  protected readonly transport: Transport;
+  private readonly queue;
+  private readonly consent;
+  private readonly breaker;
+  private readonly retry;
+  private readonly batch;
+  private readonly factory;
+  private readonly debug;
+  private deviceId;
+  private profileId;
+  private globalProperties;
+  private activeFlush;
+  private flushTimeout;
+  private removeFlushSignal;
+  private closed;
+  /** Bumped by `reset()`; a batch from an older generation is never requeued. */
+  private generation;
+  private lastFlushRequeued;
+  constructor(config: ReoptCoreConfig);
+  protected log(...args: unknown[]): void;
+  getDeviceId(): string;
+  /** Swap the device id, e.g. after a server bootstrap or a `reset()`. */
+  setDeviceId(deviceId: string): void;
+  setProfileId(profileId: string | number | null): void;
+  getProfileId(): string | number | null;
+  setConsent(category: ConsentCategory, allowed: boolean): void;
+  getConsent(category: ConsentCategory): boolean;
+  setAllConsent(allowed: boolean): void;
+  getConsentState(): ConsentState;
+  replaceConsentState(state: ConsentState): void;
+  pauseTracking(): void;
+  resumeTracking(): void;
+  /**
+   * Properties attached to every `track` event (and so every automatic
+   * event) from now on. An event's own properties win on conflict. This is
+   * how a host adds its breakdown axis — a `page_id`, a tenant — to
+   * `$web_vitals` and `$pageleave`, which the SDK otherwise stamps with
+   * only a path.
+   */
+  register(properties: Record<string, unknown>): void;
+  unregister(...keys: string[]): void;
+  getGlobalProperties(): Record<string, unknown>;
+  /**
+   * `options.identity` files the event under another visitor than the
+   * runtime's — the server SDK's way of serving many requests from one
+   * engine. Such an event never reads or writes the engine's own profile:
+   * that belongs to the runtime's visitor, not the request's.
+   */
+  track(options: TrackEventOptions): QueueResult;
+  identify(options: IdentifyOptions): QueueResult;
+  increment(options: IncrementOptions): QueueResult;
+  decrement(options: DecrementOptions): QueueResult;
+  pageView(options?: PageViewOptions): QueueResult;
+  screenView(screenName: string, properties?: Record<string, unknown>, identity?: EventIdentity): QueueResult;
+  get pending(): number;
+  private enqueue;
+  private scheduleFlush;
+  private clearScheduledFlush;
+  flush(options?: FlushOptions): Promise<FlushResult>;
+  /**
+   * The page (or process) is going away. Persist first so nothing is lost if
+   * the request never completes, then send what can be sent with keepalive.
+   */
+  private flushOnSignal;
+  /**
+   * The identity a batch is sent under, fixed when it leaves the queue. A
+   * `reset()` during a retry must not re-address the previous visitor's
+   * events to the new device.
+   */
+  private identityFor;
+  private flushExclusive;
+  private flushAll;
+  private flushOnce;
+  private continueOrSettle;
+  /**
+   * Forget who this is: profile, queued events and — when the runtime can
+   * mint one — the device id. A shared computer that logs out must not keep
+   * attributing the next person to the previous one.
+   */
+  reset(): void;
+  close(): Promise<FlushResult>;
+}
+//#endregion
+//#region src/steps.d.ts
+type ExceptionStepInput = {
+  category: ExceptionStep["category"];
+  message: string;
+  data?: Record<string, unknown> | undefined;
+};
+//#endregion
+//#region src/capture/web-vitals.d.ts
+/**
+ * The shape `next/web-vitals`' `useReportWebVitals` and the `web-vitals`
+ * package both produce. Declared here so the vanilla entry does not have to
+ * import either.
+ */
+interface WebVitalMetric {
+  id: string;
+  name: string;
+  value: number;
+  delta?: number | undefined;
+  rating?: "good" | "needs-improvement" | "poor" | undefined;
+  navigationType?: string | undefined;
+}
+type WebVitalProperties = {
+  metric_name: string;
+  metric_id: string;
+  value: number;
+  delta?: number | undefined;
+  rating?: string | undefined;
+  navigation_type?: string | undefined;
+  path: string;
+};
+//#endregion
+//#region src/config.d.ts
+type ReoptObservedEventType = "track" | "identify" | "increment" | "decrement";
+/**
+ * Observation-only lifecycle facts for local tooling. The callback is never
+ * part of delivery: throwing from it is ignored and cannot block the SDK.
+ */
+type ReoptClientObservation = {
+  type: "config";
+  at: number;
+  disabled: boolean;
+  baseUrl: string;
+  writeKeyPresent: boolean;
+  debug: boolean;
+  capture: ResolvedCaptureConfig;
+  consentPersisted: boolean;
+  batchIntervalMs: number;
+} | {
+  type: "event";
+  at: number;
+  phase: "queued" | "dropped";
+  eventId: string;
+  eventType: ReoptObservedEventType;
+  name: string;
+  pending: number;
+  reason?: string | undefined;
+  errors?: Array<{
+    field: string;
+    message: string;
+  }> | undefined;
+} | {
+  type: "identity";
+  at: number;
+  action: "initialized" | "identified" | "profile_changed" | "reset";
+  deviceId: string;
+  profileId: string | number | null;
+  storage: IdentityStorageKind;
+} | {
+  type: "consent";
+  at: number;
+  category: ConsentCategory | "all";
+  allowed: boolean;
+} | {
+  type: "tracking";
+  at: number;
+  paused: boolean;
+};
+type ReoptClientObserver = (observation: ReoptClientObservation) => void;
+/**
+ * Rewrites a pathname before it is attached to an event, and may lift the
+ * parts it removed into properties so they stay available for breakdowns:
+ * `/workspace/8f3…/crm/customers/2a1…` → `{ path: "/workspace/:id/crm/customers/:id",
+ * properties: { workspace_id: "8f3…" } }`.
+ *
+ * Applied wherever the SDK fills in a path itself — the default `$pageview`
+ * path, `$pageleave`, `$web_vitals`, `$exception`. A `path` you pass to
+ * `pageView()` explicitly is used as-is, so run the same function on it
+ * yourself; two different rules would give one visit two different paths.
+ * Must be synchronous and pure. If it throws, the raw pathname is used.
+ */
+type NormalizePath = (pathname: string) => string | {
+  path: string;
+  properties?: Record<string, unknown>;
+};
+type IdentityStorageKind = "auto" | "cookie" | "localStorage" | "memory";
+interface IdentityConfig {
+  /**
+   * Where the device id lives. `auto` (default) prefers a cookie: Safari
+   * expires script-written `localStorage` after seven days of inactivity,
+   * which turns every returning visitor into a new device. A cookie the
+   * server also reads survives that, and lets server-side events join the
+   * same device.
+   */
+  storage?: IdentityStorageKind | undefined;
+  /** Cookie `Domain`; omit for host-only. Set to share across subdomains. */
+  cookieDomain?: string | undefined;
+  /** Cookie lifetime. Default 400 days (the longest Chrome honours). */
+  cookieMaxAgeSeconds?: number | undefined;
+}
+interface CaptureConfig {
+  /**
+   * Send `$pageview` on `init()`. Default `true` for the vanilla entry.
+   * The Next entry sets it to `false` because `<ReoptPageView />` owns page
+   * views there — including the first one.
+   */
+  pageview?: boolean | undefined;
+  /** Send `$pageleave` with time-on-page when the page is hidden or the route changes. Default `true`. */
+  pageleave?: boolean | undefined;
+  /** Attach max scroll depth to `$pageleave`. Default `true`. */
+  scrollDepth?: boolean | undefined;
+  /** Send `$exception` for uncaught errors and unhandled rejections. Default `false`. */
+  exceptions?: boolean | undefined;
+  /**
+   * Throttle automatic exception capture, per exception type. Default on
+   * (10 events, one token back every 10s). `false` reports everything — only
+   * useful when you are deliberately measuring an error storm.
+   *
+   * Never applies to `captureException()`: a report you asked for explicitly is
+   * not noise the SDK gets to drop.
+   */
+  exceptionRateLimit?: {
+    bucketSize?: number;
+    refillSeconds?: number;
+  } | false | undefined;
+  /**
+   * Record breadcrumbs (`$exception_steps`) leading up to an exception.
+   * Default `false` — it puts navigation history on every error, which is a
+   * privacy decision the host makes, not the SDK.
+   */
+  exceptionSteps?: boolean | undefined;
+}
+interface ReoptClientConfig {
+  writeKey: string;
+  /** reopt-data origin, or the same-origin proxy prefix (e.g. `/ingest`) the Next.js proxy rewrites. */
+  baseUrl: string;
+  /** What the server already knows about this visitor. `null` = nothing. */
+  bootstrap?: ReoptBootstrap | null | undefined;
+  identity?: IdentityConfig | undefined;
+  capture?: CaptureConfig | undefined;
+  /**
+   * Hosts that receive the `reopt-device-id` header on outgoing `fetch`/XHR,
+   * so a server-side `track()` lands on the same device. `true` = the page's
+   * own hostname. **Default: off** — the trusted path is passing
+   * `getDeviceId()` to your server call explicitly; this patches `fetch`
+   * and loads as a separate chunk only when enabled.
+   */
+  tracingHeaders?: boolean | string[] | undefined;
+  /** See {@link NormalizePath}. */
+  normalizePath?: NormalizePath | undefined;
+  /**
+   * Properties attached to every event from the very first one. Same as
+   * calling `register()` right after `init()`, except that nothing can
+   * slip out in between: web vitals arrive from a buffered
+   * `PerformanceObserver` and can fire the instant the client exists.
+   * Pass the page context the server already knows here; update it on
+   * client-side navigation with `register()`.
+   */
+  properties?: Record<string, unknown> | undefined;
+  /**
+   * The build this page is running, sent on every event as `$release_id`.
+   *
+   * What lets error tracking say an issue first appeared in 1.4.0, and whether
+   * the fix shipped in 1.4.1 held. A string the host chooses — a version, a
+   * commit sha, a build id — not something the server issues, and an unknown
+   * one is never rejected.
+   *
+   * Falls back to `globalThis.__REOPT_RELEASE__`, which is where a build step
+   * writes the version the app's own config cannot know:
+   *
+   * ```js
+   * // vite.config.js / next.config.js
+   * define: { __REOPT_RELEASE__: JSON.stringify(process.env.GIT_SHA) }
+   * ```
+   *
+   * Sugar over `properties: { $release_id }`, which still works and costs
+   * nothing — the option exists because threading a build constant through a
+   * properties bag is the part hosts get wrong.
+   */
+  release?: string | undefined;
+  consent?: ConsentConfig | undefined;
+  batch?: BatchConfig | undefined;
+  retry?: RetryConfig | undefined;
+  circuitBreaker?: CircuitBreakerConfig | undefined;
+  /** Upper bound on queued events. Default 10 000. */
+  maxQueueSize?: number | undefined;
+  /** Overrides the store for the offline queue. Default `localStorage`. */
+  queueStorage?: StorageBackend | undefined;
+  /** Prefix for storage keys. Default `reopt_`. */
+  storagePrefix?: string | undefined;
+  /**
+   * Transport override. Tests hand in a recording function so a Playwright
+   * spec can assert on the exact payload the SDK built, without intercepting
+   * the network. Defaults to the page's `fetch` (captured at init, before the
+   * tracing patch, so the SDK's own requests are never tagged twice).
+   */
+  fetch?: FetchLike | undefined;
+  /**
+   * Observation-only lifecycle hook for devtools. It receives no credentials
+   * and is ignored when it throws. Facts are buffered in order while the
+   * opt-in observer chunk loads; delivery never depends on this callback.
+   */
+  observe?: ReoptClientObserver | undefined;
+  debug?: boolean | undefined;
+}
+interface ResolvedCaptureConfig {
+  pageview: boolean;
+  pageleave: boolean;
+  scrollDepth: boolean;
+  exceptions: boolean;
+  /**
+   * `false` disables throttling; otherwise the host's overrides, if any.
+   *
+   * Deliberately not defaulted here: the defaults live beside the limiter in
+   * the lazily-loaded exception chunk, so the main bundle carries the option
+   * but not the numbers.
+   */
+  exceptionRateLimit: {
+    bucketSize?: number;
+    refillSeconds?: number;
+  } | false;
+  exceptionSteps: boolean;
+}
+//#endregion
+//#region src/identity/device.d.ts
+interface IdentityStore {
+  readonly kind: Exclude<IdentityStorageKind, "auto">;
+  readDevice(): DeviceCookieState | null;
+  writeDevice(state: DeviceCookieState): void;
+  clearDevice(): void;
+  readConsent(): ConsentCookieState | null;
+  writeConsent(state: ConsentCookieState): void;
+  /** Engine-facing backend for the consent key, so consent decisions land in the same place. */
+  consentBackend(): StorageBackend;
+}
+//#endregion
+//#region src/client.d.ts
+interface ReoptClientDefaults {
+  /** Whether `init()` sends the first `$pageview`. The Next entry says no. */
+  pageview: boolean;
+}
+/**
+ * The browser client: the shared engine plus everything that only makes
+ * sense in a document — cookie identity, tracing headers, page leave,
+ * scroll depth, exception capture, and a clock corrected against the
+ * server's.
+ */
+/**
+ * What to attach to a manual `captureException`.
+ *
+ * The second argument used to be a bare properties bag. That shape is still
+ * accepted, so no existing call site has to change — see
+ * {@link readCaptureExceptionOptions} for how the two are told apart.
+ */
+interface CaptureExceptionOptions {
+  /** Group this error yourself instead of letting the server fingerprint it. */
+  fingerprint?: string | undefined;
+  level?: ExceptionLevel | undefined;
+  properties?: Record<string, unknown> | undefined;
+}
+declare class ReoptClient extends ReoptCore {
+  readonly writeKey: string;
+  readonly capture: ResolvedCaptureConfig;
+  private readonly store;
+  private readonly pageLeave;
+  private readonly scroll;
+  private readonly uninstallers;
+  private torndown;
+  /** The lazily-loaded exception chunk, once it has resolved. */
+  private exceptionChunk;
+  private exceptionChunkPromise;
+  private readonly session;
+  private readonly optedOut;
+  private readonly normalize;
+  private readonly observer;
+  /** True when `writeKey` or `baseUrl` was missing: every call is a silent no-op. */
+  readonly disabled: boolean;
+  constructor(config: ReoptClientConfig, defaults?: ReoptClientDefaults);
+  /** Which store identity ended up in — `cookie`, `localStorage` or `memory`. */
+  get identityStorage(): IdentityStore["kind"];
+  private observe;
+  private observeIdentity;
+  private observeEvent;
+  track(options: TrackEventOptions): QueueResult;
+  pageView(options?: PageViewOptions): QueueResult;
+  setConsent(category: ConsentCategory, allowed: boolean): void;
+  setAllConsent(allowed: boolean): void;
+  replaceConsentState(state: Record<string, boolean>): void;
+  pauseTracking(): void;
+  resumeTracking(): void;
+  setProfileId(profileId: string | number | null): void;
+  /**
+   * Refusing `analytics` removes the stored identity (the proxy does the
+   * same on its side); granting it again writes the current device through
+   * so the visit is attributable from that point on.
+   */
+  private syncOptOut;
+  identify(options: IdentifyOptions): QueueResult;
+  increment(options: IncrementOptions): QueueResult;
+  decrement(options: DecrementOptions): QueueResult;
+  /** Feed a Web Vitals metric (from `next/web-vitals` or the `web-vitals` package). */
+  captureWebVital(metric: WebVitalMetric): QueueResult;
+  /** The page's path through `normalizePath`, for events the SDK stamps itself. */
+  private currentPath;
+  /**
+   * Report an error you caught yourself.
+   *
+   * The stack parsers live in a lazily-loaded chunk — they are several times
+   * the size budget's remaining headroom, and a page that never throws should
+   * not pay for them. So the first call before that chunk resolves reports the
+   * flat keys only (name, message, raw stack) and starts the load; every call
+   * after it carries the structured `$exception_list` too. The server groups
+   * both: without a list it falls back to V1 fingerprinting on the flat keys.
+   */
+  captureException(error: unknown, optionsOrProperties?: CaptureExceptionOptions | Record<string, unknown>): QueueResult;
+  /**
+   * Record a breadcrumb for the next exception.
+   *
+   * Always available, whether or not automatic steps are on: a host that wants
+   * to leave its own trail should not have to opt into the SDK leaving one too.
+   */
+  addExceptionStep(step: ExceptionStepInput): void;
+  /** Loads the exception chunk once and remembers it, so manual captures can use the parsers. */
+  private loadExceptionChunk;
+  private trackException;
+  private emitPageLeave;
+  /**
+   * Log out: forget the profile and the queue, and become a new device.
+   * On a shared computer the next person must not inherit this one's
+   * history.
+   */
+  reset(): void;
+  close(): Promise<FlushResult>;
+}
+//#endregion
+export { QueueDropReason as A, FetchInit as C, IdentifyOptions as D, FlushResult as E, UTMParams as F, RetryConfig as M, StorageBackend as N, IncrementOptions as O, TrackEventOptions as P, EventPayload as S, FetchResponseLike as T, CircuitBreakerConfig as _, IdentityConfig as a, DecrementOptions as b, ReoptBootstrap as c, ReoptClientObserver as d, ReoptObservedEventType as f, BatchConfig as g, ExceptionStepInput as h, CaptureConfig as i, QueueResult as j, PageViewOptions as k, ReoptClientConfig as l, WebVitalProperties as m, ReoptClient as n, IdentityStorageKind as o, WebVitalMetric as p, ReoptClientDefaults as r, NormalizePath as s, CaptureExceptionOptions as t, ReoptClientObservation as u, ConsentCategory as v, FetchLike as w, EventIdentity as x, ConsentConfig as y };
+//# sourceMappingURL=client-BCrui21p.d.cts.map