@croct/plug 0.16.5 → 0.17.0

package/playground.js

@@ -1,150 +1,142 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.factory = exports.PlaygroundPlugin = void 0;
-const error_1 = require("@croct/sdk/error");
-const evaluatorFacade_1 = require("@croct/sdk/facade/evaluatorFacade");
-const constants_1 = require("./constants");
-const CONNECTION_PARAMETER = '__cplay';
+import { formatCause } from "@croct/sdk/error";
+import { TabContextFactory } from "@croct/sdk/facade/evaluatorFacade";
+import { PLAYGROUND_CONNECT_URL, PLAYGROUND_ORIGIN } from "./constants.js";
+const CONNECTION_PARAMETER = "__cplay";
 class PlaygroundPlugin {
-    constructor(configuration) {
-        this.sdkVersion = configuration.sdkVersion;
-        this.appId = configuration.appId;
-        this.connectionId = configuration.connectionId;
-        this.tab = configuration.tab;
-        this.contextFactory = configuration.contextFactory;
-        this.storage = configuration.storage;
-        this.eventSubscriber = configuration.eventSubscriber;
-        this.cidAssigner = configuration.cidAssigner;
-        this.tokenProvider = configuration.tokenProvider;
-        this.logger = configuration.logger;
+  constructor(configuration) {
+    this.sdkVersion = configuration.sdkVersion;
+    this.appId = configuration.appId;
+    this.connectionId = configuration.connectionId;
+    this.tab = configuration.tab;
+    this.contextFactory = configuration.contextFactory;
+    this.storage = configuration.storage;
+    this.eventSubscriber = configuration.eventSubscriber;
+    this.cidAssigner = configuration.cidAssigner;
+    this.tokenProvider = configuration.tokenProvider;
+    this.logger = configuration.logger;
+  }
+  enable() {
+    const connectionId = this.resolveConnectionId();
+    if (connectionId === null) {
+      return;
     }
-    enable() {
-        const connectionId = this.resolveConnectionId();
-        if (connectionId === null) {
-            return;
-        }
-        this.syncListener = () => this.cidAssigner
-            .assignCid()
-            .then(cid => {
-            this.syncToken(connectionId, cid);
-        })
-            .catch(error => {
-            this.logger.warn(`Sync failed: ${(0, error_1.formatCause)(error)}`);
-        });
-        this.eventSubscriber.addListener('tokenChanged', this.syncListener);
-        this.tab.addListener('urlChange', this.syncListener);
-        return this.syncListener();
+    this.syncListener = () => this.cidAssigner.assignCid().then((cid) => {
+      this.syncToken(connectionId, cid);
+    }).catch((error) => {
+      this.logger.warn(`Sync failed: ${formatCause(error)}`);
+    });
+    this.eventSubscriber.addListener("tokenChanged", this.syncListener);
+    this.tab.addListener("urlChange", this.syncListener);
+    return this.syncListener();
+  }
+  resolveConnectionId() {
+    if (this.connectionId !== void 0) {
+      this.logger.debug("Connection ID passed in configuration");
+      return this.connectionId;
     }
-    resolveConnectionId() {
-        if (this.connectionId !== undefined) {
-            this.logger.debug('Connection ID passed in configuration');
-            return this.connectionId;
-        }
-        const url = new URL(this.tab.url);
-        let connectionId = url.searchParams.get(CONNECTION_PARAMETER);
-        if (connectionId === null || connectionId === '') {
-            this.logger.debug('No connection ID found in URL');
-            connectionId = this.storage.getItem('connectionId');
-            this.logger.debug(connectionId !== null
-                ? 'Previous connection ID found'
-                : 'No previous connection ID found');
-            return connectionId;
-        }
-        this.logger.debug('Connection ID found in URL');
-        this.storage.setItem('connectionId', connectionId);
-        return connectionId;
+    const url = new URL(this.tab.url);
+    let connectionId = url.searchParams.get(CONNECTION_PARAMETER);
+    if (connectionId === null || connectionId === "") {
+      this.logger.debug("No connection ID found in URL");
+      connectionId = this.storage.getItem("connectionId");
+      this.logger.debug(
+        connectionId !== null ? "Previous connection ID found" : "No previous connection ID found"
+      );
+      return connectionId;
     }
-    disable() {
-        if (this.syncListener !== undefined) {
-            this.eventSubscriber.removeListener('tokenChanged', this.syncListener);
-            this.tab.removeListener('urlChange', this.syncListener);
-            delete this.syncListener;
-        }
+    this.logger.debug("Connection ID found in URL");
+    this.storage.setItem("connectionId", connectionId);
+    return connectionId;
+  }
+  disable() {
+    if (this.syncListener !== void 0) {
+      this.eventSubscriber.removeListener("tokenChanged", this.syncListener);
+      this.tab.removeListener("urlChange", this.syncListener);
+      delete this.syncListener;
     }
-    syncToken(connectionId, cid) {
-        const iframe = document.createElement('iframe');
-        iframe.setAttribute('src', constants_1.PLAYGROUND_CONNECT_URL);
-        iframe.setAttribute('sandbox', 'allow-scripts allow-same-origin');
-        iframe.style.visibility = 'hidden';
-        iframe.style.opacity = '0';
-        iframe.style.border = '0';
-        iframe.style.width = '0';
-        iframe.style.height = '0';
-        const context = this.createContext();
-        iframe.onload = () => {
-            var _a, _b;
-            if (iframe.contentWindow === null) {
-                if (document.body.contains(iframe)) {
-                    document.body.removeChild(iframe);
-                }
-                this.logger.warn('Sync handshake failed');
-                return;
-            }
-            const listener = (event) => {
-                if (event.origin !== constants_1.PLAYGROUND_ORIGIN || event.data !== connectionId) {
-                    return;
-                }
-                window.removeEventListener('message', listener);
-                if (document.body.contains(iframe)) {
-                    document.body.removeChild(iframe);
-                }
-                this.logger.debug('Sync completed');
-            };
-            window.addEventListener('message', listener);
-            const payload = {
-                appId: this.appId,
-                connectionId: connectionId,
-                sdkVersion: this.sdkVersion,
-                tabId: this.tab.id,
-                cid: cid,
-                token: (_b = (_a = this.tokenProvider
-                    .getToken()) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : null,
-                context: context,
-            };
-            iframe.contentWindow.postMessage(payload, constants_1.PLAYGROUND_ORIGIN);
-            this.logger.debug('Waiting for sync acknowledgment...');
-        };
-        this.logger.debug('Sync started');
-        const connect = () => {
-            document.body.appendChild(iframe);
-        };
-        if (document.body === null) {
-            document.addEventListener('DOMContentLoaded', connect);
-        }
-        else {
-            connect();
+  }
+  syncToken(connectionId, cid) {
+    const iframe = document.createElement("iframe");
+    iframe.setAttribute("src", PLAYGROUND_CONNECT_URL);
+    iframe.setAttribute("sandbox", "allow-scripts allow-same-origin");
+    iframe.style.visibility = "hidden";
+    iframe.style.opacity = "0";
+    iframe.style.border = "0";
+    iframe.style.width = "0";
+    iframe.style.height = "0";
+    const context = this.createContext();
+    iframe.onload = () => {
+      if (iframe.contentWindow === null) {
+        if (document.body.contains(iframe)) {
+          document.body.removeChild(iframe);
         }
-    }
-    createContext() {
-        const { page, campaign, timeZone } = this.contextFactory.createContext();
-        const context = {};
-        if (page !== undefined) {
-            context.page = page;
+        this.logger.warn("Sync handshake failed");
+        return;
+      }
+      const listener = (event) => {
+        if (event.origin !== PLAYGROUND_ORIGIN || event.data !== connectionId) {
+          return;
         }
-        if (campaign !== undefined) {
-            context.campaign = campaign;
+        window.removeEventListener("message", listener);
+        if (document.body.contains(iframe)) {
+          document.body.removeChild(iframe);
         }
-        if (timeZone !== undefined) {
-            context.timeZone = timeZone;
-        }
-        return context;
+        this.logger.debug("Sync completed");
+      };
+      window.addEventListener("message", listener);
+      const payload = {
+        appId: this.appId,
+        connectionId,
+        sdkVersion: this.sdkVersion,
+        tabId: this.tab.id,
+        cid,
+        token: this.tokenProvider.getToken()?.toString() ?? null,
+        context
+      };
+      iframe.contentWindow.postMessage(payload, PLAYGROUND_ORIGIN);
+      this.logger.debug("Waiting for sync acknowledgment...");
+    };
+    this.logger.debug("Sync started");
+    const connect = () => {
+      document.body.appendChild(iframe);
+    };
+    if (document.body === null) {
+      document.addEventListener("DOMContentLoaded", connect);
+    } else {
+      connect();
+    }
+  }
+  createContext() {
+    const { page, campaign, timeZone } = this.contextFactory.createContext();
+    const context = {};
+    if (page !== void 0) {
+      context.page = page;
+    }
+    if (campaign !== void 0) {
+      context.campaign = campaign;
     }
+    if (timeZone !== void 0) {
+      context.timeZone = timeZone;
+    }
+    return context;
+  }
 }
-exports.PlaygroundPlugin = PlaygroundPlugin;
 const factory = (props) => {
-    const { sdk, options } = props;
-    return new PlaygroundPlugin({
-        sdkVersion: sdk.version,
-        appId: sdk.appId,
-        connectionId: options.connectionId,
-        tab: sdk.tab,
-        storage: sdk.getTabStorage(),
-        tokenProvider: sdk.userTokenStore,
-        cidAssigner: sdk.cidAssigner,
-        contextFactory: new evaluatorFacade_1.TabContextFactory(sdk.tab),
-        eventSubscriber: sdk.eventManager,
-        logger: sdk.getLogger(),
-    });
+  const { sdk, options } = props;
+  return new PlaygroundPlugin({
+    sdkVersion: sdk.version,
+    appId: sdk.appId,
+    connectionId: options.connectionId,
+    tab: sdk.tab,
+    storage: sdk.getTabStorage(),
+    tokenProvider: sdk.userTokenStore,
+    cidAssigner: sdk.cidAssigner,
+    contextFactory: new TabContextFactory(sdk.tab),
+    eventSubscriber: sdk.eventManager,
+    logger: sdk.getLogger()
+  });
+};
+export {
+  PlaygroundPlugin,
+  factory
 };
-exports.factory = factory;
-//# sourceMappingURL=playground.js.map

package/plug.cjs

@@ -0,0 +1,271 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plug_exports = {};
+__export(plug_exports, {
+  GlobalPlug: () => GlobalPlug
+});
+module.exports = __toCommonJS(plug_exports);
+var import_sdkFacade = require("@croct/sdk/facade/sdkFacade");
+var import_error = require("@croct/sdk/error");
+var import_validation = require("@croct/sdk/validation");
+var import_token = require("@croct/sdk/token");
+var import_sdk = require("@croct/sdk");
+var import_content = require("@croct/content");
+var import_constants = require('./constants.cjs');
+var import_playground = require('./playground.cjs');
+var import_preview = require('./preview.cjs');
+const PLUGIN_NAMESPACE = "Plugin";
+function detectAppId() {
+  const script = window.document.querySelector(`script[src^='${import_constants.CDN_URL}']`);
+  if (!(script instanceof HTMLScriptElement)) {
+    return null;
+  }
+  return new URL(script.src).searchParams.get("appId");
+}
+class GlobalPlug {
+  constructor() {
+    this.pluginFactories = {
+      playground: import_playground.factory,
+      preview: import_preview.factory
+    };
+    this.plugins = {};
+    this.ready = new Promise((resolve) => {
+      this.initialize = resolve;
+    });
+  }
+  extend(name, plugin) {
+    if (this.pluginFactories[name] !== void 0) {
+      throw new Error(`Another plugin is already registered with name "${name}".`);
+    }
+    this.pluginFactories[name] = plugin;
+  }
+  plug(configuration = {}) {
+    if (this.instance !== void 0) {
+      const logger2 = this.instance.getLogger();
+      logger2.info("Croct is already plugged in.");
+      return;
+    }
+    const detectedAppId = detectAppId();
+    const configuredAppId = configuration.appId ?? null;
+    if (detectedAppId !== null && configuredAppId !== null && detectedAppId !== configuredAppId) {
+      throw new Error(
+        'The specified app ID and the auto-detected app ID are conflicting. There is no need to specify an app ID when using an application-specific tag. Please try again omitting the "appId" option. For help, see https://croct.help/sdk/javascript/conflicting-app-id'
+      );
+    }
+    const appId = detectedAppId ?? configuredAppId;
+    if (appId === null) {
+      throw new Error(
+        'The app ID must be specified when it cannot be auto-detected. Please try again specifying the "appId" option.For help, see https://croct.help/sdk/javascript/missing-app-id'
+      );
+    }
+    const { plugins, test, ...sdkConfiguration } = configuration;
+    const sdk = import_sdkFacade.SdkFacade.init({
+      ...sdkConfiguration,
+      appId,
+      test: test ?? (typeof process === "object" && (process.env?.CROCT_TEST_MODE !== void 0 ? process.env.CROCT_TEST_MODE === "true" : process.env?.NODE_ENV === "test"))
+    });
+    this.instance = sdk;
+    const logger = this.instance.getLogger();
+    if (detectedAppId === configuredAppId) {
+      logger.warn(
+        'It is strongly recommended omitting the "appId" option when using the application-specific tag as it is detected automatically.'
+      );
+    }
+    const pending = [];
+    const defaultEnabledPlugins = Object.fromEntries(
+      Object.keys(this.pluginFactories).map((name) => [name, true])
+    );
+    for (const [name, options] of Object.entries({ ...defaultEnabledPlugins, ...plugins })) {
+      logger.debug(`Initializing plugin "${name}"...`);
+      const factory = this.pluginFactories[name];
+      if (factory === void 0) {
+        logger.error(`Plugin "${name}" is not registered.`);
+        continue;
+      }
+      if (typeof options !== "boolean" && (options === null || typeof options !== "object")) {
+        logger.error(
+          `Invalid options for plugin "${name}", expected either boolean or object but got ${(0, import_validation.describe)(options)}`
+        );
+        continue;
+      }
+      if (options === false) {
+        logger.warn(`Plugin "${name}" is declared but not enabled`);
+        continue;
+      }
+      const args = {
+        options: options === true ? {} : options,
+        sdk: {
+          version: import_sdk.VERSION,
+          appId,
+          tracker: sdk.tracker,
+          evaluator: sdk.evaluator,
+          user: sdk.user,
+          session: sdk.session,
+          tab: sdk.context.getTab(),
+          userTokenStore: {
+            getToken: sdk.getToken.bind(sdk),
+            setToken: sdk.setToken.bind(sdk)
+          },
+          previewTokenStore: sdk.previewTokenStore,
+          cidAssigner: sdk.cidAssigner,
+          eventManager: sdk.eventManager,
+          getLogger: (...namespace) => sdk.getLogger(PLUGIN_NAMESPACE, name, ...namespace),
+          getTabStorage: (...namespace) => sdk.getTabStorage(PLUGIN_NAMESPACE, name, ...namespace),
+          getBrowserStorage: (...namespace) => sdk.getBrowserStorage(PLUGIN_NAMESPACE, name, ...namespace)
+        }
+      };
+      let plugin;
+      try {
+        plugin = factory(args);
+      } catch (error) {
+        logger.error(`Failed to initialize plugin "${name}": ${(0, import_error.formatCause)(error)}`);
+        continue;
+      }
+      logger.debug(`Plugin "${name}" initialized`);
+      if (typeof plugin !== "object") {
+        continue;
+      }
+      this.plugins[name] = plugin;
+      const promise = plugin.enable();
+      if (!(promise instanceof Promise)) {
+        logger.debug(`Plugin "${name}" enabled`);
+        continue;
+      }
+      pending.push(
+        promise.then(() => logger.debug(`Plugin "${name}" enabled`)).catch((error) => logger.error(`Failed to enable plugin "${name}": ${(0, import_error.formatCause)(error)}`))
+      );
+    }
+    Promise.all(pending).then(() => {
+      this.initialize();
+      logger.debug("Initialization complete");
+    });
+  }
+  get initialized() {
+    return this.instance !== void 0;
+  }
+  get plugged() {
+    return this.ready.then(() => this);
+  }
+  get flushed() {
+    return this.tracker.flushed.then(() => this);
+  }
+  get sdk() {
+    if (this.instance === void 0) {
+      throw new Error("Croct is not plugged in. For help, see https://croct.help/sdk/javascript/not-plugged-in");
+    }
+    return this.instance;
+  }
+  get tracker() {
+    return this.sdk.tracker;
+  }
+  get evaluator() {
+    return this.sdk.evaluator;
+  }
+  get user() {
+    return this.sdk.user;
+  }
+  get session() {
+    return this.sdk.session;
+  }
+  isAnonymous() {
+    return this.sdk.context.isAnonymous();
+  }
+  getUserId() {
+    return this.sdk.context.getUser();
+  }
+  identify(userId) {
+    if (typeof userId !== "string") {
+      throw new Error(
+        "The user ID must be a string. For help, see https://croct.help/sdk/javascript/invalid-user-id"
+      );
+    }
+    this.sdk.identify(userId);
+  }
+  anonymize() {
+    this.sdk.anonymize();
+  }
+  setToken(token) {
+    this.sdk.setToken(import_token.Token.parse(token));
+  }
+  unsetToken() {
+    this.sdk.unsetToken();
+  }
+  track(type, payload) {
+    return this.sdk.tracker.track(type, payload);
+  }
+  evaluate(query, options = {}) {
+    return this.sdk.evaluator.evaluate(query, options).catch((error) => {
+      const logger = this.sdk.getLogger();
+      const reference = query.length > 20 ? `${query.slice(0, 20)}...` : query;
+      logger.error(`Failed to evaluate query "${reference}": ${(0, import_error.formatCause)(error)}`);
+      throw error;
+    });
+  }
+  test(expression, options = {}) {
+    return this.evaluate(expression, options).then((result) => result === true);
+  }
+  fetch(slotId, { fallback, ...options } = {}) {
+    const [id, version = "latest"] = slotId.split("@");
+    const logger = this.sdk.getLogger();
+    return this.sdk.contentFetcher.fetch(id, version === "latest" ? options : { ...options, version }).catch(async (error) => {
+      logger.error(`Failed to fetch content for slot "${id}@${version}": ${(0, import_error.formatCause)(error)}`);
+      const resolvedFallback = fallback === void 0 ? await (0, import_content.loadSlotContent)(slotId, options.preferredLocale) ?? void 0 : fallback;
+      if (resolvedFallback === void 0) {
+        throw error;
+      }
+      return { content: resolvedFallback };
+    });
+  }
+  async unplug() {
+    if (this.instance === void 0) {
+      return;
+    }
+    const { instance, plugins } = this;
+    const logger = this.sdk.getLogger();
+    const pending = [];
+    for (const [pluginName, controller] of Object.entries(plugins)) {
+      if (typeof controller.disable !== "function") {
+        continue;
+      }
+      logger.debug(`Disabling plugin "${pluginName}"...`);
+      const promise = controller.disable();
+      if (!(promise instanceof Promise)) {
+        logger.debug(`Plugin "${pluginName}" disabled`);
+        continue;
+      }
+      pending.push(
+        promise.then(() => logger.debug(`Plugin "${pluginName}" disabled`)).catch((error) => logger.error(`Failed to disable "${pluginName}": ${(0, import_error.formatCause)(error)}`))
+      );
+    }
+    delete this.instance;
+    this.plugins = {};
+    this.ready = new Promise((resolve) => {
+      this.initialize = resolve;
+    });
+    await Promise.all(pending);
+    try {
+      await instance.close();
+    } finally {
+      logger.info("\u{1F50C} Croct has been unplugged.");
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GlobalPlug
+});

package/plug.d.cts

@@ -0,0 +1,86 @@
+import { SessionFacade } from '@croct/sdk/facade/sessionFacade';
+import { UserFacade } from '@croct/sdk/facade/userFacade';
+import { TrackerFacade } from '@croct/sdk/facade/trackerFacade';
+import { EvaluationOptions, EvaluatorFacade } from '@croct/sdk/facade/evaluatorFacade';
+import { Configuration as Configuration$1 } from '@croct/sdk/facade/sdkFacade';
+import { Optional } from '@croct/sdk/utilityTypes';
+import { ExternalTrackingEventType, ExternalTrackingEventPayload, ExternalTrackingEvent } from '@croct/sdk/trackingEvents';
+import { FetchOptions as FetchOptions$1 } from '@croct/sdk/facade/contentFetcherFacade';
+import { PluginFactory } from './plugin.cjs';
+import { VersionedSlotId, SlotContent } from './slot.cjs';
+import { JsonValue, JsonObject } from '@croct/json/mutable';
+import '@croct/sdk/token';
+import './sdk/index.cjs';
+import '@croct/sdk/eventManager';
+import '@croct/sdk/sdkEvents';
+import '@croct/sdk/logging';
+import '@croct/sdk/tab';
+import '@croct/sdk/cid';
+import '@croct/json';
+import './versioning.cjs';
+import './component.cjs';
+
+interface PluginConfigurations {
+    [key: string]: any;
+}
+type Configuration = Optional<Configuration$1, 'appId'> & {
+    plugins?: PluginConfigurations;
+};
+type FetchOptions<T> = Omit<FetchOptions$1, 'version'> & {
+    fallback?: T;
+};
+type FetchResponse<I extends VersionedSlotId, C extends JsonObject = JsonObject, F = never> = {
+    content: SlotContent<I, C> | F;
+};
+interface Plug {
+    readonly tracker: TrackerFacade;
+    readonly user: UserFacade;
+    readonly session: SessionFacade;
+    readonly initialized: boolean;
+    readonly flushed: Promise<this>;
+    readonly plugged: Promise<this>;
+    plug(configuration: Configuration): void;
+    isAnonymous(): boolean;
+    getUserId(): string | null;
+    identify(userId: string): void;
+    anonymize(): void;
+    setToken(token: string): void;
+    unsetToken(): void;
+    track<T extends ExternalTrackingEventType>(type: T, payload: ExternalTrackingEventPayload<T>): Promise<ExternalTrackingEvent<T>>;
+    evaluate<T extends JsonValue>(expression: string, options?: EvaluationOptions): Promise<T>;
+    fetch<I extends VersionedSlotId>(slotId: I, options?: FetchOptions<SlotContent<I>>): Promise<FetchResponse<I>>;
+    fetch<F, I extends VersionedSlotId>(slotId: I, options?: FetchOptions<SlotContent<I> | F>): Promise<FetchResponse<I, JsonObject, F>>;
+    unplug(): Promise<void>;
+}
+declare class GlobalPlug implements Plug {
+    private pluginFactories;
+    private instance?;
+    private plugins;
+    private initialize;
+    private ready;
+    constructor();
+    extend(name: string, plugin: PluginFactory): void;
+    plug(configuration?: Configuration): void;
+    get initialized(): boolean;
+    get plugged(): Promise<this>;
+    get flushed(): Promise<this>;
+    private get sdk();
+    get tracker(): TrackerFacade;
+    get evaluator(): EvaluatorFacade;
+    get user(): UserFacade;
+    get session(): SessionFacade;
+    isAnonymous(): boolean;
+    getUserId(): string | null;
+    identify(userId: string): void;
+    anonymize(): void;
+    setToken(token: string): void;
+    unsetToken(): void;
+    track<T extends ExternalTrackingEventType>(type: T, payload: ExternalTrackingEventPayload<T>): Promise<ExternalTrackingEvent<T>>;
+    evaluate<T extends JsonValue>(query: string, options?: EvaluationOptions): Promise<T>;
+    test(expression: string, options?: EvaluationOptions): Promise<boolean>;
+    fetch<I extends VersionedSlotId>(slotId: I, options?: FetchOptions<SlotContent<I>>): Promise<FetchResponse<I>>;
+    fetch<F, I extends VersionedSlotId>(slotId: I, options?: FetchOptions<SlotContent<I> | F>): Promise<FetchResponse<I, JsonObject, F>>;
+    unplug(): Promise<void>;
+}
+
+export { type Configuration, type FetchOptions, type FetchResponse, GlobalPlug, type Plug, type PluginConfigurations };