@jitsu/js 1.9.7-canary.903.20240731114701 → 1.9.8

package/src/analytics-plugin.ts

@@ -1,7 +1,16 @@
 /* global analytics */
 
-import { JitsuOptions, PersistentStorage, RuntimeFacade } from "./jitsu";
-import { AnalyticsClientEvent, Callback, ID, JSONObject, Options } from "@jitsu/protocols/analytics";
+import {
+  DynamicJitsuOptions,
+  JitsuOptions,
+  PersistentStorage,
+  RuntimeFacade,
+  AnalyticsClientEvent,
+  Callback,
+  ID,
+  JSONObject,
+  Options,
+} from "@jitsu/protocols/analytics";
 import parse from "./index";
 
 import { AnalyticsInstance, AnalyticsPlugin } from "analytics";
@@ -26,6 +35,39 @@ const defaultConfig: Required<JitsuOptions> = {
   fetchTimeoutMs: undefined,
   s2s: undefined,
   idEndpoint: undefined,
+  privacy: {
+    dontSend: false,
+    disableUserIds: false,
+    ipPolicy: "keep",
+    consentCategories: undefined,
+  },
+};
+
+// mergeConfig merges newConfig into currentConfig also making sure that all undefined values are replaced with defaultConfig values
+const mergeConfig = (current: JitsuOptions, newConfig: JitsuOptions): void => {
+  for (const key of Object.keys(defaultConfig)) {
+    const value = newConfig[key];
+    if (key === "privacy") {
+      if (typeof value === "object") {
+        current.privacy = {
+          ...defaultConfig.privacy,
+          ...current.privacy,
+          ...value,
+        };
+      } else if (newConfig.hasOwnProperty("privacy") && typeof value === "undefined") {
+        // explicitly set to undefined - reset to default
+        current.privacy = { ...defaultConfig.privacy };
+      }
+    } else if (typeof value === "undefined") {
+      if (newConfig.hasOwnProperty(key) || !current.hasOwnProperty(key)) {
+        // explicitly set to undefined - reset to default
+        // or was not set at all - set to default
+        current[key] = defaultConfig[key];
+      }
+    } else {
+      current[key] = value;
+    }
+  }
 };
 
 export const parseQuery = (qs?: string): Record<string, string> => {
@@ -154,11 +196,20 @@ const defaultCookie2Key = {
   __anon_id: "__eventn_id",
   __user_traits: "__eventn_id_usr",
   __user_id: "__eventn_uid",
+  __group_id: "__group_id",
+  __group_traits: "__group_traits",
 };
 
 const cookieStorage: StorageFactory = (cookieDomain, key2cookie) => {
   return {
     setItem(key: string, val: any) {
+      if (typeof val === "undefined") {
+        removeCookie(key2cookie[key] || key, {
+          domain: cookieDomain,
+          secure: window.location.protocol === "https:",
+        });
+        return;
+      }
       const strVal = typeof val === "object" && val !== null ? encodeURIComponent(JSON.stringify(val)) : val;
       const cookieName = key2cookie[key] || key;
       setCookie(cookieName, strVal, {
@@ -270,7 +321,11 @@ export const emptyRuntime = (config: JitsuOptions): RuntimeFacade => ({
         if (config.debug) {
           console.log(`[JITSU EMPTY RUNTIME] Set storage item ${key}=${JSON.stringify(val)}`);
         }
-        storage[key] = val;
+        if (typeof val === "undefined") {
+          delete storage[key];
+        } else {
+          storage[key] = val;
+        }
       },
       getItem(key: string) {
         const val = storage[key];
@@ -372,8 +427,13 @@ function adjustPayload(
     library: {
       name: jitsuLibraryName,
       version: jitsuVersion,
-      env: s2s ? "node" : "browser",
+      env: isInBrowser() ? "browser" : "node",
     },
+    consent: config.privacy?.consentCategories
+      ? {
+          categoryPreferences: config.privacy.consentCategories,
+        }
+      : undefined,
     userAgent: runtime.userAgent(),
     locale: runtime.language(),
     screen: runtime.screen(),
@@ -388,11 +448,13 @@ function adjustPayload(
       url: properties.url || url,
       encoding: properties.encoding || runtime.documentEncoding(),
     },
-    clientIds: {
-      fbc: runtime.getCookie("_fbc"),
-      fbp: runtime.getCookie("_fbp"),
-      ...getGa4Ids(runtime),
-    },
+    clientIds: !config.privacy?.disableUserIds
+      ? {
+          fbc: runtime.getCookie("_fbc"),
+          fbp: runtime.getCookie("_fbp"),
+          ...getGa4Ids(runtime),
+        }
+      : undefined,
     campaign: parseUtms(query),
   };
   const withContext = {
@@ -406,6 +468,12 @@ function adjustPayload(
   };
   delete withContext.meta;
   delete withContext.options;
+  if (config.privacy?.disableUserIds) {
+    delete withContext.userId;
+    delete withContext.anonymousId;
+    delete withContext.context.traits;
+    delete withContext.groupId;
+  }
   return withContext;
 }
 
@@ -562,7 +630,7 @@ function maskWriteKey(writeKey?: string): string | undefined {
 async function send(
   method,
   payload,
-  jitsuConfig: Required<JitsuOptions>,
+  jitsuConfig: JitsuOptions,
   instance: AnalyticsInstance,
   store: PersistentStorage
 ): Promise<any> {
@@ -570,7 +638,7 @@ async function send(
     console.log(`[JITSU DEBUG] sending '${method}' event:`, payload);
     return;
   }
-  const s2s = jitsuConfig.s2s === undefined ? !isInBrowser() : jitsuConfig.s2s;
+  const s2s = !!jitsuConfig.s2s;
   const url = s2s ? `${jitsuConfig.host}/api/s/s2s/${method}` : `${jitsuConfig.host}/api/s/${method}`;
   const fetch = jitsuConfig.fetch || globalThis.fetch;
   if (!fetch) {
@@ -592,15 +660,19 @@ async function send(
     : undefined;
 
   const authHeader = jitsuConfig.writeKey ? { "X-Write-Key": jitsuConfig.writeKey } : {};
+  const ipHeader =
+    typeof jitsuConfig.privacy?.ipPolicy === "undefined" || jitsuConfig.privacy?.ipPolicy === "keep"
+      ? {}
+      : { "X-IP-Policy": jitsuConfig.privacy.ipPolicy };
   let fetchResult;
   try {
     fetchResult = await fetch(url, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-
         ...authHeader,
         ...debugHeader,
+        ...ipHeader,
       },
       body: JSON.stringify(adjustedPayload),
       signal: abortController?.signal,
@@ -658,17 +730,12 @@ async function send(
   return adjustedPayload;
 }
 
-export type JitsuPluginConfig = JitsuOptions & {
-  storageWrapper?: (persistentStorage: PersistentStorage) => PersistentStorage;
-};
-export const jitsuAnalyticsPlugin = (pluginConfig: JitsuPluginConfig = {}): AnalyticsPlugin => {
-  const instanceConfig = {
-    ...defaultConfig,
-    ...pluginConfig,
-  };
+export const jitsuAnalyticsPlugin = (jitsuOptions: JitsuOptions = {}, storage: PersistentStorage): AnalyticsPlugin => {
+  // just to make sure that all undefined values are replaced with defaultConfig values
+  mergeConfig(jitsuOptions, jitsuOptions);
   return {
     name: "jitsu",
-    config: instanceConfig,
+    config: jitsuOptions,
 
     initialize: async args => {
       const { config } = args;
@@ -706,28 +773,24 @@ export const jitsuAnalyticsPlugin = (pluginConfig: JitsuPluginConfig = {}): Anal
     },
     page: args => {
       const { payload, config, instance } = args;
-      return send(
-        "page",
-        payload,
-        config,
-        instance,
-        pluginConfig.storageWrapper ? pluginConfig.storageWrapper(instance.storage) : instance.storage
-      );
+      if (config.privacy?.dontSend) {
+        return;
+      }
+      return send("page", payload, config, instance, storage);
     },
     track: args => {
       const { payload, config, instance } = args;
-      return send(
-        "track",
-        payload,
-        config,
-        instance,
-        pluginConfig.storageWrapper ? pluginConfig.storageWrapper(instance.storage) : instance.storage
-      );
+      if (config.privacy?.dontSend) {
+        return;
+      }
+      return send("track", payload, config, instance, storage);
     },
     identify: args => {
       const { payload, config, instance } = args;
+      if (config.privacy?.dontSend || config.privacy?.disableUserIds) {
+        return;
+      }
       // Store traits in cache to be able to use them in page and track events that run asynchronously with current identify.
-      const storage = pluginConfig.storageWrapper ? pluginConfig.storageWrapper(instance.storage) : instance.storage;
       storage.setItem("__user_id", payload.userId);
       if (payload.traits && typeof payload.traits === "object") {
         storage.setItem("__user_traits", payload.traits);
@@ -736,37 +799,54 @@ export const jitsuAnalyticsPlugin = (pluginConfig: JitsuPluginConfig = {}): Anal
     },
     reset: args => {
       const { config, instance } = args;
-      const storage = pluginConfig.storageWrapper ? pluginConfig.storageWrapper(instance.storage) : instance.storage;
-      storage?.reset();
+      storage.reset();
       if (config.debug) {
         console.log("[JITSU DEBUG] Resetting Jitsu plugin storage");
       }
     },
     methods: {
       //analytics doesn't support group as a base method, so we need to add it manually
+      configure(newOptions: DynamicJitsuOptions) {
+        const idsWasDisabled = jitsuOptions.privacy?.disableUserIds || jitsuOptions.privacy?.dontSend;
+        mergeConfig(jitsuOptions, newOptions);
+        const idsDisabledNow = jitsuOptions.privacy?.disableUserIds || jitsuOptions.privacy?.dontSend;
+        if (!idsDisabledNow && idsWasDisabled) {
+          if (jitsuOptions.debug) {
+            console.log("[JITSU] Enabling Anonymous ID. Generating new Id.");
+          }
+          const instance = (this as any).instance;
+          const newAnonymousId = uuid();
+          const userState = instance.user();
+          if (userState) {
+            userState.anonymousId = newAnonymousId;
+          }
+          storage.setItem("__anon_id", newAnonymousId);
+          instance.setAnonymousId(newAnonymousId);
+        }
+      },
       group(groupId?: ID, traits?: JSONObject | null, options?: Options, callback?: Callback) {
+        if (jitsuOptions.privacy?.dontSend || jitsuOptions.privacy?.disableUserIds) {
+          return;
+        }
         if (typeof groupId === "number") {
           //fix potential issues with group id being used incorrectly
           groupId = groupId + "";
         }
 
-        const analyticsInstance = this.instance;
-        const cacheWrap = pluginConfig.storageWrapper
-          ? pluginConfig.storageWrapper(analyticsInstance.storage)
-          : analyticsInstance.storage;
-        const user = analyticsInstance.user();
+        const instance = (this as any).instance;
+        const user = instance.user();
         const userId = options?.userId || user?.userId;
-        const anonymousId = options?.anonymousId || user?.anonymousId || cacheWrap.getItem("__anon_id");
-        cacheWrap.setItem("__group_id", groupId);
+        const anonymousId = options?.anonymousId || user?.anonymousId || storage.getItem("__anon_id");
+        storage.setItem("__group_id", groupId);
         if (traits && typeof traits === "object") {
-          cacheWrap.setItem("__group_traits", traits);
+          storage.setItem("__group_traits", traits);
         }
         return send(
           "group",
           { type: "group", groupId, traits, ...(anonymousId ? { anonymousId } : {}), ...(userId ? { userId } : {}) },
-          instanceConfig,
-          analyticsInstance,
-          cacheWrap
+          jitsuOptions,
+          instance,
+          storage
         );
       },
     },
@@ -786,6 +866,23 @@ export function randomId(hashString: string | undefined = ""): string {
   );
 }
 
+export function uuid() {
+  var u = "",
+    m = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx",
+    i = 0,
+    rb = (Math.random() * 0xffffffff) | 0;
+
+  while (i++ < 36) {
+    var c = m[i - 1],
+      r = rb & 0xf,
+      v = c == "x" ? r : (r & 0x3) | 0x8;
+
+    u += c == "-" || c == "4" ? c : v.toString(16);
+    rb = i % 8 == 0 ? (Math.random() * 0xffffffff) | 0 : rb >> 4;
+  }
+  return u;
+}
+
 function hash(str: string, seed: number = 0): number {
   let h1 = 0xdeadbeef ^ seed,
     h2 = 0x41c6ce57 ^ seed;

package/src/browser.ts

@@ -1,9 +1,8 @@
-import type { AnalyticsInterface, JitsuOptions } from "./jitsu";
+import type { AnalyticsInterface, JitsuOptions } from "@jitsu/protocols/analytics";
 import { jitsuAnalytics } from "./index";
 
 export type JitsuBrowserOptions = {
   namespace?: string;
-  userId?: string;
   onload?: string;
   initOnly?: boolean;
 } & JitsuOptions;
@@ -14,16 +13,47 @@ function snakeToCamel(s: string) {
   });
 }
 
-export type Parser = (arg: string) => any;
-const booleanParser = (arg: string) => arg === "true" || arg === "1" || arg === "yes";
+export type Parser = {
+  path?: (name: string) => string[];
+  parse: (arg: string) => any;
+};
+const trimPrefix = (s: string, prefix: string) => s.replace(new RegExp(`^${prefix}`), "");
+
+const defaultParser = (nestedPath: string[] = []) => ({
+  path: (name: string) => [
+    ...nestedPath,
+    snakeToCamel(nestedPath.length > 0 ? trimPrefix(name, nestedPath.join("-") + "-") : name),
+  ],
+  parse: (arg: string) => arg,
+});
+
+const booleanParser = (nestedPath: string[] = []) => ({
+  ...defaultParser(nestedPath),
+  parse: (arg: string) => arg === "true" || arg === "1" || arg === "yes",
+});
 
-const parsers: Partial<Record<keyof JitsuBrowserOptions, Parser>> = {
-  debug: booleanParser,
-  initOnly: booleanParser,
+const parsers: Partial<Record<string, Parser>> = {
+  debug: booleanParser(),
+  "privacy-disable-user-ids": booleanParser(["privacy"]),
+  "privacy-dont-send": booleanParser(["privacy"]),
+  "privacy-ip-policy": defaultParser(["privacy"]),
+  "echo-events": booleanParser(),
+  "init-only": booleanParser(),
 };
 
-function getParser(name: keyof JitsuBrowserOptions): Parser {
-  return parsers[name] || (x => x);
+function getParser(name: string): Parser {
+  return parsers[name] || defaultParser();
+}
+
+function setPath(obj: any, path: string[], value: any) {
+  let current = obj;
+  let i = 0;
+  for (; i < path.length - 1; i++) {
+    const key = path[i];
+    current[key] = current[key] || {};
+    current = current[key];
+  }
+  current[path[i]] = value;
 }
 
 function getScriptAttributes(scriptElement: HTMLScriptElement) {
@@ -31,13 +61,12 @@ function getScriptAttributes(scriptElement: HTMLScriptElement) {
     .getAttributeNames()
     .filter(name => name.indexOf("data-") === 0)
     .map(name => name.substring("data-".length))
-    .reduce(
-      (res, name) => ({
-        ...res,
-        [snakeToCamel(name)]: getParser(snakeToCamel(name) as any)(scriptElement.getAttribute(`data-${name}`)),
-      }),
-      {}
-    );
+    .reduce((res, name) => {
+      const parser = getParser(name);
+      const path = parser.path(name);
+      setPath(res, path, parser.parse(scriptElement.getAttribute(`data-${name}`)));
+      return res;
+    }, {});
 }
 
 function runCallback(callback: any, jitsu: AnalyticsInterface) {

package/src/destination-plugins/index.ts

@@ -3,7 +3,6 @@ import { tagPlugin } from "./tag";
 import { logrocketPlugin } from "./logrocket";
 import { gtmPlugin } from "./gtm";
 import { ga4Plugin } from "./ga4";
-import type { JitsuOptions } from "../jitsu";
 
 export type InternalPlugin<T> = {
   id: string;

package/src/index.ts

@@ -1,7 +1,17 @@
 import Analytics from "analytics";
-import { AnalyticsInterface, JitsuOptions, PersistentStorage, RuntimeFacade } from "./jitsu";
-import { jitsuAnalyticsPlugin, emptyRuntime, isInBrowser, windowRuntime } from "./analytics-plugin";
-import { Callback, DispatchedEvent, ID, JSONObject, Options } from "@jitsu/protocols/analytics";
+import { jitsuAnalyticsPlugin, emptyRuntime, isInBrowser, windowRuntime, uuid } from "./analytics-plugin";
+import {
+  Callback,
+  DispatchedEvent,
+  ID,
+  JSONObject,
+  Options,
+  AnalyticsInterface,
+  JitsuOptions,
+  PersistentStorage,
+  RuntimeFacade,
+  DynamicJitsuOptions,
+} from "@jitsu/protocols/analytics";
 
 export default function parse(input) {
   let value = input;
@@ -31,6 +41,7 @@ export const emptyAnalytics: AnalyticsInterface = {
   identify: () => Promise.resolve({}),
   group: () => Promise.resolve({}),
   reset: () => Promise.resolve({}),
+  configure: () => {},
 };
 
 function createUnderlyingAnalyticsInstance(
@@ -38,8 +49,6 @@ function createUnderlyingAnalyticsInstance(
   rt: RuntimeFacade,
   plugins: any[] = []
 ): AnalyticsInterface {
-  const storage = rt.store();
-
   const storageCache: any = {};
 
   // AnalyticsInstance's storage is async somewhere inside. So if we make 'page' call right after 'identify' call
@@ -47,6 +56,9 @@ function createUnderlyingAnalyticsInstance(
   // to avoid that we use in-memory cache for storage
   const cachingStorageWrapper = (persistentStorage: PersistentStorage) => ({
     setItem(key: string, val: any) {
+      if (opts.privacy?.dontSend || opts.privacy?.disableUserIds) {
+        return;
+      }
       if (opts.debug) {
         console.log(`[JITSU DEBUG] Caching storage setItem: ${key}=${val}`);
       }
@@ -54,6 +66,9 @@ function createUnderlyingAnalyticsInstance(
       persistentStorage.setItem(key, val);
     },
     getItem(key: string) {
+      if (opts.privacy?.dontSend || opts.privacy?.disableUserIds) {
+        return;
+      }
       const value = storageCache[key] || persistentStorage.getItem(key);
       if (opts.debug) {
         console.log(
@@ -66,7 +81,7 @@ function createUnderlyingAnalyticsInstance(
       for (const key of [...Object.keys(storageCache)]) {
         delete storageCache[key];
       }
-      storage.reset();
+      persistentStorage.reset();
     },
     removeItem(key: string) {
       if (opts.debug) {
@@ -76,14 +91,15 @@ function createUnderlyingAnalyticsInstance(
       persistentStorage.removeItem(key);
     },
   });
+  const storage = cachingStorageWrapper(rt.store());
 
   const analytics = Analytics({
     debug: !!opts.debug,
     storage,
-    plugins: [jitsuAnalyticsPlugin({ ...opts, storageWrapper: cachingStorageWrapper }), ...plugins],
+    plugins: [jitsuAnalyticsPlugin(opts, storage), ...plugins],
   } as any);
 
-  return {
+  const a = {
     ...analytics,
     page: (...args) => {
       if (args.length === 2 && typeof args[0] === "string" && typeof args[1] === "object") {
@@ -124,7 +140,7 @@ function createUnderlyingAnalyticsInstance(
       if (opts.debug) {
         console.log("[JITSU DEBUG] Setting anonymous id to " + id);
       }
-      //Workaround for analytics.js bug. Underlying setAnonymousId doesn't work set the id immediately,
+      //Workaround for analytics.js bug. Underlying setAnonymousId doesn't  set the id immediately,
       //so we got to it manually here. See https://github.com/jitsucom/jitsu/issues/1060
       storage.setItem("__anon_id", id);
       const userState = analytics.user();
@@ -144,6 +160,19 @@ function createUnderlyingAnalyticsInstance(
         console.log("[JITSU DEBUG] User state after reset", JSON.stringify(analytics.user()));
       }
     },
+    async configure(options: DynamicJitsuOptions) {
+      if (opts.debug) {
+        console.log("[JITSU DEBUG] Update Jitsu config with", JSON.stringify(options));
+      }
+      if (options.privacy?.disableUserIds || options.privacy?.dontSend) {
+        storage.reset();
+      }
+      for (const plugin of Object.values(analytics.plugins)) {
+        if (typeof plugin["configure"] === "function") {
+          plugin["configure"](options);
+        }
+      }
+    },
     async group(
       groupId?: ID,
       traits?: JSONObject | null,
@@ -161,6 +190,10 @@ function createUnderlyingAnalyticsInstance(
       return results[0];
     },
   } as AnalyticsInterface;
+  if (opts.privacy?.disableUserIds || opts.privacy?.dontSend) {
+    storage.reset();
+  }
+  return a;
 }
 
 /**
@@ -171,7 +204,9 @@ function fixOptions(opts: JitsuOptions): JitsuOptions {
   return {
     ...opts,
     host:
-      opts.host.indexOf("https://") !== 0 && opts.host.indexOf("http://") !== 0 ? `https://${opts.host}` : opts.host,
+      (opts.host ?? "").indexOf("https://") !== 0 && (opts.host ?? "").indexOf("http://") !== 0
+        ? `https://${opts.host}`
+        : opts.host,
   };
 }
 
@@ -205,22 +240,16 @@ export function jitsuAnalytics(_opts: JitsuOptions): AnalyticsInterface {
   // }
 }
 
-function uuid() {
-  var u = "",
-    m = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx",
-    i = 0,
-    rb = (Math.random() * 0xffffffff) | 0;
-
-  while (i++ < 36) {
-    var c = m[i - 1],
-      r = rb & 0xf,
-      v = c == "x" ? r : (r & 0x3) | 0x8;
-
-    u += c == "-" || c == "4" ? c : v.toString(16);
-    rb = i % 8 == 0 ? (Math.random() * 0xffffffff) | 0 : rb >> 4;
-  }
-  return u;
-}
-
-export * from "./jitsu";
+export {
+  Callback,
+  DispatchedEvent,
+  ID,
+  JSONObject,
+  Options,
+  AnalyticsInterface,
+  JitsuOptions,
+  PersistentStorage,
+  RuntimeFacade,
+  DynamicJitsuOptions,
+};
 export * from "./analytics-plugin";

package/src/jitsu.ts

@@ -1,93 +0,0 @@
-import type { AnalyticsInterface } from "@jitsu/protocols/analytics";
-
-type JitsuOptions = {
-  /**
-   * API Key. Optional. If not set, Jitsu will send event to the server without auth, and server
-   * will link the call to configured source by domain name
-   */
-  writeKey?: string;
-  /**
-   * API Host. Default value: same host as script origin
-   */
-  host?: string;
-  /**
-   * To enable debug logging
-   */
-  debug?: boolean;
-  /**
-   * Explicitly specify cookie domain. If not set, cookie domain will be set to top level
-   * of the current domain. Example: if JS lives on "app.example.com", cookie domain will be
-   * set to ".example.com". If it lives on "example.com", cookie domain will be set to ".example.com" too
-   */
-  cookieDomain?: string;
-  /**
-   * Provide fetch implementation. It is required if you want to use Jitsu in NodeJS
-   */
-  fetch?: typeof fetch;
-  /**
-   * Which runtime to use. Runtime is used for obtaining context of the event: cookes,
-   * url, etc. At the moment, Jitsu supports browser runtime and NodeJS runtime, but you
-   * can provide your own implementation.
-   *
-   * If it's not set, the runtime will be detected automatically by presense of `window` object
-   */
-  runtime?: RuntimeFacade;
-  /**
-   * If set to true, jitsu will output events in console. In this case you don't need to set
-   * writeKey / host. It's useful for debugging development environment
-   */
-  echoEvents?: boolean;
-
-  /**
-   * If true, events will go to s2s endpoints like ${host}/api/s/s2s/{type}. Otherwise they'll go to ${host}/api/s/{type}.
-   *
-   * If not set at all, it will be detected automatically by presence of `window` object
-   */
-  s2s?: boolean;
-
-  /**
-   * Timeout for fetch requests. Default value: 5000
-   */
-  fetchTimeoutMs?: number;
-
-  /**
-   * Endpoint that makes sure that Jitsu anonymousId cookie is set as server (httpOnly) cookie.
-   * Endpoint must be hosted on the same domain as the site where Jitsu code is installed.
-   * Required to overcome Safari ITP restrictions.
-   */
-  idEndpoint?: string;
-};
-
-type PersistentStorage = {
-  getItem: (key: string, options?: any) => any;
-  setItem: (key: string, value: any, options?: any) => void;
-  removeItem: (key: string, options?: any) => void;
-  reset: () => void;
-};
-
-type RuntimeFacade = {
-  store(): PersistentStorage;
-  userAgent(): string | undefined;
-  language(): string | undefined;
-  pageUrl(): string | undefined;
-  documentEncoding(): string | undefined;
-  getCookie(name: string): string | undefined;
-  getCookies(): Record<string, string>;
-
-  timezoneOffset(): number | undefined;
-  screen():
-    | {
-        width: number;
-        height: number;
-        innerWidth: number;
-        innerHeight: number;
-        density: number;
-      }
-    | undefined;
-  referrer(): string | undefined;
-  pageTitle(): string | undefined;
-};
-
-export declare function jitsuAnalytics(opts: JitsuOptions): AnalyticsInterface;
-
-export { AnalyticsInterface, JitsuOptions, PersistentStorage, RuntimeFacade };