@adv-re/segment-wrapper 4.36.0-beta.0

package/dist/index.d.mts

@@ -0,0 +1,916 @@
+/**
+ * Core Segment Analytics types
+ */
+/**
+ * Segment Analytics instance available on window.analytics
+ */
+interface SegmentAnalytics {
+    track: (event: string, properties?: Record<string, unknown>, options?: AnalyticsOptions, callback?: AnalyticsCallback) => void;
+    page: (name?: string, properties?: Record<string, unknown>, options?: AnalyticsOptions, callback?: AnalyticsCallback) => void;
+    identify: (userId: string | number, traits?: Record<string, unknown>, options?: AnalyticsOptions, callback?: AnalyticsCallback) => void;
+    reset: () => void;
+    ready: (callback: () => void) => void;
+    addSourceMiddleware?: (middleware: SourceMiddlewareFunction) => void;
+    addDestinationMiddleware?: (middleware: DestinationMiddlewareFunction) => void;
+    user?: () => SegmentUser;
+}
+/**
+ * Segment user object
+ */
+interface SegmentUser {
+    id: () => string | null;
+    anonymousId: () => string | null;
+    traits: () => Record<string, unknown>;
+}
+/**
+ * Callback function for analytics methods
+ */
+type AnalyticsCallback = (...args: unknown[]) => void;
+/**
+ * Options/context object for analytics methods
+ */
+interface AnalyticsOptions {
+    integrations?: IntegrationsObject;
+    context?: ContextObject;
+    anonymousId?: string;
+    ip?: string;
+    [key: string]: unknown;
+}
+/**
+ * Context object that can be passed to analytics methods
+ */
+interface ContextObject {
+    integrations?: IntegrationsObject;
+    traits?: Record<string, unknown>;
+    campaign?: CampaignDetails;
+    page?: PageContext;
+    userAgent?: string;
+    ip?: string;
+    locale?: string;
+    timezone?: string;
+    externalIds?: ExternalId[];
+    [key: string]: unknown;
+}
+/**
+ * Integrations configuration object
+ */
+interface IntegrationsObject {
+    All?: boolean;
+    'Adobe Analytics'?: boolean | {
+        marketingCloudVisitorId?: string;
+    };
+    'Google Analytics 4'?: boolean | {
+        clientId?: string;
+        sessionId?: string;
+    };
+    Personas?: boolean;
+    Webhooks?: boolean;
+    Webhook?: boolean;
+    [integrationName: string]: boolean | Record<string, unknown> | undefined;
+}
+/**
+ * Campaign details from URL parameters
+ */
+interface CampaignDetails {
+    campaign_id?: string;
+    campaign_name?: string;
+    campaign_source?: string;
+    campaign_medium?: string;
+    campaign_term?: string;
+    campaign_content?: string;
+    [key: string]: string | undefined;
+}
+/**
+ * Page context information
+ */
+interface PageContext {
+    path?: string;
+    referrer?: string;
+    search?: string;
+    title?: string;
+    url?: string;
+    [key: string]: unknown;
+}
+/**
+ * External ID for cross-platform identification
+ */
+interface ExternalId {
+    id: string;
+    type: string;
+    collection?: string;
+    encoding?: string;
+}
+/**
+ * Middleware payload object
+ */
+interface MiddlewarePayload {
+    obj: {
+        type: string;
+        event?: string;
+        userId?: string | number;
+        anonymousId?: string;
+        properties?: Record<string, unknown>;
+        traits?: Record<string, unknown>;
+        context?: ContextObject;
+        integrations?: IntegrationsObject;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+/**
+ * Source middleware function signature
+ */
+type SourceMiddlewareFunction = (payload: {
+    payload: MiddlewarePayload;
+    next: (payload: MiddlewarePayload | null) => void;
+    integrations: IntegrationsObject;
+}) => void;
+/**
+ * Destination middleware function signature
+ */
+type DestinationMiddlewareFunction = (payload: {
+    payload: MiddlewarePayload;
+    next: (payload: MiddlewarePayload | null) => void;
+    integration: string;
+}) => void;
+/**
+ * Google Consents for Consent Mode
+ */
+interface GoogleConsents {
+    analytics_storage?: ConsentValue;
+    ad_storage?: ConsentValue;
+    ad_user_data?: ConsentValue;
+    ad_personalization?: ConsentValue;
+}
+/**
+ * Consent value for Google Consent Mode
+ */
+type ConsentValue = 'granted' | 'denied';
+/**
+ * GDPR Privacy values
+ * Contains the user's consent state for analytics and advertising tracking
+ */
+interface GdprPrivacyValue {
+    analytics: string;
+    advertising: string;
+}
+
+declare const _default: {
+    page: (event?: string, properties?: Record<string, unknown>, context?: AnalyticsOptions, callback?: AnalyticsCallback) => Promise<void>;
+    identify: (userIdParam: string | number, traits?: Record<string, unknown>, options?: AnalyticsOptions, callback?: AnalyticsCallback) => Promise<void>;
+    track: (event: string, properties?: Record<string, unknown>, context?: AnalyticsOptions, callback?: AnalyticsCallback) => Promise<void>;
+    reset: () => Promise<void>;
+};
+
+/**
+ * Middleware types for source and destination middlewares
+ */
+
+/**
+ * Source middleware parameters
+ */
+interface SourceMiddlewareParams {
+    payload: MiddlewarePayload;
+    next: (payload: MiddlewarePayload | null) => void;
+    integrations: IntegrationsObject;
+}
+/**
+ * Destination middleware parameters
+ */
+interface DestinationMiddlewareParams {
+    payload: MiddlewarePayload;
+    next: (payload: MiddlewarePayload | null) => void;
+    integration: string;
+}
+/**
+ * User traits for middleware
+ */
+interface UserTraits {
+    email?: string;
+    name?: string;
+    userId?: string | number;
+    [key: string]: unknown;
+}
+/**
+ * Screen information for middleware
+ */
+interface ScreenInfo {
+    width: number;
+    height: number;
+    density: number;
+}
+/**
+ * Page data for middleware
+ */
+interface PageData {
+    path: string;
+    referrer: string;
+    search: string;
+    title: string;
+    url: string;
+}
+/**
+ * Context properties that can be added by middlewares
+ */
+interface DefaultContextProperties {
+    platform: string;
+    clientVersion: string;
+    gdpr_privacy?: string;
+    gdpr_privacy_advertising?: string;
+    analytics_storage?: string;
+    google_consents?: {
+        analytics_storage?: string;
+        ad_storage?: string;
+        ad_user_data?: string;
+        ad_personalization?: string;
+    };
+    [key: string]: unknown;
+}
+/**
+ * Middleware context enhancement function
+ */
+type ContextEnhancer = (context: ContextObject) => ContextObject | Promise<ContextObject>;
+
+/**
+ * Configuration types for segment-wrapper
+ */
+/**
+ * Segment Wrapper configuration object
+ */
+interface SegmentWrapperConfig {
+    /**
+     * Google Analytics Measurement ID (e.g., G-XXXXXXXXXX)
+     */
+    googleAnalyticsMeasurementId?: string;
+    /**
+     * Google Analytics data layer name (default: 'dataLayer')
+     */
+    googleAnalyticsDataLayer?: string;
+    /**
+     * Google Analytics additional config
+     */
+    googleAnalyticsConfig?: Record<string, unknown>;
+    /**
+     * Enable Google Analytics Consent Management
+     */
+    googleAnalyticsConsentManagement?: boolean;
+    /**
+     * User ID prefix to prepend to all user identifications
+     */
+    userIdPrefix?: string;
+    /**
+     * Default properties to attach to all track calls
+     */
+    defaultProperties?: Record<string, unknown>;
+    /**
+     * Enable experimental page data middleware
+     */
+    experimentalPageDataMiddleware?: boolean;
+    /**
+     * Enable sending Xandr ID in external IDs
+     */
+    sendXandrId?: boolean;
+    /**
+     * Adobe Marketing Cloud Organization ID
+     */
+    adobeMarketingCloudOrgId?: string;
+    /**
+     * Custom configuration values
+     */
+    [key: string]: unknown;
+}
+/**
+ * MPI (Multi-Platform Interface) configuration structure
+ */
+interface MPIConfig {
+    segmentWrapper?: SegmentWrapperConfig;
+    [key: string]: unknown;
+}
+/**
+ * Window interface extension for MPI config
+ */
+interface WindowWithMPI extends Window {
+    __mpi?: MPIConfig;
+    gtag?: (...args: unknown[]) => void;
+    dataLayer?: unknown[];
+    google_tag_manager?: unknown;
+    __tcfapi?: (...args: unknown[]) => void;
+}
+/**
+ * Configuration keys that can be used with getConfig/setConfig
+ */
+type ConfigKey = keyof SegmentWrapperConfig;
+/**
+ * Configuration getter function type
+ */
+type ConfigGetter = {
+    (): SegmentWrapperConfig;
+    <K extends ConfigKey>(key: K): SegmentWrapperConfig[K];
+};
+/**
+ * Configuration setter function type
+ */
+type ConfigSetter = <K extends ConfigKey>(key: K, value: SegmentWrapperConfig[K]) => void;
+
+/**
+ * Repository interfaces for external integrations
+ */
+
+/**
+ * Adobe Visitor API interface
+ */
+interface AdobeVisitor {
+    getMarketingCloudVisitorID: () => string | undefined;
+    version?: string;
+}
+/**
+ * Adobe repository configuration
+ */
+interface AdobeConfig {
+    ADOBE_ORG_ID?: string;
+    DEFAULT_DEMDEX_VERSION?: string;
+    TIME_BETWEEN_RETRIES?: number;
+    TIMES_TO_RETRY?: number;
+    TRACKING_SERVER?: string;
+}
+/**
+ * Adobe visitor data
+ */
+interface AdobeVisitorData$1 {
+    trackingServer?: string;
+    version?: string;
+}
+/**
+ * Google Analytics fields
+ */
+interface GoogleAnalyticsFields {
+    client_id?: string;
+    session_id?: string;
+}
+/**
+ * Google Tag Manager data layer
+ */
+type DataLayer = unknown[];
+/**
+ * Google gtag function
+ */
+type GtagFunction = (...args: unknown[]) => void;
+/**
+ * Consent state value (numeric)
+ */
+type ConsentStateValue = 1 | 2;
+/**
+ * Google Consent Mode command types
+ */
+type ConsentCommand = 'default' | 'update';
+/**
+ * Xandr ID value
+ */
+type XandrId = string;
+/**
+ * Options for getting Xandr ID
+ */
+interface GetXandrIdOptions {
+    gdprPrivacyValueAdvertising?: string;
+}
+/**
+ * Options for getting campaign details
+ */
+interface GetCampaignDetailsOptions {
+    needsTransformation?: boolean;
+}
+/**
+ * STC (Schibsted Tracking Code) structure
+ */
+interface STCParams {
+    medium: string | null;
+    source: string | null;
+    campaign: string | null;
+    content?: string | null;
+    term?: string | null;
+    id?: string | null;
+}
+/**
+ * Google repository interface
+ */
+interface GoogleRepository {
+    loadGoogleAnalytics: () => Promise<boolean>;
+    getGoogleClientId: () => Promise<string>;
+    getGoogleSessionId: () => Promise<string>;
+    setGoogleUserId: (userId: string | number) => void;
+    getCampaignDetails: (options?: GetCampaignDetailsOptions) => CampaignDetails;
+    sendGoogleConsents: (command: ConsentCommand, consents?: GoogleConsents) => void;
+    getConsentState: () => ConsentStateValue | undefined;
+    getGoogleConsentValue: (consentType: keyof GoogleConsents) => ConsentValue | undefined;
+}
+/**
+ * Adobe repository interface
+ */
+interface AdobeRepository {
+    getAdobeMCVisitorID: () => Promise<string>;
+    getAdobeVisitorData: () => Promise<AdobeVisitorData$1>;
+    getAdobeMarketingCloudVisitorIdFromWindow: () => Promise<string>;
+}
+/**
+ * Xandr repository interface
+ */
+interface XandrRepository {
+    getXandrId: (options?: GetXandrIdOptions) => Promise<XandrId>;
+}
+/**
+ * Window interface extension for segment wrapper globals
+ */
+interface WindowWithSegmentWrapper extends Window {
+    __SEGMENT_WRAPPER?: {
+        ADOBE_ORG_ID?: string;
+        DEFAULT_DEMDEX_VERSION?: string;
+        TIME_BETWEEN_RETRIES?: number;
+        TIMES_TO_RETRY?: number;
+        TRACKING_SERVER?: string;
+    };
+    Visitor?: {
+        getInstance: (orgId: string, servers?: {
+            trackingServer?: string;
+            trackingServerSecure?: string;
+        }) => AdobeVisitor;
+    };
+}
+
+/**
+ * Utility types
+ */
+/**
+ * Cookie options
+ */
+interface CookieOptions {
+    domain?: string;
+    path?: string;
+    expires?: Date | string | number;
+    maxAge?: number;
+    secure?: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+}
+/**
+ * Storage type
+ */
+type StorageType = 'localStorage' | 'sessionStorage';
+/**
+ * Storage interface
+ */
+interface Storage {
+    getItem: (key: string) => string | null;
+    setItem: (key: string, value: string) => void;
+    removeItem: (key: string) => void;
+    clear: () => void;
+}
+/**
+ * Anonymous ID check result
+ */
+interface AnonymousIdCheckResult {
+    anonymousId: string;
+    isNew: boolean;
+}
+/**
+ * Email hash algorithm
+ */
+type HashAlgorithm = 'sha256' | 'md5';
+/**
+ * Hashed email result
+ */
+interface HashedEmail {
+    value: string;
+    algorithm: HashAlgorithm;
+}
+
+/**
+ * TCF (Transparency & Consent Framework) types
+ */
+/**
+ * TCF API version
+ */
+type TCFApiVersion = 2;
+/**
+ * User GDPR consent state
+ */
+declare enum UserGDPR {
+    ACCEPTED = "accepted",
+    DECLINED = "declined",
+    UNKNOWN = "unknown"
+}
+/**
+ * GDPR Privacy value per category
+ */
+interface GDPRPrivacyValue {
+    analytics?: UserGDPR;
+    advertising?: UserGDPR;
+}
+/**
+ * TCF events
+ */
+declare enum TCFEvents {
+    LOADED = "tcloaded",
+    USER_ACTION_COMPLETE = "useractioncomplete"
+}
+/**
+ * TCF data structure from CMP
+ */
+interface TCData {
+    tcString?: string;
+    tcfPolicyVersion?: number;
+    cmpId?: number;
+    cmpVersion?: number;
+    gdprApplies?: boolean;
+    eventStatus: string;
+    cmpStatus?: string;
+    listenerId?: number;
+    isServiceSpecific?: boolean;
+    useNonStandardStacks?: boolean;
+    publisherCC?: string;
+    purposeOneTreatment?: boolean;
+    outOfBand?: {
+        allowedVendors?: Record<string, boolean>;
+        disclosedVendors?: Record<string, boolean>;
+    };
+    purpose?: {
+        consents?: Record<number, boolean>;
+        legitimateInterests?: Record<number, boolean>;
+    };
+    vendor?: {
+        consents?: Record<number, boolean>;
+        legitimateInterests?: Record<number, boolean>;
+    };
+    specialFeatureOptins?: Record<number, boolean>;
+    publisher?: {
+        consents?: Record<number, boolean>;
+        legitimateInterests?: Record<number, boolean>;
+        customPurpose?: {
+            consents?: Record<number, boolean>;
+            legitimateInterests?: Record<number, boolean>;
+        };
+        restrictions?: Record<string, Record<number, number>>;
+    };
+}
+/**
+ * TCF API callback
+ */
+type TCFCallback = (tcData: TCData, success: boolean) => void;
+/**
+ * TCF API command types
+ */
+type TCFCommand = 'addEventListener' | 'removeEventListener' | 'getTCData' | 'ping';
+/**
+ * TCF API function
+ */
+type TCFApi = (command: string, version: number, callback: TCFCallback, parameter?: unknown) => void;
+/**
+ * GDPR state manager
+ */
+interface GDPRState {
+    listeners: Array<(value: GDPRPrivacyValue) => void>;
+    value?: GDPRPrivacyValue;
+    addListener: (callback: (value: GDPRPrivacyValue) => void) => void;
+    get: () => GDPRPrivacyValue | undefined;
+    set: (value: GDPRPrivacyValue) => void;
+}
+/**
+ * Needed purposes for different tracking categories
+ */
+interface NeededPurposes {
+    analytics: number[];
+    advertising: number[];
+}
+/**
+ * Boros TCF cookie structure
+ */
+interface BorosTcfCookie {
+    uuid?: string;
+    created?: string;
+    version?: string;
+    [key: string]: unknown;
+}
+
+/**
+ * Universal ID types
+ */
+/**
+ * Universal ID data structure
+ */
+interface UniversalIdData {
+    universalId?: string;
+    email?: string;
+    hashedEmail?: string;
+    timestamp?: number;
+}
+/**
+ * Universal ID listener callback
+ */
+type UniversalIdListener = (data: UniversalIdData) => void;
+/**
+ * Universal ID event detail
+ */
+interface UniversalIdEventDetail {
+    universalId?: string;
+    hashedEmail?: string;
+}
+/**
+ * Universal ID custom event
+ */
+interface UniversalIdEvent extends CustomEvent {
+    detail: UniversalIdEventDetail;
+}
+
+/**
+ * Configuration module for segment-wrapper
+ */
+
+/**
+ * Check if code is running in a browser environment
+ */
+declare const isClient: boolean;
+/**
+ * Get the Segment Wrapper config from window.
+ * Can be called with no arguments to get the full config object,
+ * or with a key to get a specific config value.
+ *
+ * @example
+ * // Get full config
+ * const config = getConfig()
+ *
+ * @example
+ * // Get specific value
+ * const measurementId = getConfig('googleAnalyticsMeasurementId')
+ */
+declare function getConfig(): SegmentWrapperConfig;
+declare function getConfig<K extends ConfigKey>(key: K): SegmentWrapperConfig[K];
+/**
+ * Set a config value to the Segment Wrapper config
+ *
+ * @param key - Config key to update
+ * @param value - Value to set on the config key
+ *
+ * @example
+ * setConfig('googleAnalyticsMeasurementId', 'G-XXXXXXXXXX')
+ */
+declare const setConfig: <K extends ConfigKey>(key: K, value: SegmentWrapperConfig[K]) => void;
+/**
+ * Initialize segment wrapper configuration
+ *
+ * @param config - Configuration object to set
+ *
+ * @example
+ * initConfig({
+ *   googleAnalyticsMeasurementId: 'G-XXXXXXXXXX',
+ *   userIdPrefix: 'user_'
+ * })
+ */
+declare const initConfig: (config: Partial<SegmentWrapperConfig>) => void;
+/**
+ * Clear all segment wrapper configuration
+ */
+declare const clearConfig: () => void;
+
+/**
+ * Event constants used throughout the segment wrapper
+ */
+declare const EVENTS: {
+    readonly GA4_INIT_EVENT_SENT: "ga4InitEventSent";
+};
+
+/**
+ * Adobe Analytics Repository
+ * Handles Adobe Marketing Cloud Visitor ID integration
+ */
+interface AdobeGlobalConfig {
+    ADOBE_ORG_ID?: string;
+    DEFAULT_DEMDEX_VERSION: string;
+    TIME_BETWEEN_RETRIES: number;
+    TIMES_TO_RETRY: number;
+    SERVERS: {
+        trackingServer?: string;
+        trackingServerSecure?: string;
+    };
+}
+interface DemdexInstance {
+    getMarketingCloudVisitorID: () => string | undefined;
+    version?: string;
+}
+interface AdobeVisitorData {
+    trackingServer?: string;
+    version: string;
+}
+declare global {
+    interface Window {
+        __SEGMENT_WRAPPER?: {
+            ADOBE_ORG_ID?: string;
+            DEFAULT_DEMDEX_VERSION?: string;
+            TIME_BETWEEN_RETRIES?: number;
+            TIMES_TO_RETRY?: number;
+            TRACKING_SERVER?: string;
+        };
+        Visitor?: {
+            getInstance: (orgId: string, servers: AdobeGlobalConfig['SERVERS']) => DemdexInstance;
+        };
+    }
+}
+/**
+ * Get Adobe Visitor Data including tracking server and version
+ */
+declare const getAdobeVisitorData: () => Promise<AdobeVisitorData>;
+/**
+ * Get Adobe Marketing Cloud Visitor ID
+ * Can use custom getter, import visitor API, or get from window
+ */
+declare const getAdobeMCVisitorID: () => Promise<string | undefined>;
+
+/**
+ * Get Universal ID
+ * Attempts to get it from config, or generates it from user email
+ */
+declare const getUniversalId: () => string | undefined;
+
+/**
+ * Google Analytics Repository
+ * Handles Google Analytics 4 integration and Consent Mode
+ */
+
+declare const CONSENT_STATES: {
+    granted: "granted";
+    denied: "denied";
+};
+declare global {
+    interface Window {
+        gtag?: (...args: unknown[]) => void;
+        google_tag_data?: {
+            ics?: {
+                getConsentState?: (consentType: string) => number | undefined;
+            };
+        };
+    }
+}
+
+/**
+ * Anonymous ID checking utility
+ */
+/**
+ * Check and reset anonymous ID if it matches the "no consents" placeholder
+ *
+ * This function checks if the user's anonymous ID is set to a placeholder value
+ * used when the user hasn't given consent. If it matches, it resets the ID to null
+ * so Segment can generate a new proper anonymous ID.
+ *
+ * @example
+ * // Call after analytics is ready
+ * window.analytics.ready(checkAnonymousId)
+ */
+declare const checkAnonymousId: () => void;
+
+/**
+ * Cookie utilities for segment-wrapper
+ */
+/**
+ * Read a cookie value by name
+ *
+ * @param cookieName - The name of the cookie to read
+ * @returns The cookie value or null if not found
+ *
+ * @example
+ * const value = readCookie('session_id')
+ */
+declare function readCookie(cookieName: string): string | null;
+/**
+ * Save a cookie with the given name and data
+ *
+ * @param cookieName - The name of the cookie
+ * @param data - The data to store in the cookie
+ * @param options - Cookie options
+ *
+ * @example
+ * saveCookie('user_id', '12345', { maxAge: 86400, sameSite: 'Strict' })
+ */
+declare function saveCookie(cookieName: string, data: string, options?: {
+    maxAge?: number;
+    path?: string;
+    reduceDomain?: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+}): void;
+/**
+ * Remove a cookie by name
+ *
+ * @param cookieName - The name of the cookie to remove
+ * @param options - Cookie options (path, domain, sameSite)
+ *
+ * @example
+ * removeCookie('session_id')
+ */
+declare function removeCookie(cookieName: string, options?: {
+    path?: string;
+    reduceDomain?: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+}): void;
+/**
+ * Reduces the domain to main domain name
+ * Examples:
+ *   - www.mywebpage.es -> .mywebpage.es
+ *   - www.my.newwebpage.net -> .newwebpage.net
+ *   - www.mywebpage.co.uk -> .mywebpage.co.uk
+ *
+ * @param domain - The domain to reduce (defaults to current hostname)
+ * @returns Dot + main domain
+ */
+declare const toCookieDomain: (domain?: string) => string;
+
+/**
+ * Email hashing utilities
+ */
+/**
+ * Normalize email by lowering case and extracting + and . symbols for gmail
+ *
+ * @param email - Email to normalize
+ * @returns Normalized email. If not valid, returns an empty string
+ *
+ * @example
+ * normalizeEmail('User.Name+tag@Gmail.com')
+ * // Returns: 'username@gmail.com'
+ */
+declare function normalizeEmail(email: string): string;
+/**
+ * Create a Universal ID from an email using SHA256 hashing
+ *
+ * @param email - Email to hash
+ * @returns SHA256 hash of normalized email, or empty string if invalid
+ *
+ * @example
+ * createUniversalId('user@example.com')
+ * // Returns: 'b4c9a289323b21a01c3e940f150eb9b8c542587f1abfd8f0e1cc1ffc5e475514'
+ */
+declare function createUniversalId(email: string): string;
+/**
+ * Hash an email using MD5
+ *
+ * @param email - Email to hash
+ * @returns MD5 hash of normalized email, or empty string if invalid
+ *
+ * @example
+ * hashEmail('user@example.com')
+ * // Returns: '5f4dcc3b5aa765d61d8327deb882cf99'
+ */
+declare function hashEmail(email: string): string;
+
+/**
+ * Storage utilities for localStorage and sessionStorage
+ */
+
+type StorageMethod = 'getItem' | 'setItem' | 'removeItem';
+interface StorageParams {
+    /** Storage type to use */
+    type?: StorageType;
+    /** Method to call on the storage */
+    method?: StorageMethod;
+    /** Key to store/retrieve */
+    key: string;
+    /** Value to store (only for setItem) */
+    value?: string;
+}
+/**
+ * Use this function to store and retrieve data from localStorage or sessionStorage
+ *
+ * @param params - Storage parameters
+ * @returns The value from getItem, or void for setItem/removeItem
+ *
+ * @example
+ * // Get item
+ * const value = storage({ key: 'user_id' })
+ *
+ * @example
+ * // Set item
+ * storage({ key: 'user_id', value: '12345', method: 'setItem' })
+ *
+ * @example
+ * // Remove item
+ * storage({ key: 'user_id', method: 'removeItem' })
+ *
+ * @example
+ * // Use sessionStorage
+ * const value = storage({ type: 'sessionStorage', key: 'temp_data' })
+ */
+declare const storage: ({ type, method, key, value }: StorageParams) => string | null | void;
+/**
+ * Get an item from storage
+ */
+declare const getStorageItem: (key: string, type?: StorageType) => string | null;
+/**
+ * Set an item in storage
+ */
+declare const setStorageItem: (key: string, value: string, type?: StorageType) => void;
+/**
+ * Remove an item from storage
+ */
+declare const removeStorageItem: (key: string, type?: StorageType) => void;
+
+/**
+ * @adv-re/segment-wrapper
+ *
+ * Modern TypeScript abstraction layer on top of the Segment Analytics library.
+ */
+
+export { type AdobeConfig, type AdobeRepository, type AdobeVisitor, type AdobeVisitorData$1 as AdobeVisitorData, type AnalyticsCallback, type GdprPrivacyValue as AnalyticsGdprPrivacyValue, type AnalyticsOptions, type AnonymousIdCheckResult, type BorosTcfCookie, CONSENT_STATES, type CampaignDetails, type ConfigGetter, type ConfigKey, type ConfigSetter, type ConsentCommand, type ConsentStateValue, type ConsentValue, type ContextEnhancer, type ContextObject, type CookieOptions, type DataLayer, type DefaultContextProperties, type DestinationMiddlewareFunction, type DestinationMiddlewareParams, EVENTS, type ExternalId, type GDPRPrivacyValue, type GDPRState, type GetCampaignDetailsOptions, type GetXandrIdOptions, type GoogleAnalyticsFields, type GoogleConsents, type GoogleRepository, type GtagFunction, type HashAlgorithm, type HashedEmail, type IntegrationsObject, type MPIConfig, type MiddlewarePayload, type NeededPurposes, type PageContext, type PageData, type STCParams, type ScreenInfo, type SegmentAnalytics, type SegmentUser, type SegmentWrapperConfig, type SourceMiddlewareFunction, type SourceMiddlewareParams, type Storage, type StorageType, type TCData, type TCFApi, type TCFApiVersion, type TCFCallback, type TCFCommand, TCFEvents, type UniversalIdData, type UniversalIdEvent, type UniversalIdEventDetail, type UniversalIdListener, UserGDPR, type UserTraits, type WindowWithMPI, type WindowWithSegmentWrapper, type XandrId, type XandrRepository, checkAnonymousId, clearConfig, createUniversalId, _default as default, getAdobeMCVisitorID, getAdobeVisitorData, getConfig, getStorageItem, getUniversalId, hashEmail, initConfig, isClient, normalizeEmail, readCookie, removeCookie, removeStorageItem, saveCookie, setConfig, setStorageItem, storage, toCookieDomain };