@ninetailed/experience.js 7.5.3 → 7.6.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ninetailed/experience.js",
-  "version": "7.5.3",
+  "version": "7.6.0-beta.2",
   "description": "Ninetailed SDK for javascript",
   "license": "MIT",
   "repository": {
@@ -8,15 +8,12 @@
     "url": "https://github.com/ninetailed-inc/experience.js.git",
     "directory": "packages/sdks/javascript"
   },
-  "module": "./index.js",
-  "main": "./index.cjs",
-  "type": "module",
-  "types": "./src/index.d.ts",
   "dependencies": {
-    "@jest/globals": "27.5.1",
-    "@ninetailed/experience.js-shared": "7.5.3",
     "analytics": "0.8.1",
-    "zod": "3.21.4"
+    "@ninetailed/experience.js-plugin-analytics": "*",
+    "@ninetailed/experience.js-shared": "*",
+    "uuid": "9.0.0"
   },
-  "peerDependencies": {}
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js"
 }

package/src/index.d.ts

@@ -1,5 +1,5 @@
 export * from './lib/constants';
-export * from './lib/ninetailedCorePlugin';
+export * from './lib/NinetailedCorePlugin';
 export * from './lib/Ninetailed';
 export * from './lib/selectVariant';
 export * from './lib/types';

package/src/lib/ElementSeenObserver.d.ts

@@ -1,5 +1,5 @@
 export type ElementSeenObserverOptions = {
-    onElementSeen: (element: Element) => void;
+    onElementSeen: (element: Element, delay?: number) => void;
 };
 export type ObserveOptions = {
     delay?: number;

package/src/lib/Ninetailed.d.ts

@@ -1,8 +1,11 @@
 /// <reference types="analytics" />
-import { Locale, Traits, OnLogHandler, OnErrorHandler, Logger, PageviewProperties, Properties, NinetailedApiClient, NinetailedApiClientOptions, NinetailedRequestContext } from '@ninetailed/experience.js-shared';
-import { OnInitProfileId } from './ninetailedCorePlugin';
-import { EventFunctionOptions, NinetailedInstance, NinetailedPlugin, OnIsInitializedCallback, OnProfileChangeCallback, ProfileState, TrackHasSeenComponent, ElementSeenPayload, TrackComponentView } from './types';
+import { Locale, Traits, OnLogHandler, OnErrorHandler, Logger, PageviewProperties, Properties, NinetailedApiClient, NinetailedApiClientOptions, NinetailedRequestContext, Reference, Event } from '@ninetailed/experience.js-shared';
+import { OnInitProfileId } from './NinetailedCorePlugin';
+import { EventFunctionOptions, NinetailedInstance, OnIsInitializedCallback, OnProfileChangeCallback, ProfileState, TrackHasSeenComponent, TrackComponentView } from './types';
 import { ObserveOptions } from './ElementSeenObserver';
+import { OnSelectVariantArgs, OnSelectVariantCallback } from './types/OnSelectVariant';
+import { ElementSeenPayload, NinetailedPlugin } from '@ninetailed/experience.js-plugin-analytics';
+import { EventBuilder } from './utils/EventBuilder';
 declare global {
     interface Window {
         ninetailed?: {
@@ -32,6 +35,7 @@ type Options = {
     onInitProfileId?: OnInitProfileId;
     buildClientContext?: () => NinetailedRequestContext;
     storageImpl?: Storage;
+    useClientSideEvaluation?: boolean;
 };
 type NinetailedApiClientInstanceOrOptions = NinetailedApiClient | NinetailedApiClientOptions;
 export declare class Ninetailed implements NinetailedInstance {
@@ -47,22 +51,32 @@ export declare class Ninetailed implements NinetailedInstance {
     readonly plugins: NinetailedPlugin[];
     readonly logger: Logger;
     private readonly componentViewTrackingThreshold;
-    constructor(ninetailedApiClientInstanceOrOptions: NinetailedApiClientInstanceOrOptions, { plugins, url, locale, requestTimeout, onLog, onError, buildClientContext, onInitProfileId, componentViewTrackingThreshold, storageImpl, }?: Options);
+    private readonly useClientSideEvaluation;
+    readonly eventBuilder: EventBuilder;
+    constructor(ninetailedApiClientInstanceOrOptions: NinetailedApiClientInstanceOrOptions, { plugins, url, locale, requestTimeout, onLog, onError, buildClientContext, onInitProfileId, componentViewTrackingThreshold, storageImpl, useClientSideEvaluation, }?: Options);
     page: (data?: Partial<PageviewProperties>, options?: EventFunctionOptions) => Promise<import("./types").FlushResult>;
     track: (event: string, properties?: Properties, options?: EventFunctionOptions) => Promise<import("./types").FlushResult>;
+    identify: (uid: string, traits?: Traits, options?: EventFunctionOptions) => Promise<import("./types").FlushResult>;
+    batch: (events: Event[]) => Promise<import("./types").FlushResult>;
+    trackStickyComponentView: ({ experienceId, componentId, variantIndex, }: {
+        experienceId: string;
+        componentId: string;
+        variantIndex: number;
+    }) => Promise<import("./types").FlushResult>;
     /**
      * @deprecated The legacy datamodel is not recommended anymore
      * Will be removed in the next version of the SDK
      */
     trackHasSeenComponent: TrackHasSeenComponent;
     trackComponentView: TrackComponentView;
+    private get pluginsWithCustomComponentViewThreshold();
     observeElement: (payload: ElementSeenPayload, options?: ObserveOptions) => void;
     unobserveElement: (element: Element) => void;
     private onElementSeen;
-    identify: (uid: string, traits?: Traits, options?: EventFunctionOptions) => Promise<import("./types").FlushResult>;
     reset: () => Promise<void>;
     debug: (enabled: boolean) => Promise<void>;
     onProfileChange: (cb: OnProfileChangeCallback) => import("analytics").DetachListeners;
+    onSelectVariant: <Baseline extends Reference, Variant extends Reference>({ baseline, experiences }: OnSelectVariantArgs<Baseline, Variant>, cb: OnSelectVariantCallback<Baseline, Variant>) => () => void;
     onIsInitialized: (onIsInitialized: OnIsInitializedCallback) => void;
     private waitUntilInitialized;
     get profileState(): ProfileState;

package/src/lib/NinetailedCorePlugin/NinetailedCorePlugin.d.ts

@@ -0,0 +1,69 @@
+import { AnalyticsInstance } from 'analytics';
+import { Locale, NinetailedApiClient, NinetailedRequestContext } from '@ninetailed/experience.js-shared';
+import { NinetailedAnalyticsPlugin, NinetailedPlugin, SanitizedElementSeenPayload } from '@ninetailed/experience.js-plugin-analytics';
+import { NinetailedInstance, FlushResult } from '../types';
+import { HAS_SEEN_STICKY_COMPONENT } from '../constants';
+import { HasComponentViewTrackingThreshold } from '../types/interfaces/HasComponentViewTrackingThreshold';
+export type OnInitProfileId = (profileId?: string) => Promise<string | undefined> | string | undefined;
+type AnalyticsPluginNinetailedConfig = {
+    apiClient: NinetailedApiClient;
+    locale?: Locale;
+    requestTimeout?: number;
+    onInitProfileId?: OnInitProfileId;
+    buildClientContext?: () => NinetailedRequestContext;
+    ninetailed: NinetailedInstance;
+};
+export declare const PLUGIN_NAME = "ninetailed:core";
+type EventFn = {
+    payload: any;
+    instance: InternalAnalyticsInstance;
+};
+type AbortableFnParams = {
+    abort: () => void;
+    payload: unknown;
+};
+type InternalAnalyticsInstance = AnalyticsInstance & {
+    dispatch: (action: any) => void;
+};
+export interface NinetailedCorePlugin extends NinetailedPlugin {
+    flush: (args: void) => Promise<FlushResult>;
+}
+export declare class NinetailedCorePlugin extends NinetailedAnalyticsPlugin implements NinetailedCorePlugin, HasComponentViewTrackingThreshold {
+    name: string;
+    private _instance?;
+    private queue;
+    private enabledFeatures;
+    private readonly buildContext;
+    private readonly onInitProfileId?;
+    private readonly apiClient;
+    private readonly locale?;
+    private readonly ninetailed;
+    constructor({ apiClient, locale, ninetailed, onInitProfileId, buildClientContext, }: AnalyticsPluginNinetailedConfig);
+    initialize({ instance, }: {
+        instance: InternalAnalyticsInstance;
+    }): Promise<void>;
+    pageStart(params: AbortableFnParams): unknown;
+    page({ payload }: EventFn): Promise<void>;
+    trackStart(params: AbortableFnParams): unknown;
+    track({ payload }: EventFn): Promise<void>;
+    identifyStart(params: AbortableFnParams): unknown;
+    identify({ payload }: EventFn): Promise<void>;
+    getComponentViewTrackingThreshold(): number;
+    protected onTrackExperience(properties: SanitizedElementSeenPayload): Promise<void>;
+    protected onTrackComponent(): Promise<void>;
+    [HAS_SEEN_STICKY_COMPONENT]: ({ payload }: EventFn) => Promise<void>;
+    setItemStart({ abort, payload }: {
+        abort: any;
+        payload: any;
+    }): any;
+    methods: {
+        reset: (...args: any[]) => Promise<void>;
+        debug: (...args: any[]) => Promise<void>;
+    };
+    private enqueueEvent;
+    private abortNonClientEvents;
+    private get instance();
+    flush: (args: void) => Promise<FlushResult>;
+    private _flush;
+}
+export {};

package/src/lib/{ninetailedCorePlugin → NinetailedCorePlugin}/index.d.ts

@@ -1,3 +1,3 @@
-export * from './ninetailedCorePlugin';
+export * from './NinetailedCorePlugin';
 export * from './constants';
 export * from './Events';

package/src/lib/constants.d.ts

@@ -1,5 +1,4 @@
-export declare const HAS_SEEN_COMPONENT = "has_seen_component";
-export declare const HAS_SEEN_ELEMENT = "has_seen_element";
 export declare const COMPONENT = "component";
 export declare const COMPONENT_START = "componentStart";
 export declare const PAGE_HIDDEN = "page_hidden";
+export declare const HAS_SEEN_STICKY_COMPONENT = "sticky_component_view";

package/src/lib/experience/makeExperienceSelectMiddleware.d.ts

@@ -1,19 +1,19 @@
-import { ExperienceConfiguration, Profile, Reference, VariantRef } from '@ninetailed/experience.js-shared';
-import { NinetailedPlugin } from '../types/NinetailedPlugin';
-import { ExperienceSelectionMiddlewareReturnArg } from '../types/interfaces/HasExperienceSelectionMiddleware';
-type MakeExperienceSelectMiddlewareArg<Variant extends Reference> = {
+import { ExperienceConfiguration, Profile, Reference } from '@ninetailed/experience.js-shared';
+import { NinetailedPlugin } from '@ninetailed/experience.js-plugin-analytics';
+import { ExperienceSelectionMiddleware, ExperienceSelectionMiddlewareArg } from '../types/interfaces/HasExperienceSelectionMiddleware';
+type MakeExperienceSelectMiddlewareArg<Baseline extends Reference, Variant extends Reference> = {
     plugins: NinetailedPlugin[];
     experiences: ExperienceConfiguration<Variant>[];
     baseline: Reference;
     profile: Profile | null;
-    onChange: () => void;
+    onChange: (middleware: ExperienceSelectionMiddleware<Baseline, Variant>) => void;
 };
-export declare const makeExperienceSelectMiddleware: <Variant extends Reference>({ plugins, onChange, experiences, baseline, profile, }: MakeExperienceSelectMiddlewareArg<Variant>) => {
+export declare const makeExperienceSelectMiddleware: <TBaseline extends Reference, TVariant extends Reference>({ plugins, onChange, experiences, baseline, profile, }: MakeExperienceSelectMiddlewareArg<TBaseline, TVariant>) => {
     addListeners: () => void;
     removeListeners: () => void;
-    middleware: ({ experience, variant, variantIndex, }: ExperienceSelectionMiddlewareReturnArg<Variant | VariantRef>) => {
-        experience: ExperienceConfiguration<Variant | VariantRef> | null;
-        variant: Variant | VariantRef;
+    middleware: ({ experience, variant, variantIndex, }: ExperienceSelectionMiddlewareArg<TBaseline, TVariant>) => {
+        experience: ExperienceConfiguration<TVariant> | null;
+        variant: TBaseline | TVariant | import("@ninetailed/experience.js-shared").VariantRef;
         variantIndex: number;
     };
 };

package/src/lib/guards/hasComponentViewTrackingThreshold.d.ts

@@ -0,0 +1,3 @@
+import { NinetailedPlugin } from '@ninetailed/experience.js-plugin-analytics';
+import type { HasComponentViewTrackingThreshold } from '../types/interfaces/HasComponentViewTrackingThreshold';
+export declare const hasComponentViewTrackingThreshold: (arg: NinetailedPlugin) => arg is NinetailedPlugin & HasComponentViewTrackingThreshold;

package/src/lib/guards/hasExperienceSelectionMiddleware.d.ts

@@ -1,3 +1,3 @@
 import { Reference } from '@ninetailed/experience.js-shared';
 import { HasExperienceSelectionMiddleware } from '../types/interfaces/HasExperienceSelectionMiddleware';
-export declare const hasExperienceSelectionMiddleware: <Variant extends Reference>(arg: unknown) => arg is HasExperienceSelectionMiddleware<Variant>;
+export declare const hasExperienceSelectionMiddleware: <TBaseline extends Reference, TVariant extends Reference>(arg: unknown) => arg is HasExperienceSelectionMiddleware<TBaseline, TVariant>;

package/src/lib/plugins/selectPluginsHavingExperienceSelectionMiddleware.d.ts

@@ -1,4 +1,4 @@
 import { Reference } from '@ninetailed/experience.js-shared';
+import { NinetailedPlugin } from '@ninetailed/experience.js-plugin-analytics';
 import { HasExperienceSelectionMiddleware } from '../types/interfaces/HasExperienceSelectionMiddleware';
-import { NinetailedPlugin } from '../types/NinetailedPlugin';
-export declare const selectPluginsHavingExperienceSelectionMiddleware: <Variant extends Reference>(plugins: NinetailedPlugin[]) => HasExperienceSelectionMiddleware<Variant>[];
+export declare const selectPluginsHavingExperienceSelectionMiddleware: <Baseline extends Reference, Variant extends Reference>(plugins: NinetailedPlugin[]) => HasExperienceSelectionMiddleware<Baseline, Variant>[];

package/src/lib/plugins/selectPluginsHavingOnChangeEmitter.d.ts

@@ -1,3 +1,3 @@
-import { NinetailedPlugin } from '../types/NinetailedPlugin';
+import { NinetailedPlugin } from '@ninetailed/experience.js-plugin-analytics';
 import { HasOnChangeEmitter } from '../types/interfaces/HasOnChangeEmitter';
 export declare const selectPluginsHavingOnChangeEmitter: (plugins: NinetailedPlugin[]) => HasOnChangeEmitter[];

package/src/lib/types/OnSelectVariant.d.ts

@@ -0,0 +1,51 @@
+import { Profile, ExperienceConfiguration, Reference, VariantRef } from '@ninetailed/experience.js-shared';
+import type { DetachListeners } from 'analytics';
+type Loading<TBaseline extends Reference> = {
+    status: 'loading';
+    loading: boolean;
+    hasVariants: boolean;
+    baseline: TBaseline;
+    experience: null;
+    variant: TBaseline;
+    variantIndex: number;
+    audience: null;
+    isPersonalized: boolean;
+    profile: null;
+    error: null;
+};
+type Success<TBaseline extends Reference, TVariant extends Reference> = {
+    status: 'success';
+    loading: boolean;
+    hasVariants: boolean;
+    baseline: TBaseline;
+    experience: ExperienceConfiguration<TVariant> | null;
+    variant: TBaseline | TVariant | VariantRef;
+    variantIndex: number;
+    audience: {
+        id: string;
+    } | null;
+    isPersonalized: boolean;
+    profile: Profile;
+    error: null;
+};
+type Fail<TBaseline extends Reference> = {
+    status: 'error';
+    loading: boolean;
+    hasVariants: boolean;
+    baseline: TBaseline;
+    experience: null;
+    variant: TBaseline;
+    variantIndex: number;
+    audience: null;
+    isPersonalized: boolean;
+    profile: null;
+    error: Error;
+};
+export type OnSelectVariantArgs<TBaseline extends Reference, TVariant extends Reference> = {
+    baseline: TBaseline;
+    experiences: ExperienceConfiguration<TVariant>[];
+};
+export type OnSelectVariantCallbackArgs<TBaseline extends Reference, TVariant extends Reference> = Loading<TBaseline> | Success<TBaseline, TVariant> | Fail<TBaseline>;
+export type OnSelectVariantCallback<TBaseline extends Reference, TVariant extends Reference> = (state: OnSelectVariantCallbackArgs<TBaseline, TVariant>) => void;
+export type OnSelectVariant<TBaseline extends Reference = Reference, TVariant extends Reference = Reference> = (args: OnSelectVariantArgs<TBaseline, TVariant>, cb: OnSelectVariantCallback<TBaseline, TVariant>) => DetachListeners;
+export {};

package/src/lib/types/index.d.ts

@@ -1,9 +1,9 @@
-import { Logger, PageviewProperties, Profile, Properties, Traits, SelectedVariantInfo } from '@ninetailed/experience.js-shared';
 import { DetachListeners } from 'analytics';
-import { TrackComponentProperties } from './TrackingProperties';
-import { NinetailedPlugin } from './NinetailedPlugin';
+import { Logger, PageviewProperties, Profile, Properties, Traits, SelectedVariantInfo, Reference, Event } from '@ninetailed/experience.js-shared';
+import { ElementSeenPayload, NinetailedPlugin, TrackComponentProperties } from '@ninetailed/experience.js-plugin-analytics';
 import { type Ninetailed } from '../Ninetailed';
-import { ElementSeenPayload } from './ElementSeenPayload';
+import { OnSelectVariant } from './OnSelectVariant';
+import { EventBuilder } from '../utils/EventBuilder';
 type Loading = {
     status: 'loading';
     profile: null;
@@ -42,12 +42,13 @@ export type Track = (event: string, properties?: Properties, options?: EventFunc
 export type TrackHasSeenComponent = (properties: TrackComponentProperties) => Promise<void>;
 export type TrackComponentView = (properties: ElementSeenPayload) => Promise<void>;
 export type Identify = (uid: string, traits?: Traits, options?: EventFunctionOptions) => Promise<FlushResult>;
+export type Batch = (events: Event[]) => Promise<FlushResult>;
 export type Reset = () => void;
 export type Debug = (enable: boolean) => void;
 export type OnProfileChange = (cb: OnProfileChangeCallback) => DetachListeners;
 type ObserveElement = Ninetailed['observeElement'];
 type UnObserveElement = Ninetailed['unobserveElement'];
-export interface NinetailedInstance {
+export interface NinetailedInstance<TBaseline extends Reference = Reference, TVariant extends Reference = Reference> {
     page: Page;
     track: Track;
     /**
@@ -56,20 +57,19 @@ export interface NinetailedInstance {
     trackHasSeenComponent: TrackHasSeenComponent;
     trackComponentView: TrackComponentView;
     identify: Identify;
+    batch: Batch;
     reset: Reset;
     debug: Debug;
     profileState: ProfileState;
     onProfileChange: OnProfileChange;
     plugins: NinetailedPlugin[];
     logger: Logger;
+    eventBuilder: EventBuilder;
     onIsInitialized: OnIsInitialized;
     observeElement: ObserveElement;
     unobserveElement: UnObserveElement;
+    onSelectVariant: OnSelectVariant<TBaseline, TVariant>;
 }
-export { NinetailedPlugin, TrackComponentProperties };
-export type { EventHandler } from './EventHandler';
 export type { AnalyticsInstance } from './AnalyticsInstance';
-export { ElementSeenPayloadSchema } from './ElementSeenPayload';
-export type { ElementSeenPayload } from './ElementSeenPayload';
 export type { ProfileChangedPayload } from './ProfileChangedPayload';
 export type { Credentials } from './Credentials';

package/src/lib/types/interfaces/HasComponentViewTrackingThreshold.d.ts

@@ -0,0 +1,3 @@
+export interface HasComponentViewTrackingThreshold {
+    getComponentViewTrackingThreshold: () => number;
+}

package/src/lib/types/interfaces/HasExperienceSelectionMiddleware.d.ts

@@ -1,16 +1,16 @@
-import { ExperienceConfiguration, Reference } from '@ninetailed/experience.js-shared';
-export type ExperienceSelectionMiddlewareReturnArg<Variant extends Reference> = {
-    experience: ExperienceConfiguration<Variant> | null;
-    variant: Variant;
+import { ExperienceConfiguration, Reference, VariantRef } from '@ninetailed/experience.js-shared';
+export type ExperienceSelectionMiddlewareArg<TBaseline extends Reference, TVariant extends Reference> = {
+    experience: ExperienceConfiguration<TVariant> | null;
+    variant: TBaseline | TVariant | VariantRef;
     variantIndex: number;
 };
-type ExperienceSelectionMiddlewareReturn<Variant extends Reference> = (arg: ExperienceSelectionMiddlewareReturnArg<Variant>) => ExperienceSelectionMiddlewareReturnArg<Variant>;
-type ExperienceSelectionMiddlewareArg<Variant extends Reference> = {
-    experiences: ExperienceConfiguration<Variant>[];
+export type ExperienceSelectionMiddleware<TBaseline extends Reference, TVariant extends Reference> = (arg: ExperienceSelectionMiddlewareArg<TBaseline, TVariant>) => ExperienceSelectionMiddlewareArg<TBaseline, TVariant>;
+type BuildExperienceSelectionMiddlewareArg<TVariant extends Reference> = {
+    experiences: ExperienceConfiguration<TVariant>[];
     baseline: Reference;
 };
-export type ExperienceSelectionMiddleware<Variant extends Reference> = (arg: ExperienceSelectionMiddlewareArg<Variant>) => ExperienceSelectionMiddlewareReturn<Variant>;
-export interface HasExperienceSelectionMiddleware<Variant extends Reference> {
-    getExperienceSelectionMiddleware: ExperienceSelectionMiddleware<Variant>;
+export type BuildExperienceSelectionMiddleware<TBaseline extends Reference, TVariant extends Reference> = (arg: BuildExperienceSelectionMiddlewareArg<TVariant>) => ExperienceSelectionMiddleware<TBaseline, TVariant>;
+export interface HasExperienceSelectionMiddleware<TBaseline extends Reference, TVariant extends Reference> {
+    getExperienceSelectionMiddleware: BuildExperienceSelectionMiddleware<TBaseline, TVariant>;
 }
 export {};

package/src/lib/types/interfaces/InterestedInHiddenPage.d.ts

@@ -1,5 +1,5 @@
 import { PAGE_HIDDEN } from '../../constants';
-import { EventHandler } from '../EventHandler';
+import { EventHandler } from '@ninetailed/experience.js-plugin-analytics';
 export interface InterestedInHiddenPage {
     [PAGE_HIDDEN]: EventHandler<void>;
 }

package/src/lib/types/interfaces/InterestedInProfileChange.d.ts

@@ -1,5 +1,5 @@
 import { PROFILE_CHANGE } from '@ninetailed/experience.js-shared';
-import { EventHandler } from '../EventHandler';
+import { EventHandler } from '@ninetailed/experience.js-plugin-analytics';
 import { ProfileChangedPayload } from '../ProfileChangedPayload';
 export interface InterestedInProfileChange {
     [PROFILE_CHANGE]: EventHandler<ProfileChangedPayload>;

package/src/lib/types/interfaces/InterestedInSeenElements.d.ts

@@ -1,6 +1,4 @@
-import { HAS_SEEN_ELEMENT } from '../../constants';
-import { ElementSeenPayload } from '../ElementSeenPayload';
-import { EventHandler } from '../EventHandler';
+import { EventHandler, ElementSeenPayload, HAS_SEEN_ELEMENT } from '@ninetailed/experience.js-plugin-analytics';
 export interface InterestedInSeenElements {
     [HAS_SEEN_ELEMENT]: EventHandler<ElementSeenPayload>;
 }

package/src/lib/utils/EventBuilder.d.ts

@@ -0,0 +1,221 @@
+import { BuildPageEventArgs, BuildTrackEventArgs, IdentifyEventArgs, NinetailedRequestContext, Properties } from '@ninetailed/experience.js-shared';
+export declare class EventBuilder {
+    private readonly buildRequestContext;
+    constructor(buildRequestContext?: () => NinetailedRequestContext);
+    page(properties?: Properties, data?: Partial<Omit<BuildPageEventArgs, 'ctx' | 'properties'>>): {
+        channel: import("@ninetailed/experience.js-shared").EventChanel;
+        context: {
+            app?: {
+                name: string;
+                version: string;
+            } | undefined;
+            campaign: {
+                name?: string | undefined;
+                source?: string | undefined;
+                medium?: string | undefined;
+                term?: string | undefined;
+                content?: string | undefined;
+            };
+            library: {
+                name: string;
+                version: string;
+            };
+            locale: string;
+            page: {
+                path: string;
+                url: string;
+                query: Record<string, string>;
+                referrer: string;
+                search: string;
+            };
+            userAgent?: string | undefined;
+            gdpr: {
+                isConsentGiven: boolean;
+            };
+            location?: {
+                coordinates?: {
+                    latitude: number;
+                    longitude: number;
+                } | undefined;
+                city?: string | undefined;
+                postalCode?: string | undefined;
+                region?: string | undefined;
+                regionCode?: string | undefined;
+                country?: string | undefined;
+                countryCode?: string | undefined;
+                continent?: string | undefined;
+                timezone?: string | undefined;
+            } | undefined;
+        };
+        messageId: string;
+        originalTimestamp: string;
+        timestamp: string;
+        sentAt: string;
+        type: import("@ninetailed/experience.js-shared").EventType;
+        userId?: string | undefined;
+        name?: string | undefined;
+        properties: import("@ninetailed/experience.js-shared").PageviewProperties;
+    };
+    track(event: string, properties?: Properties, data?: Partial<Omit<BuildTrackEventArgs, 'ctx' | 'event' | 'properties'>>): {
+        channel: import("@ninetailed/experience.js-shared").EventChanel;
+        context: {
+            app?: {
+                name: string;
+                version: string;
+            } | undefined;
+            campaign: {
+                name?: string | undefined;
+                source?: string | undefined;
+                medium?: string | undefined;
+                term?: string | undefined;
+                content?: string | undefined;
+            };
+            library: {
+                name: string;
+                version: string;
+            };
+            locale: string;
+            page: {
+                path: string;
+                url: string;
+                query: Record<string, string>;
+                referrer: string;
+                search: string;
+            };
+            userAgent?: string | undefined;
+            gdpr: {
+                isConsentGiven: boolean;
+            };
+            location?: {
+                coordinates?: {
+                    latitude: number;
+                    longitude: number;
+                } | undefined;
+                city?: string | undefined;
+                postalCode?: string | undefined;
+                region?: string | undefined;
+                regionCode?: string | undefined;
+                country?: string | undefined;
+                countryCode?: string | undefined;
+                continent?: string | undefined;
+                timezone?: string | undefined;
+            } | undefined;
+        };
+        messageId: string;
+        originalTimestamp: string;
+        timestamp: string;
+        sentAt: string;
+        type: import("@ninetailed/experience.js-shared").EventType;
+        userId?: string | undefined;
+        event: string;
+        properties: Properties;
+    };
+    identify(userId: string, traits?: Properties, data?: Partial<Omit<IdentifyEventArgs, 'ctx' | 'userId' | 'traits'>>): {
+        channel: import("@ninetailed/experience.js-shared").EventChanel;
+        context: {
+            app?: {
+                name: string;
+                version: string;
+            } | undefined;
+            campaign: {
+                name?: string | undefined;
+                source?: string | undefined;
+                medium?: string | undefined;
+                term?: string | undefined;
+                content?: string | undefined;
+            };
+            library: {
+                name: string;
+                version: string;
+            };
+            locale: string;
+            page: {
+                path: string;
+                url: string;
+                query: Record<string, string>;
+                referrer: string;
+                search: string;
+            };
+            userAgent?: string | undefined;
+            gdpr: {
+                isConsentGiven: boolean;
+            };
+            location?: {
+                coordinates?: {
+                    latitude: number;
+                    longitude: number;
+                } | undefined;
+                city?: string | undefined;
+                postalCode?: string | undefined;
+                region?: string | undefined;
+                regionCode?: string | undefined;
+                country?: string | undefined;
+                countryCode?: string | undefined;
+                continent?: string | undefined;
+                timezone?: string | undefined;
+            } | undefined;
+        };
+        messageId: string;
+        originalTimestamp: string;
+        timestamp: string;
+        sentAt: string;
+        type: import("@ninetailed/experience.js-shared").EventType;
+        userId?: string | undefined;
+        traits: Properties;
+    };
+    component(componentId: string, experienceId?: string, variantIndex?: number, data?: Partial<Omit<BuildPageEventArgs, 'ctx' | 'componentId' | 'experienceId' | 'variantIndex'>>): {
+        channel: import("@ninetailed/experience.js-shared").EventChanel;
+        context: {
+            app?: {
+                name: string;
+                version: string;
+            } | undefined;
+            campaign: {
+                name?: string | undefined;
+                source?: string | undefined;
+                medium?: string | undefined;
+                term?: string | undefined;
+                content?: string | undefined;
+            };
+            library: {
+                name: string;
+                version: string;
+            };
+            locale: string;
+            page: {
+                path: string;
+                url: string;
+                query: Record<string, string>;
+                referrer: string;
+                search: string;
+            };
+            userAgent?: string | undefined;
+            gdpr: {
+                isConsentGiven: boolean;
+            };
+            location?: {
+                coordinates?: {
+                    latitude: number;
+                    longitude: number;
+                } | undefined;
+                city?: string | undefined;
+                postalCode?: string | undefined;
+                region?: string | undefined;
+                regionCode?: string | undefined;
+                country?: string | undefined;
+                countryCode?: string | undefined;
+                continent?: string | undefined;
+                timezone?: string | undefined;
+            } | undefined;
+        };
+        messageId: string;
+        originalTimestamp: string;
+        timestamp: string;
+        sentAt: string;
+        type: import("@ninetailed/experience.js-shared").EventType;
+        userId?: string | undefined;
+        componentId: string;
+        experienceId?: string | undefined;
+        variantIndex?: number | undefined;
+    };
+}

package/src/lib/utils/noop.d.ts

@@ -0,0 +1 @@
+export declare const noop: () => void;