@treasuredata/web-sdk 1.0.0

package/dist/browser.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Browser/IIFE Entry Point
+ *
+ * This entry point is specifically for browser IIFE builds.
+ * It exports only Treasure as the default export so it becomes the global constructor.
+ */
+import Treasure from './treasure';
+export default Treasure;
+//# sourceMappingURL=browser.d.ts.map

package/dist/checksums.txt

@@ -0,0 +1,8 @@
+f78df7778b059bfdc572a76427956a414751e4c5bcc6aa0ef2cab5b3242b0bf7  ./loader.min.js
+4ed5ef2e3f519aaa7cf4a612eddd67df5c18d0e6b452d5bd11b59d36f821ea3b  ./td-sdk.esm.js
+fceb3135094564669c2b760b891eea4d02165e5faab1b3078af1670f8fc04c5d  ./td-sdk.esm.min.js
+8dc322d45af0e3b2d8fc2f86245421c6111d251c368aa7f5d57555f4a487c1d7  ./td-sdk.min.js
+80452ed288b30ea6d44f30910170679eb33ab8382ef92cce5afc0aeedc03a493  ./td-sdk.cjs
+842c5a1495039443abf3305a7dbe1c203a3aab446b0dd52050f2dba5d5eed7a3  ./td-sdk.js
+f78df7778b059bfdc572a76427956a414751e4c5bcc6aa0ef2cab5b3242b0bf7  ./loader.js
+28e68c0b48b19abb08582fffad0fb5af2b69cd9f26ea8cb999bf2c60850950d2  ./td-sdk.min.cjs

package/dist/core/config.d.ts

@@ -0,0 +1,10 @@
+export declare const CONFIG: {
+    readonly GLOBAL: "Treasure";
+    readonly VERSION: "1.0.0";
+    readonly HOST: "us01.records.in.treasuredata.com";
+    readonly DATABASE: "";
+    readonly PATHNAME: "/";
+    readonly FILENAME: "td-sdk";
+    readonly URL: "//cdn.treasuredata.com/sdk/web/1.0/td-sdk.min.js";
+};
+//# sourceMappingURL=config.d.ts.map

package/dist/core/config.template.d.ts

@@ -0,0 +1,10 @@
+export declare const CONFIG: {
+    readonly GLOBAL: "@GLOBAL";
+    readonly VERSION: "@VERSION";
+    readonly HOST: "@HOST";
+    readonly DATABASE: "@DATABASE";
+    readonly PATHNAME: "@PATHNAME";
+    readonly FILENAME: "@FILENAME";
+    readonly URL: "@URL";
+};
+//# sourceMappingURL=config.template.d.ts.map

package/dist/core/configurator.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Treasure Configurator
+ * Handles configuration validation and setup for the TD client
+ */
+import type { TDConfig } from '../types';
+declare function defaultSSCCookieDomain(): string;
+export declare const DEFAULT_CONFIG: {
+    database: "";
+    development: boolean;
+    globalIdCookie: string;
+    host: "us01.records.in.treasuredata.com";
+    logging: boolean;
+    pathname: "/";
+    requestType: string;
+    jsonpTimeout: number;
+    startInSignedMode: boolean;
+    useServerSideCookie: boolean;
+    sscDomain: typeof defaultSSCCookieDomain;
+    sscServer: (cookieDomain: string) => string;
+    storeConsentByLocalStorage: boolean;
+};
+/**
+ * Configure TD client configuration
+ * Pure function that takes a partial config with required `writeKey` and
+ * `database`, and returns a complete, validated config
+ *
+ * Modify DEFAULT_CONFIG to change any defaults
+ * Protocol defaults to auto-detection but can be set manually
+ * host defaults to us01.records.in.treasuredata.com
+ * pathname defaults to /
+ * requestType is always fetch
+ */
+export declare function configure(options: Pick<TDConfig, 'writeKey' | 'database'> & Partial<TDConfig>): TDConfig;
+export {};
+//# sourceMappingURL=configurator.d.ts.map

package/dist/core/sdk.d.ts

@@ -0,0 +1,3 @@
+import type { TDConfig, TreasureSDK } from '../types';
+export declare function createSDK(config: TDConfig): TreasureSDK;
+//# sourceMappingURL=sdk.d.ts.map

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Treasure Data Web SDK - Modern TypeScript Implementation
+ *
+ * A modern, TypeScript-first analytics SDK for browser event tracking
+ * with Baseline browser support and comprehensive type safety.
+ */
+export { createSDK } from './core/sdk';
+export { Treasure, default } from './treasure';
+export { createLoader, processQueuedCalls, replaceLoaderStub } from './loader';
+export { initSDK } from './init';
+export * from './types';
+export { session, BLOCKEVENTSCOOKIE, SIGNEDMODECOOKIE } from './plugins/session';
+export { record, _validateRecord } from './plugins/record';
+export { track } from './plugins/track';
+export { clicks } from './plugins/clicks';
+export type { ClickTrackingOptions } from './plugins/clicks';
+export { utm } from './plugins/utm';
+export type { UTMPluginOptions } from './plugins/utm';
+export { personalization } from './plugins/personalization';
+export type { UserSegmentOptions, UserSegment, PersonalizationFetchConfig, } from './plugins/personalization';
+export { pagePersonalize } from './plugins/page-personalize';
+export type { PagePersonalizePluginAPI, ApplyPersonalizationOptions, } from './plugins/page-personalize';
+export type { PersonalizationPayload } from './plugins/page-personalize/offers';
+export { conversionAPI } from './plugins/conversion-api';
+export type { ConversionAPIConfig, ConversionAPIOptions, } from './plugins/conversion-api';
+export { serverCookie } from './plugins/server-cookie';
+export { globalId } from './plugins/global-id';
+export type { GlobalIdPluginAPI, GlobalIdCookieOptions, } from './plugins/global-id';
+export { generateUUID, isValidUUID } from './utils/uuid';
+export { setCookie, type CookieConfig } from './utils/set-cookie';
+export { cookie } from './vendor/js-cookies';
+export * as elementUtils from './utils/element';
+export { adlHeaders, globalIdAdlHeaders, invariant, isLocalStorageAccessible, } from './utils/misc';
+export { configure, DEFAULT_CONFIG } from './core/configurator';
+export { SERVER_COOKIE_NAME } from './plugins/server-cookie';
+export declare const version: string;
+//# sourceMappingURL=index.d.ts.map

package/dist/init.d.ts

@@ -0,0 +1,18 @@
+/**
+ * SDK Initialization and Loader Integration
+ *
+ * This module handles the initialization of the SDK and integration with the async loader.
+ * It automatically replaces any loader stubs with actual SDK instances.
+ */
+import { Treasure } from './treasure';
+/**
+ * Initialize the SDK and replace any existing loader stubs
+ */
+export declare function initSDK(globalName?: string): void;
+export { Treasure };
+declare const _default: {
+    initSDK: typeof initSDK;
+    Treasure: typeof Treasure;
+};
+export default _default;
+//# sourceMappingURL=init.d.ts.map

package/dist/loader.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Treasure Data SDK Async Loader
+ *
+ * This loader creates a stub object that queues method calls before the actual SDK loads.
+ * This allows the SDK to be loaded asynchronously without blocking page rendering,
+ * while still capturing early tracking events.
+ *
+ * Usage in HTML:
+ * <script>
+ *   (function(n,c){if(c[n]===void 0){c[n]=function(){c[n].clients.push(this);this._init=[Array.prototype.slice.call(arguments)]};c[n].clients=[];var action=function(method){return function(){this['_'+method]=this['_'+method]||[];this['_'+method].push(Array.prototype.slice.call(arguments));return this}};var methods=['collectTags','addRecord','blockEvents','fetchServerCookie','fetchGlobalID','fetchUserSegments','fetchPersonalization','resetUUID','ready','setSignedMode','setAnonymousMode','set','trackEvent','trackPageview','trackClicks','unblockEvents'];for(var i=0;i<methods.length;i++){var method=methods[i];c[n].prototype[method]=action(method)}var s=document.createElement('script');s.type='text/javascript';s.async=!0;s.src=(document.location.protocol==='https:'?'https:':'http:')+'/path/to/td.js';var t=document.getElementsByTagName('script')[0];t.parentNode.insertBefore(s,t)}}('td',this));
+ *
+ *   // Now you can use td immediately
+ *   var client = new td({writeKey: 'key', database: 'db'});
+ *   client.trackEvent('table', {event: 'data'});
+ * </script>
+ */
+interface LoaderClient {
+    _init?: any[][];
+    _collectTags?: any[][];
+    _addRecord?: any[][];
+    _blockEvents?: any[][];
+    _fetchServerCookie?: any[][];
+    _fetchGlobalID?: any[][];
+    _fetchUserSegments?: any[][];
+    _fetchPersonalization?: any[][];
+    _resetUUID?: any[][];
+    _ready?: any[][];
+    _setSignedMode?: any[][];
+    _setAnonymousMode?: any[][];
+    _set?: any[][];
+    _trackEvent?: any[][];
+    _trackPageview?: any[][];
+    _trackClicks?: any[][];
+    _unblockEvents?: any[][];
+}
+/**
+ * List of SDK methods that should be stubbed in the loader
+ * Order matters for consistency between loader and processor
+ */
+export declare const LOADER_METHODS: string[];
+/**
+ * Creates the async loader stub function
+ */
+export declare function createLoader(globalName: string, scriptUrl: string): string;
+/**
+ * Processes queued calls from the loader stub
+ */
+export declare function processQueuedCalls(loaderClient: LoaderClient, actualClient: any): void;
+/**
+ * Replaces the loader stub with the actual SDK
+ */
+export declare function replaceLoaderStub(globalName: string, sdkConstructor: any): void;
+declare const _default: {
+    createLoader: typeof createLoader;
+    processQueuedCalls: typeof processQueuedCalls;
+    replaceLoaderStub: typeof replaceLoaderStub;
+};
+export default _default;
+//# sourceMappingURL=loader.d.ts.map

package/dist/loader.js

@@ -0,0 +1 @@
+!function(t,e){if(void 0===e[t]){e[t]=function(){e[t].clients.push(this),this._init=[Array.prototype.slice.call(arguments)]},e[t].clients=[];for(var r=function(t){return function(){return this["_"+t]=this["_"+t]||[],this["_"+t].push(Array.prototype.slice.call(arguments)),this}},s=["set","collectTags","blockEvents","unblockEvents","setSignedMode","setAnonymousMode","fetchServerCookie","fetchGlobalID","fetchUserSegments","fetchPersonalization","resetUUID","addRecord","trackEvent","trackPageview","trackClicks","ready"],c=0;c<s.length;c++){var o=s[c];e[t].prototype[o]=r(o)}var n=document.createElement("script");n.type="text/javascript",n.async=!0,n.src=("https:"===document.location.protocol?"https:":"http:")+"//cdn.treasuredata.com/sdk/web/1.0/td-sdk.min.js";var i=document.getElementsByTagName("script")[0];i.parentNode.insertBefore(n,i)}}("Treasure",this);

package/dist/loader.min.js

@@ -0,0 +1 @@
+!function(t,e){if(void 0===e[t]){e[t]=function(){e[t].clients.push(this),this._init=[Array.prototype.slice.call(arguments)]},e[t].clients=[];for(var r=function(t){return function(){return this["_"+t]=this["_"+t]||[],this["_"+t].push(Array.prototype.slice.call(arguments)),this}},s=["set","collectTags","blockEvents","unblockEvents","setSignedMode","setAnonymousMode","fetchServerCookie","fetchGlobalID","fetchUserSegments","fetchPersonalization","resetUUID","addRecord","trackEvent","trackPageview","trackClicks","ready"],c=0;c<s.length;c++){var o=s[c];e[t].prototype[o]=r(o)}var n=document.createElement("script");n.type="text/javascript",n.async=!0,n.src=("https:"===document.location.protocol?"https:":"http:")+"//cdn.treasuredata.com/sdk/web/1.0/td-sdk.min.js";var i=document.getElementsByTagName("script")[0];i.parentNode.insertBefore(n,i)}}("Treasure",this);

package/dist/plugins/clicks.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Clicks Plugin
+ * Automatically tracks clicks on interactive elements
+ */
+import type { TreasurePlugin } from '../types';
+export interface ClickTrackingOptions {
+    /** Element to observe (default: document) */
+    element?: EventTarget;
+    /** Function to extend click data */
+    extendClickData?: (event: Event, data: Record<string, string>) => Record<string, string> | null;
+    /** Attribute name to ignore elements (default: 'td-ignore') */
+    ignoreAttribute?: string;
+    /** Table name for click events (default: 'clicks') */
+    tableName?: string;
+}
+export interface ClicksPluginAPI {
+    /** Track clicks with optional configuration */
+    trackClicks: (options?: ClickTrackingOptions) => (() => void) | undefined;
+}
+export declare function clicks(): TreasurePlugin<ClicksPluginAPI>;
+//# sourceMappingURL=clicks.d.ts.map

package/dist/plugins/conversion-api.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Conversion API Support Plugin
+ * Collects advertising cookies and parameters from various platforms for conversion tracking
+ */
+import type { TreasurePlugin } from '../types';
+export interface ConversionAPIConfig {
+    /** Vendors to collect tags from */
+    vendors?: string[];
+    /** Cookie names to collect */
+    cookies?: string[];
+    /** URL parameter names to collect */
+    params?: string[];
+}
+export interface ConversionAPIOptions {
+    /** Custom Google Conversion Linker prefix (default: '_gcl') */
+    gclPrefix?: string;
+}
+export interface ConversionAPIPluginAPI {
+    /** Collect conversion tracking tags */
+    collectTags(config?: ConversionAPIConfig, options?: ConversionAPIOptions): void;
+}
+export declare function conversionAPI(): TreasurePlugin<ConversionAPIPluginAPI>;
+//# sourceMappingURL=conversion-api.d.ts.map

package/dist/plugins/global-id.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Global ID Plugin
+ * Fetches and caches the Treasure Data Global ID.
+ */
+import type { TreasurePlugin } from '../types';
+export interface GlobalIdCookieOptions {
+    path?: string;
+    domain?: string;
+    secure?: boolean;
+    maxAge?: number | string | Date;
+    sameSite?: 'None' | 'Lax' | 'Strict';
+}
+export interface GlobalIdPluginAPI {
+    fetchGlobalID(success?: (globalId: string | null) => void, error?: (error: unknown) => void, forceFetch?: boolean, options?: GlobalIdCookieOptions): void;
+}
+export declare function globalId(): TreasurePlugin<GlobalIdPluginAPI>;
+//# sourceMappingURL=global-id.d.ts.map

package/dist/plugins/in-browser-message.d.ts

@@ -0,0 +1,6 @@
+/**
+ * In-browser message rendering for personalization API responses
+ * Handles popup (Shadow DOM modal) and inline (DOM replacement) message types
+ */
+export declare function handlePersonalizationResponse(response: unknown): void;
+//# sourceMappingURL=in-browser-message.d.ts.map

package/dist/plugins/page-personalize/bridge/constants.d.ts

@@ -0,0 +1,9 @@
+/** URL query parameter that selects the active mode. */
+export declare const MODE_QUERY_PARAM = "td-personalization-mode";
+/** Init message data value. */
+export declare const INIT_MESSAGE_TYPE = "td:p13n-studio:init";
+/** Ready message data value. */
+export declare const READY_MESSAGE_TYPE = "td:p13n-studio:ready";
+/** Trusted parent origins for cross-frame communication. */
+export declare const ALLOWED_PARENT_ORIGINS: readonly string[];
+//# sourceMappingURL=constants.d.ts.map

package/dist/plugins/page-personalize/bridge/rpc.d.ts

@@ -0,0 +1,15 @@
+import { type Remote } from 'comlink';
+import type { ModeRuntime } from '../router';
+/**
+ * Exposes an RPC object to the parent frame over the handshake port.
+ */
+export declare function exposeRpc<T extends object>(rpc: T): ModeRuntime;
+/**
+ * Wraps the parent frame's RPC over the handshake port. `getApi()` returns
+ * `null` until the handshake completes, then the live `Remote<T>`. After
+ * `dispose()`, returns `null` again.
+ */
+export declare function wrapParentRpc<T extends object>(): ModeRuntime & {
+    getApi: () => Remote<T> | null;
+};
+//# sourceMappingURL=rpc.d.ts.map

package/dist/plugins/page-personalize/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Treasure Data Personalization Studio runtime plugin.
+ *
+ * Customer-facing. Exposes the page-personalization surface
+ * (`personalizePage`, `applyPersonalization`) for fetching and applying
+ * personalized content to the page.
+ *
+ * It also hosts the internal Studio `preview` integration, which customers do
+ * not interact with directly.
+ */
+import type { JSONValue, TreasurePlugin } from '../../types';
+import type { PersonalizationFetchConfig } from '../personalization';
+import { type PersonalizationPayload } from './offers';
+/** Options for {@link PagePersonalizePluginAPI.applyPersonalization}. */
+export interface ApplyPersonalizationOptions {
+    /**
+     * Apply even while the page is embedded in Personalization Studio.
+     * Defaults to false to avoid clobbering spot previews/picker.
+     */
+    force?: boolean;
+}
+export interface PagePersonalizePluginAPI {
+    /**
+     * Apply a previously fetched personalization payload to the current page.
+     */
+    applyPersonalization(payload: PersonalizationPayload, options?: ApplyPersonalizationOptions): void;
+    /**
+     * Fetch personalization offers and apply them to the current page.
+     * The success callback receives the fetched payload.
+     */
+    personalizePage(config: PersonalizationFetchConfig, data?: Record<string, JSONValue> | null, successCallback?: (payload: PersonalizationPayload) => void, errorCallback?: (error: Error) => void): void;
+}
+export declare function pagePersonalize(): TreasurePlugin<PagePersonalizePluginAPI>;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/page-personalize/injection/inject.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Shared shadow-DOM spot injection. Per-spot primitives; callers iterate
+ * and validate inputs.
+ *
+ * `applySpot` never throws — platform exceptions are caught and converted
+ * into structured `ApplySpotResult` failures.
+ */
+import type { ApplySpotResult, Spot, SpotRef } from '../types';
+/** Inject one spot into `doc`. Caller MUST pass a structurally-valid `Spot`. */
+export declare function applySpot(doc: Document, spot: Spot): ApplySpotResult;
+/**
+ * Restore visibility of original light DOM under the spot's host. Inserts a
+ * `<slot>` because the platform offers no way to detach a shadow root once
+ * attached. Caller MUST pass a structurally-valid `SpotRef`.
+ */
+export declare function removeSpot(doc: Document, ref: SpotRef): void;
+//# sourceMappingURL=inject.d.ts.map

package/dist/plugins/page-personalize/modes/preview.d.ts

@@ -0,0 +1,3 @@
+import type { ModeHandler } from '../router';
+export declare const previewHandler: ModeHandler;
+//# sourceMappingURL=preview.d.ts.map

package/dist/plugins/page-personalize/modes/spot-selection.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Spot-selection mode handler.
+ *
+ * Highlights DOM elements on hover and sends a stable CSS selector to the
+ * parent Studio via Comlink on click.
+ */
+import type { ModeHandler } from '../router';
+export declare const spotSelectionHandler: ModeHandler;
+//# sourceMappingURL=spot-selection.d.ts.map

package/dist/plugins/page-personalize/offers.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Personalization-offer decoding for the page-personalize "apply" path.
+ *
+ * The p13n API returns a map of named offers. Every value inside an offer's
+ * `attributes` arrives as a JSON string (TD convention), so each field is
+ * parsed before use. Of all offers, exactly one wins: the latest in-window
+ * campaign, with audience rank as the tie-breaker (see `selectWinningOffer`).
+ * Its `content` entries become `Spot`s for shadow-DOM injection.
+ */
+import type { Spot } from './types';
+/** One personalization entry as authored in Studio, parsed from untrusted p13n
+ * JSON and validated at runtime. */
+export interface P13nEntry {
+    /** CSS selector for the host element. */
+    css_selector: string;
+    /** HTML injected into the host's shadow root. */
+    html_value: string;
+    /** CSS injected into the host's shadow root. */
+    css_value: string;
+    /** Creative/personalization identifier for impression reporting. */
+    id: number;
+}
+/** Offer attributes. Every value is delivered as a string by the p13n API. Keys
+ * are prefixed with `td_personalization.` per the API return contract. */
+export interface PersonalizationOfferAttributes {
+    /** JSON string encoding a `P13nEntry[]`. */
+    'td_personalization.content'?: string;
+    /** Numeric string; lower value = higher rank. Tie-breaker among offers that
+     * share the latest `campaign_updated_at`. */
+    'td_personalization.audience_rank'?: string;
+    /** Unix-seconds string; primary selection key (latest wins). */
+    'td_personalization.campaign_updated_at'?: string;
+    /** Unix-seconds string; campaign becomes active at this time (inclusive). */
+    'td_personalization.campaigns_start_date'?: string;
+    /** Unix-seconds string; campaign stops being active at this time (exclusive). */
+    'td_personalization.campaigns_end_date'?: string;
+    /** Campaign identifier shared by the offer's content entries. */
+    'td_personalization.campaign'?: string;
+    [key: string]: unknown;
+}
+export interface PersonalizationOffer {
+    attributes?: PersonalizationOfferAttributes | null;
+}
+export interface PersonalizationPayload {
+    offers?: Record<string, PersonalizationOffer> | null;
+}
+export interface ImpressionRef {
+    campaign: string;
+    creative: string;
+}
+export interface DecodedSpot {
+    spot: Spot;
+    /** Null when the entry can't be attributed; the spot is still injected. */
+    impression: ImpressionRef | null;
+}
+/**
+ * Pick the single latest in-window offer, tie-broken by audience rank.
+ *
+ * Selection order over `payload.offers` (insertion order preserved):
+ * 1. Drop offers outside their active campaign window.
+ * 2. Drop offers without a finite numeric `audience_rank`.
+ * 3. Winner = highest `campaign_updated_at` (missing treated as `-Infinity`);
+ *    ties broken by lowest `audience_rank`, then by first encountered.
+ *
+ * Returns `null` when no offer qualifies. `now` defaults to the current time in
+ * unix seconds and is injectable for deterministic tests.
+ */
+export declare function selectWinningOffer(payload: PersonalizationPayload | null | undefined, now?: number): PersonalizationOffer | null;
+/** Decode the single winning offer's entries into spots; malformed entries are
+ * dropped, so the result may be shorter than the offer's content. */
+export declare function decodeOffers(payload: PersonalizationPayload | null | undefined, now?: number): DecodedSpot[];
+//# sourceMappingURL=offers.d.ts.map

package/dist/plugins/page-personalize/router.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Mode detection + dispatch for pagePersonalize. Adding a mode: drop a
+ * handler in `modes/` and register it in `MODE_HANDLERS`.
+ */
+import type { TreasureCore } from '../../types';
+import type { PagePersonalizeMode } from './types';
+export interface ModeHandler {
+    readonly mode: PagePersonalizeMode;
+    /** Returning `null` is a clean refusal; the router treats it as a no-op. */
+    activate(core: TreasureCore): ModeRuntime | null;
+}
+export interface ModeRuntime {
+    /** Reserved for future SPA route-change teardown. */
+    dispose?(): void;
+}
+export declare function runRouter(core: TreasureCore): PagePersonalizeMode | null;
+//# sourceMappingURL=router.d.ts.map

package/dist/plugins/page-personalize/types.d.ts

@@ -0,0 +1,27 @@
+/** Internal types for the pagePersonalize plugin. */
+export interface Spot {
+    selector: string;
+    html?: string;
+    css?: string;
+}
+export interface ApplySpotResult {
+    /**
+     * Echoes back the caller's `selector` for resolved paths (always a string)
+     * and roundtrips the original faulty value verbatim for `invalid_spot`,
+     * so Studio can attribute per-row failures.
+     */
+    selector: unknown;
+    success: boolean;
+    reason?: 'invalid_spot' | 'not_found' | 'unsupported_element' | 'already_has_shadow' | 'injection_error';
+    matchCount?: number;
+}
+export type PagePersonalizeMode = 'preview' | 'spot-selection';
+export type SpotRef = Pick<Spot, 'selector'>;
+export interface PreviewRpc {
+    applySpots(spots: Spot[]): Promise<ApplySpotResult[]>;
+    removeSpots(spots: SpotRef[]): Promise<void>;
+}
+export interface SpotSelectionParentRpc {
+    onSpotSelected(selector: string): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/plugins/page-personalize/utils/selector-generator.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Multi-tier CSS selector generator.
+ * Produces a stable, minimal selector for a given DOM element.
+ */
+export declare function generateSelector(element: Element): string;
+//# sourceMappingURL=selector-generator.d.ts.map

package/dist/plugins/personalization.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Personalization Plugin
+ * Provides user segmentation and personalization capabilities
+ */
+import type { TreasurePlugin, JSONValue } from '../types';
+export interface UserSegmentOptions {
+    /** Audience token(s) for the userId */
+    audienceToken: string | string[];
+    /** Key-value pairs to be sent for this segment */
+    keys?: Record<string, JSONValue>;
+}
+export interface UserSegment {
+    /** Segment key data */
+    key: Record<string, JSONValue>;
+    /** Segment values */
+    values: string[];
+    /** Segment attributes */
+    attributes: Record<string, JSONValue>;
+}
+export interface PersonalizationFetchConfig {
+    /** Personalization endpoint */
+    endpoint: string;
+    /** Database name */
+    database: string;
+    /** Table name */
+    table: string;
+    /** Personalization token */
+    token: string;
+}
+export interface PersonalizationPluginAPI {
+    /** Fetch user segments */
+    fetchUserSegments(options: UserSegmentOptions, successCallback?: (segments: UserSegment[]) => void, errorCallback?: (error: Error) => void): void;
+    /** Fetch user segments (overload for token-only usage) */
+    fetchUserSegments(audienceToken: string | string[], successCallback?: (segments: UserSegment[]) => void, errorCallback?: (error: Error) => void): void;
+    /** Fetch personalization data */
+    fetchPersonalization(config: PersonalizationFetchConfig, data?: Record<string, JSONValue> | null, successCallback?: (response: Record<string, JSONValue>) => void, errorCallback?: (error: Error) => void): void;
+}
+export declare function personalization(): TreasurePlugin<PersonalizationPluginAPI>;
+//# sourceMappingURL=personalization.d.ts.map

package/dist/plugins/record.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Record Plugin
+ * Core functionality for tracking events and managing storage
+ * Converted from core/record.ts to plugin architecture
+ */
+import type { TreasurePlugin, JSONValue, TrackResponse, TDError } from '../types';
+export interface AddRecordOptions {
+    /** Defaults to the SDK's configured database when omitted. */
+    database?: string;
+}
+export interface RecordPluginAPI {
+    addRecord(table: string, record: Record<string, JSONValue>, success?: (response: TrackResponse) => void, error?: (error: TDError) => void, options?: AddRecordOptions): void;
+}
+export interface SubmitRecordRequest {
+    apikey: string;
+    record: Record<string, JSONValue>;
+    time: number | null;
+    url: string;
+    inSignedMode: boolean;
+    isGlobalIdEnabled: boolean;
+    windowBeingUnloaded: boolean;
+    timeoutMs: number;
+}
+/**
+ * Validate record data
+ */
+declare function validateRecord(table: string, record: Record<string, JSONValue>): void;
+export declare const _validateRecord: typeof validateRecord;
+export declare function record(): TreasurePlugin<RecordPluginAPI>;
+export declare function submitRecord(request: SubmitRecordRequest, success?: (response: TrackResponse) => void, error?: (error: TDError) => void): Promise<void>;
+export {};
+//# sourceMappingURL=record.d.ts.map

package/dist/plugins/server-cookie.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Server-side Cookie Plugin
+ *
+ * This functionality complies with ITP 1.2 tracking.
+ * Contact customer support for enabling this feature.
+ */
+import type { TreasurePlugin } from '../types';
+export interface ServerCookiePluginAPI {
+    /** Fetch server-side cookie ID */
+    fetchServerCookie(success?: (serverSideId: string) => void, error?: (error: string | Error) => void, forceFetch?: boolean): void;
+}
+export declare const SERVER_COOKIE_NAME = "_td_ssc_id";
+export declare function serverCookie(): TreasurePlugin<ServerCookiePluginAPI>;
+//# sourceMappingURL=server-cookie.d.ts.map

package/dist/plugins/session.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Session Plugin
+ * Owns identity (UUID) and consent (signed/anonymous mode) state.
+ * Both record and track read from this plugin via sdk.
+ */
+import type { TreasurePlugin, StorageConfiguration, JSONValue } from '../types';
+export declare const BLOCKEVENTSCOOKIE = "__td_blockEvents";
+export declare const SIGNEDMODECOOKIE = "__td_signed";
+export interface SessionPluginAPI {
+    inSignedMode(): boolean;
+    setSignedMode(): void;
+    setAnonymousMode(keepIdentifier?: boolean): void;
+    blockEvents(): void;
+    unblockEvents(): void;
+    areEventsBlocked(): boolean;
+    getUUID(): string;
+    resetUUID(suggestedStorage?: StorageConfiguration, suggestedClientId?: string): void;
+    set(table: string | Record<string, JSONValue>, property?: string | Record<string, JSONValue>, value?: JSONValue): void;
+    get(table?: string, key?: string): JSONValue;
+    removeCachedGlobalID(): void;
+    removeServerCookie(): void;
+    isGlobalIdEnabled(): boolean;
+}
+export declare function session(): TreasurePlugin<SessionPluginAPI>;
+//# sourceMappingURL=session.d.ts.map

package/dist/plugins/track.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Track Plugin
+ * Provides event tracking with UUID management and global values
+ */
+import type { TreasurePlugin, JSONValue, TrackResponse, TDError, PersonalizationOptions } from '../types';
+export interface TrackPluginAPI {
+    trackEvent(table?: string, record?: Record<string, JSONValue>, success?: (result: TrackResponse) => void, failure?: (error: TDError) => void): void;
+    trackPageview(table?: string, success?: (result: TrackResponse) => void, failure?: (error: TDError) => void, options?: {
+        payload?: Record<string, JSONValue>;
+    }): void;
+    getTrackValues(): Record<string, JSONValue>;
+    getPersonalizationConfig(): PersonalizationOptions | undefined;
+    setPersonalizationConfig(options?: PersonalizationOptions): void;
+}
+export declare function track(): TreasurePlugin<TrackPluginAPI>;
+//# sourceMappingURL=track.d.ts.map