@liiift-studio/sanity-visitor-insights 0.1.0

package/dist/ranges-D6AZwpmm.d.ts

@@ -0,0 +1,282 @@
+/** Shared contract types for the Studio plugin and the API-route handler it calls. */
+/**
+ * Why a metric has no usable number. Kept distinct rather than collapsed into one flag, because
+ * the UI must say different things: "this site never tracked it" is permanent, "not yet at this
+ * date" resolves as time passes, and "GA4 withheld it" means the number exists but is hidden.
+ */
+type UnavailableReason = 
+/** The event has never been instrumented on this site. Permanent for historical ranges. */
+'not_instrumented'
+/** Instrumented, but the requested range predates the cutover date. */
+ | 'before_cutover'
+/** GA4 suppressed the row for privacy thresholding. A real number exists; we may not see it. */
+ | 'suppressed'
+/** The upstream source errored or timed out. Retryable, unlike the others. */
+ | 'source_error'
+/** The metric is not defined for this site at all (e.g. a flow that does not exist there). */
+ | 'not_applicable';
+/**
+ * A metric that may legitimately have no value.
+ *
+ * The whole point of this union is that there is no way to read a number without first handling
+ * the absent case — a missing metric can never silently coerce to 0 and be charted as a real
+ * trough. `partial` carries a number that is only valid for part of the requested range.
+ */
+type MetricValue = {
+    status: 'ok';
+    value: number;
+} | {
+    status: 'partial';
+    value: number;
+    coveredFrom: string;
+    note: string;
+} | {
+    status: 'unavailable';
+    reason: UnavailableReason;
+    detail?: string;
+};
+/** Construct an available metric. */
+declare function ok(value: number): MetricValue;
+/** Construct an unavailable metric. */
+declare function unavailable(reason: UnavailableReason, detail?: string): MetricValue;
+/**
+ * Construct a metric covering only part of the requested range.
+ *
+ * @param value - the number for the covered portion
+ * @param coveredFrom - ISO date from which the number is valid
+ * @param note - short human-readable reason, shown next to the figure
+ */
+declare function partial(value: number, coveredFrom: string, note: string): MetricValue;
+/**
+ * Read a metric's number, or `null` when there isn't a usable one.
+ * Use at render time so the absent case has to be handled explicitly.
+ */
+declare function valueOrNull(metric: MetricValue): number | null;
+/** The range granularities offered in the UI. */
+type RangeKey = 'week' | 'quarter' | 'year';
+/**
+ * A resolved date range. Both bounds are inclusive ISO `YYYY-MM-DD` dates in `timezone`.
+ *
+ * `timezone` is carried explicitly because GA4 buckets by the property's configured timezone,
+ * Vercel reports in UTC, and Sanity `_createdAt` is UTC — comparing them without a single declared
+ * anchor silently shifts events across day and week boundaries.
+ */
+interface DateRange {
+    key: RangeKey;
+    start: string;
+    end: string;
+    timezone: string;
+}
+/** The report names this package serves. Used as a strict allow-list, never as dynamic dispatch. */
+declare const REPORT_NAMES: readonly ["measurement-health", "acquisition", "journey", "typeface-interest"];
+type ReportName = (typeof REPORT_NAMES)[number];
+/** Narrow an untrusted string to a known report name. */
+declare function isReportName(value: unknown): value is ReportName;
+/** Which upstreams a report consulted, and how each fared. */
+type SourceStatus = {
+    status: 'ok';
+} | {
+    status: 'unconfigured';
+} | {
+    status: 'error';
+    message: string;
+};
+/** Upstream data sources this package can read. */
+type SourceName = 'ga4' | 'vercel' | 'sanity';
+/**
+ * Envelope around every report response.
+ *
+ * `sources` is mandatory rather than optional because partial failure is the normal case here,
+ * not the exception: a panel comparing three sources must be able to distinguish "this source
+ * reported zero" from "this source never answered", which a bare payload cannot express.
+ */
+interface ReportEnvelope<T> {
+    report: ReportName;
+    range: DateRange;
+    /** Per-source outcome. A report may succeed overall while one source is unconfigured. */
+    sources: Partial<Record<SourceName, SourceStatus>>;
+    /** Caveats to surface in the UI, e.g. GA4 sampling or an instrumentation cutover in range. */
+    notices: string[];
+    data: T;
+}
+/** Error shape returned by the handler. Never leaks upstream error text to the browser. */
+interface ReportError {
+    error: string;
+    report?: string;
+}
+
+/**
+ * Event instrumentation cutovers.
+ *
+ * GA4 cannot backfill events: data from before an event was instrumented does not exist and never
+ * will. A range spanning a cutover therefore mixes two measurement regimes, and a chart drawn
+ * across it reads as a change in visitor behaviour when it is really a change in what was counted.
+ *
+ * This lives in the package rather than in each site repo so all three foundries share one model
+ * and one set of semantics, and so the Studio panel and the server handler agree by construction.
+ */
+
+/** An event that predates this work — long-running, with no discontinuity to mark. */
+declare const PREEXISTING: "preexisting";
+/**
+ * When an event began firing on a site.
+ * `PREEXISTING` = live before this work began. `null` = planned, not yet deployed.
+ * An ISO `YYYY-MM-DD` string = the deploy date, set in the commit that ships the event.
+ */
+type EventCutover = typeof PREEXISTING | string | null;
+/** How completely an event covers a requested range. */
+type Coverage = {
+    status: 'full';
+} | {
+    status: 'partial';
+    cutover: string;
+} | {
+    status: 'none';
+    reason: 'not_instrumented' | 'before_cutover' | 'unknown_event';
+    cutover?: string;
+};
+/**
+ * Determine how well an event covers a date range.
+ *
+ * @param cutovers - the site's event cutover map
+ * @param eventName - GA4 event name to look up
+ * @param range - the requested range
+ */
+declare function coverageForRange(cutovers: Readonly<Record<string, EventCutover>>, eventName: string, range: Pick<DateRange, 'start' | 'end'>): Coverage;
+/**
+ * Wrap a raw count in a MetricValue that reflects the event's coverage of the range.
+ *
+ * Call this instead of returning a bare number, so a value that only covers part of the range
+ * carries that fact with it all the way to the renderer.
+ *
+ * @param count - the number GA4 returned, or null if the query could not run
+ * @param coverage - result of coverageForRange for the same event and range
+ */
+declare function applyCoverage(count: number | null, coverage: Coverage): MetricValue;
+/**
+ * Human-readable notices for every event in a range that is not fully covered.
+ * Surfaced in the report envelope so the panel can show caveats without recomputing them.
+ */
+declare function coverageNotices(cutovers: Readonly<Record<string, EventCutover>>, eventNames: readonly string[], range: Pick<DateRange, 'start' | 'end'>): string[];
+
+/**
+ * Per-site adapter configuration.
+ *
+ * The three foundries differ in ways that cannot be abstracted away: different GA4 event coverage,
+ * different order schemas, different flows that exist on one site and not another. Rather than
+ * branching on a site id inside the reports — which would mean editing this package to onboard a
+ * fourth foundry — each site describes itself through this config and the reports stay generic.
+ */
+
+/** GA4 connection for one site. */
+interface Ga4Config {
+    /** Numeric GA4 property id. NOT the `G-XXXXXXX` measurement id, which is the client-side one. */
+    propertyId: string;
+    /** IANA timezone the property is configured with. Every range is anchored to this. */
+    timezone: string;
+}
+/** Vercel Web Analytics connection for one site. */
+interface VercelConfig {
+    projectId: string;
+    teamId?: string;
+}
+/** Where to count orders, and what they are called on this site. */
+interface OrdersConfig {
+    /** Document type holding orders. */
+    documentType: string;
+    /**
+     * Field holding the typeface references on an order, if the site has one.
+     * Null where orders do not resolve to typefaces in a usable way.
+     */
+    typefacesField: string | null;
+    /**
+     * GROQ filter appended to exclude non-typeface orders, e.g. merch-only orders on Darden.
+     * Merch inflates a family's apparent purchase count if not excluded.
+     */
+    excludeFilter?: string;
+}
+/** One site's complete description of itself. */
+interface SiteAnalyticsConfig {
+    /** Stable machine id, e.g. `darden`. */
+    siteId: string;
+    /** Human label shown in the Studio UI. */
+    label: string;
+    /** Null when GA4 is not wired up for this site — reports degrade rather than fail. */
+    ga4: Ga4Config | null;
+    /** Null when Vercel Web Analytics is unavailable, e.g. on a plan tier without API access. */
+    vercel: VercelConfig | null;
+    orders: OrdersConfig;
+    /**
+     * When each GA4 event began firing here. Events absent from this map report as `unknown_event`,
+     * which is the honest answer for a flow the site does not have — distinct from `not_instrumented`,
+     * which implies it is merely pending.
+     */
+    eventCutovers: Record<string, EventCutover>;
+    /** Origins allowed to call this site's handler cross-origin, e.g. a separately deployed Studio. */
+    allowedStudioOrigins?: string[];
+}
+/** A problem found while validating a site config. */
+interface ConfigProblem {
+    field: string;
+    message: string;
+}
+/**
+ * Validate a site config at runtime.
+ *
+ * Compile-time types do not survive into a consuming site's `sanity.config.js`, which is plain
+ * JavaScript — so a typo'd property id or a measurement id pasted where a numeric property id
+ * belongs would otherwise surface as an empty chart rather than an error.
+ *
+ * @param config - the candidate config
+ * @returns the problems found; an empty array means the config is usable
+ */
+declare function validateSiteConfig(config: Partial<SiteAnalyticsConfig> | undefined): ConfigProblem[];
+/** Whether a string is an IANA timezone this runtime recognises. */
+declare function isValidTimeZone(timeZone: string): boolean;
+/** Throw if a config is unusable, naming every problem at once rather than one per run. */
+declare function assertValidSiteConfig(config: Partial<SiteAnalyticsConfig> | undefined): asserts config is SiteAnalyticsConfig;
+
+/**
+ * Date-range resolution.
+ *
+ * Every range is resolved against one declared timezone — the GA4 property's — because the three
+ * sources bucket time differently: GA4 by the property timezone, Vercel by UTC, Sanity `_createdAt`
+ * by UTC. Without a single anchor, an order placed near midnight lands in different weeks depending
+ * on which source you ask, which corrupts exactly the cross-source comparison this tool exists for.
+ */
+
+/** GA4 does not finalise the most recent days. Figures inside this window may still rise. */
+declare const GA4_PROCESSING_LAG_DAYS = 2;
+/** Format a Date as `YYYY-MM-DD` in the given IANA timezone. */
+declare function formatInTimeZone(date: Date, timeZone: string): string;
+/** Shift an ISO `YYYY-MM-DD` date by a whole number of days. */
+declare function shiftDays(isoDate: string, days: number): string;
+/** Inclusive whole days between two ISO dates. */
+declare function daysBetween(start: string, end: string): number;
+/**
+ * Resolve a range key into concrete dates, anchored to `timezone` and ending today.
+ *
+ * @param key - week, quarter or year
+ * @param timezone - IANA timezone of the GA4 property this range will be queried against
+ * @param now - injectable clock, so tests are deterministic
+ */
+declare function resolveRange(key: RangeKey, timezone: string, now?: Date): DateRange;
+/**
+ * The equivalent range immediately before `range`, for period-over-period comparison.
+ *
+ * A bare count answers "how many", which on its own is not actionable; the comparison is what
+ * tells someone whether to do anything.
+ */
+declare function previousRange(range: DateRange): DateRange;
+/**
+ * The trailing dates within a range whose GA4 figures are not yet settled.
+ * Returns an empty array when the range ends before the lag window.
+ */
+declare function provisionalDates(range: DateRange, now?: Date): string[];
+/**
+ * Notice text when a range includes days GA4 has not finished processing, or `null` when it does not.
+ * Without this a Monday-morning glance at "this week" reads the trailing dip as a real drop.
+ */
+declare function provisionalNotice(range: DateRange, now?: Date): string | null;
+
+export { type Coverage as C, type DateRange as D, type EventCutover as E, GA4_PROCESSING_LAG_DAYS as G, type MetricValue as M, type OrdersConfig as O, PREEXISTING as P, type ReportEnvelope as R, type SiteAnalyticsConfig as S, type UnavailableReason as U, type VercelConfig as V, type ReportName as a, type RangeKey as b, REPORT_NAMES as c, type ReportError as d, type SourceName as e, type SourceStatus as f, coverageForRange as g, previousRange as h, isReportName as i, valueOrNull as j, type ConfigProblem as k, type Ga4Config as l, applyCoverage as m, assertValidSiteConfig as n, ok as o, partial as p, coverageNotices as q, resolveRange as r, daysBetween as s, formatInTimeZone as t, unavailable as u, validateSiteConfig as v, isValidTimeZone as w, provisionalDates as x, provisionalNotice as y, shiftDays as z };

package/dist/server.d.mts

@@ -0,0 +1,280 @@
+import { S as SiteAnalyticsConfig, M as MetricValue } from './ranges-D6AZwpmm.mjs';
+export { k as ConfigProblem, C as Coverage, D as DateRange, E as EventCutover, G as GA4_PROCESSING_LAG_DAYS, l as Ga4Config, O as OrdersConfig, P as PREEXISTING, c as REPORT_NAMES, b as RangeKey, R as ReportEnvelope, d as ReportError, a as ReportName, e as SourceName, f as SourceStatus, U as UnavailableReason, V as VercelConfig, m as applyCoverage, n as assertValidSiteConfig, g as coverageForRange, q as coverageNotices, s as daysBetween, t as formatInTimeZone, i as isReportName, w as isValidTimeZone, o as ok, p as partial, h as previousRange, x as provisionalDates, y as provisionalNotice, r as resolveRange, z as shiftDays, u as unavailable, v as validateSiteConfig, j as valueOrNull } from './ranges-D6AZwpmm.mjs';
+
+/**
+ * Request authentication and CORS for the report handler.
+ *
+ * The Studio forwards its own Sanity session token and this verifies it against Sanity. A shared
+ * secret was the obvious alternative and is the wrong one: the Studio bundle is served publicly, so
+ * any secret compiled into it is extractable, which moves the bar from "know the URL" to "open
+ * devtools". Verifying a session token instead proves the caller is a logged-in project user, and
+ * gives a real identity to log rather than an anonymous caller who read a constant.
+ *
+ * This mirrors the pattern already in production on Darden's order-action endpoints.
+ */
+/** Minimal shape this module needs from a Next.js API request. */
+interface HandlerRequest {
+    method?: string;
+    url?: string;
+    headers: Record<string, string | string[] | undefined>;
+    query?: Record<string, string | string[] | undefined>;
+}
+/** Minimal shape this module needs from a Next.js API response. */
+interface HandlerResponse {
+    setHeader(name: string, value: string): void;
+    status(code: number): HandlerResponse;
+    json(body: unknown): void;
+    end(): void;
+}
+/** A verified Sanity Studio user. */
+interface StudioUser {
+    id: string;
+    name?: string;
+    email?: string;
+    roles?: Array<{
+        name: string;
+    }>;
+}
+/** Outcome of verifying a request's Studio token. */
+type VerifyResult = {
+    ok: true;
+    user: StudioUser;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Verify that a request carries a valid Sanity user token for this project.
+ *
+ * @param req - the incoming request
+ * @param sanityProjectId - project the token must belong to
+ * @returns ok with the resolved user, or a reason suitable for logging but never for the response
+ */
+declare function verifyStudioRequest(req: HandlerRequest, sanityProjectId: string): Promise<VerifyResult>;
+/**
+ * Apply CORS headers for a Studio-originated request and answer the preflight.
+ *
+ * Echoes one allow-listed origin rather than sending `*`. A wildcard is acceptable for public HTML
+ * but not for an endpoint that takes an Authorization header and returns business data.
+ *
+ * @param req - the incoming request
+ * @param res - the response to decorate
+ * @param allowedOrigins - exact origins permitted to call cross-origin
+ * @returns true when the request was a preflight and is now fully answered
+ */
+declare function applyCors(req: HandlerRequest, res: HandlerResponse, allowedOrigins: readonly string[]): boolean;
+/**
+ * Guard a report endpoint. Responds 401 and returns null when the caller cannot be verified.
+ *
+ * @returns the verified user, or null when the request has already been answered with a 401
+ */
+declare function requireStudioUser(req: HandlerRequest, res: HandlerResponse, sanityProjectId: string): Promise<StudioUser | null>;
+
+/** What this module needs from a Sanity client — kept minimal so it is trivial to stub in tests. */
+interface SanityQueryClient {
+    fetch<T>(query: string, params?: Record<string, unknown>): Promise<T>;
+}
+
+/**
+ * The mountable Next.js API-route handler.
+ *
+ * Ships from this package rather than being copy-pasted into each site so the three foundries
+ * cannot drift apart: a fix applied here reaches all of them on a version bump, instead of being
+ * applied to one repo and forgotten in the other two. A consuming site's route is then:
+ *
+ *   // pages/api/visitor-insights/[report].js
+ *   import { createVisitorInsightsHandler } from '@liiift-studio/sanity-visitor-insights/server'
+ *   export default createVisitorInsightsHandler({ config: mySiteConfig })
+ *
+ * Credentials are read from the environment inside this module and never leave the server.
+ */
+
+/** Environment variables this handler reads. Names are fixed so all three sites match. */
+declare const ENV_VARS: {
+    /** Service-account JSON (raw or base64) with Viewer on the GA4 property. */
+    readonly googleServiceAccount: "VISITOR_INSIGHTS_GA4_SERVICE_ACCOUNT";
+    /** Vercel API token with read access to the project. */
+    readonly vercelToken: "VISITOR_INSIGHTS_VERCEL_TOKEN";
+};
+/** Options for building a handler. */
+interface HandlerOptions {
+    /** This site's description of itself. */
+    config: SiteAnalyticsConfig;
+    /**
+     * Sanity client used for order counts. Supply the site's existing server-side client so this
+     * package does not need its own Sanity credentials.
+     */
+    sanityClient?: SanityQueryClient;
+    /** Sanity project id used to verify Studio tokens. Defaults to `SANITY_STUDIO_PROJECT_ID`. */
+    sanityProjectId?: string;
+    /** Cache lifetime for report responses. */
+    cacheTtlMs?: number;
+}
+/**
+ * Build the API-route handler for a site.
+ *
+ * @param options - the site config and its Sanity client
+ * @returns a Next.js Pages Router API handler
+ */
+declare function createVisitorInsightsHandler(options: HandlerOptions): (req: HandlerRequest, res: HandlerResponse) => Promise<void>;
+
+/** Empty the cache. Test seam, and useful after a config change. */
+declare function clearCache(): void;
+
+/**
+ * Report result shapes, shared by the server that produces them and the panels that render them.
+ *
+ * These live outside both entry points on purpose. If the panels imported them from
+ * `src/server/reports/*` — even as `import type`, which does erase at build time — the module
+ * graph would still contain a client-to-server edge, and the guarantee that credential-reading
+ * code cannot reach a Studio bundle would rest on a compiler detail rather than on structure.
+ */
+
+/** How much of reality each source sees. Pageviews compare like with like; the rest is context. */
+interface MeasurementHealthData {
+    /** GA4 pageviews — directly comparable to `vercelPageviews`. */
+    ga4Pageviews: MetricValue;
+    /** Vercel pageviews — cookieless, not consent-gated. */
+    vercelPageviews: MetricValue;
+    /**
+     * Vercel minus GA4 pageviews, as a share of Vercel. Positive means GA4 saw less.
+     * Null when either side is unavailable — never computed against a missing operand.
+     */
+    shortfallRatio: number | null;
+    /** GA4 sessions. Context only: a session is not a pageview and is never subtracted from one. */
+    ga4Sessions: MetricValue;
+    /** Orders in range. Ground truth for conversions, shown as context. */
+    orders: MetricValue;
+    /** Share of sessions that granted consent, where the event exists. */
+    consentRate: MetricValue;
+    /** Plain-language reading of the numbers above, for a non-analyst audience. */
+    interpretation: string;
+}
+/** One acquisition source. */
+interface SourceRow {
+    /** GA4 `sessionSource` value. */
+    source: string;
+    /** GA4 `sessionDefaultChannelGroup`, e.g. Organic Search. */
+    channel: string;
+    sessions: number;
+    /** True when this source is one of the design-industry referrers. */
+    designIndustry: boolean;
+    /** True for GA4's `(not set)` / `(direct)` style buckets, which are not real sources. */
+    unattributed: boolean;
+}
+/** Where visitors came from. */
+interface AcquisitionData {
+    rows: SourceRow[];
+    totalSessions: number;
+    /** Sessions from design-industry referrers, as a share of the total. */
+    designIndustryShare: number | null;
+    /** Sessions GA4 could not attribute, as a share of the total. */
+    unattributedShare: number | null;
+    /** True when GA4 withheld low-count rows, so the tail is shorter than reality. */
+    rowsWithheld: boolean;
+}
+/** One rung of the funnel. */
+interface JourneyStep {
+    key: string;
+    label: string;
+    event: string;
+    count: MetricValue;
+    /**
+     * Share of the previous measurable step that reached this one.
+     * Null when either end is unavailable — a drop-off across an unmeasured step is meaningless.
+     */
+    conversionFromPrevious: number | null;
+}
+/** A page where sessions commonly ended. */
+interface ExitPage {
+    path: string;
+    exits: number;
+}
+/** How far visitors get. Per-step totals, never an observed path. */
+interface JourneyData {
+    steps: JourneyStep[];
+    topExitPages: ExitPage[];
+    /** Always true. The UI must not present these steps as a tracked journey. */
+    approximate: true;
+    /** Why it is approximate, in words the panel can show directly. */
+    approximationNote: string;
+}
+/** One family's interest figures. */
+interface TypefaceInterestRow {
+    typeface: string;
+    viewed: MetricValue;
+    tested: MetricValue;
+    bought: MetricValue;
+    /** Tested divided by viewed. Null unless both are real numbers. */
+    testRate: number | null;
+}
+/** Viewed, tested and bought, by family. */
+interface TypefaceInterestData {
+    rows: TypefaceInterestRow[];
+    /** Stated in the response so the UI cannot omit it. */
+    interpretationNote: string;
+    /** True when GA4 withheld low-count rows, so quiet families may be missing entirely. */
+    rowsWithheld: boolean;
+}
+
+/**
+ * Acquisition — where visitors come from.
+ *
+ * Design-industry referrers are pulled out as a named segment rather than left in a generic
+ * referrer table. A visit from Fonts In Use or Typewolf is a pre-qualified, industry-literate
+ * visitor and behaves nothing like average organic traffic; burying those rows among search and
+ * social discards the distinction a foundry actually acts on.
+ *
+ * `(not set)` rows are surfaced rather than swept into "other". On a type-foundry site they can be
+ * a large share — bookmarked visits, stripped referrers, AI crawlers — and hiding them makes the
+ * table look more complete than it is.
+ */
+
+/** Referrer hosts that identify a design-industry source worth tracking separately. */
+declare const DESIGN_INDUSTRY_SOURCES: readonly ["fontsinuse.com", "typewolf.com", "typographica.org", "fonts.google.com", "behance.net", "dribbble.com", "itsnicethat.com"];
+
+/**
+ * Journey — how far visitors get, and where they stop.
+ *
+ * This is an ordered step funnel, not a path graph, and that is a deliberate limit rather than a
+ * simplification. GA4's Data API has no path-exploration endpoint; Path Exploration is a UI-only
+ * feature. What is available is per-event totals and `runFunnelReport`, an alpha surface that
+ * returns step-conversion marginals — not observed sequences. Rendering ribbons from marginals
+ * would assert that a given visitor went A to B to C when no such co-occurrence was ever measured.
+ *
+ * So each step is reported as its own honest total, adjacent drop-off is derived between steps, and
+ * the response is explicitly flagged as an approximation for the UI to display.
+ *
+ * A step whose event is not instrumented on this site reports as unavailable, never as zero. On a
+ * site missing `begin_checkout`, the cart-to-checkout drop-off is not "100% drop-off" — it is
+ * unmeasured, and the two must not look alike.
+ */
+
+/** The funnel, in order. Each entry names the GA4 event that evidences the step. */
+declare const JOURNEY_STEPS: readonly [{
+    readonly key: "landed";
+    readonly label: "Landed";
+    readonly event: "page_view";
+}, {
+    readonly key: "viewed_typeface";
+    readonly label: "Viewed a typeface";
+    readonly event: "view_item";
+}, {
+    readonly key: "tested";
+    readonly label: "Used the type tester";
+    readonly event: "tester_engaged";
+}, {
+    readonly key: "added_to_cart";
+    readonly label: "Added to cart";
+    readonly event: "add_to_cart";
+}, {
+    readonly key: "began_checkout";
+    readonly label: "Began checkout";
+    readonly event: "begin_checkout";
+}, {
+    readonly key: "purchased";
+    readonly label: "Purchased";
+    readonly event: "purchase";
+}];
+
+export { type AcquisitionData, DESIGN_INDUSTRY_SOURCES, ENV_VARS, type ExitPage, type HandlerOptions, type HandlerRequest, type HandlerResponse, JOURNEY_STEPS, type JourneyData, type JourneyStep, type MeasurementHealthData, MetricValue, type SanityQueryClient, SiteAnalyticsConfig, type SourceRow, type StudioUser, type TypefaceInterestData, type TypefaceInterestRow, applyCors, clearCache, createVisitorInsightsHandler, requireStudioUser, verifyStudioRequest };