@croct/sdk 0.17.11 → 0.18.0

package/context.cjs

@@ -20,10 +20,10 @@ __export(context_exports, {
   Context: () => Context
 });
 module.exports = __toCommonJS(context_exports);
-var import_token = require("./token");
-var import_tab = require("./tab");
-var import_uuid = require("./uuid");
-var import_cache = require("./cache");
+var import_token = require('./token/index.cjs');
+var import_tab = require('./tab.cjs');
+var import_uuid = require('./uuid.cjs');
+var import_cache = require('./cache/index.cjs');
 function tokenEquals(left, right) {
   return left === right || left !== null && right !== null && left.toString() === right.toString();
 }
@@ -111,4 +111,3 @@ class Context {
 0 && (module.exports = {
   Context
 });
-//# sourceMappingURL=context.cjs.map

package/context.d.cts

@@ -0,0 +1,36 @@
+import { Token } from './token/token.cjs';
+import { Cache } from './cache/cache.cjs';
+import { UrlSanitizer, Tab } from './tab.cjs';
+import { EventDispatcher } from './eventManager.cjs';
+import { SdkEventMap } from './sdkEvents.cjs';
+import '@croct/json';
+import './apiKey.cjs';
+
+type TokenScope = 'isolated' | 'global' | 'contextual';
+type Configuration = {
+    tokenScope: TokenScope;
+    urlSanitizer?: UrlSanitizer;
+    eventDispatcher: ContextEventDispatcher;
+    cache: {
+        tabId: Cache;
+        tabToken: Cache;
+        browserToken: Cache;
+    };
+};
+type ContextEventDispatcher = EventDispatcher<Pick<SdkEventMap, 'tokenChanged'>>;
+declare class Context {
+    private readonly tab;
+    private readonly tokenStore;
+    private readonly eventDispatcher;
+    private lastToken;
+    private constructor();
+    static load({ cache, tokenScope, eventDispatcher, urlSanitizer }: Configuration): Context;
+    getTab(): Tab;
+    isAnonymous(): boolean;
+    getUser(): string | null;
+    getToken(): Token | null;
+    setToken(token: Token | null): void;
+    private syncToken;
+}
+
+export { type Configuration, Context, type TokenScope };

package/context.js

@@ -1,7 +1,7 @@
-import { CachedTokenStore, ReplicatedTokenStore, InMemoryTokenStore } from "./token";
-import { Tab } from "./tab";
-import { uuid4 } from "./uuid";
-import { ObservableCache } from "./cache";
+import { CachedTokenStore, ReplicatedTokenStore, InMemoryTokenStore } from "./token/index.js";
+import { Tab } from "./tab.js";
+import { uuid4 } from "./uuid.js";
+import { ObservableCache } from "./cache/index.js";
 function tokenEquals(left, right) {
   return left === right || left !== null && right !== null && left.toString() === right.toString();
 }
@@ -88,4 +88,3 @@ class Context {
 export {
   Context
 };
-//# sourceMappingURL=context.js.map

package/error.cjs

@@ -49,4 +49,3 @@ function formatCause(error) {
   formatCause,
   formatMessage
 });
-//# sourceMappingURL=error.cjs.map

package/error.d.cts

@@ -0,0 +1,4 @@
+declare function formatMessage(error: unknown): string;
+declare function formatCause(error: unknown): string;
+
+export { formatCause, formatMessage };

package/error.js

@@ -25,4 +25,3 @@ export {
   formatCause,
   formatMessage
 };
-//# sourceMappingURL=error.js.map

package/evaluator.cjs

@@ -23,11 +23,11 @@ __export(evaluator_exports, {
   QueryError: () => QueryError
 });
 module.exports = __toCommonJS(evaluator_exports);
-var import_constants = require("./constants");
-var import_error = require("./error");
-var import_sourceLocation = require("./sourceLocation");
-var import_logging = require("./logging");
-var import_help = require("./help");
+var import_constants = require('./constants.cjs');
+var import_error = require('./error.cjs');
+var import_sourceLocation = require('./sourceLocation.cjs');
+var import_logging = require('./logging/index.cjs');
+var import_help = require('./help.cjs');
 var EvaluationErrorType = /* @__PURE__ */ ((EvaluationErrorType2) => {
   EvaluationErrorType2["TIMEOUT"] = "https://croct.help/api/evaluation#timeout";
   EvaluationErrorType2["UNEXPECTED_ERROR"] = "https://croct.help/api/evaluation#unexpected-error";
@@ -216,4 +216,3 @@ let Evaluator = _Evaluator;
   Evaluator,
   QueryError
 });
-//# sourceMappingURL=evaluator.cjs.map

package/evaluator.d.cts

@@ -0,0 +1,86 @@
+import { JsonObject, JsonValue } from '@croct/json';
+import { Token } from './token/token.cjs';
+import { Location } from './sourceLocation.cjs';
+import { Logger } from './logging/logger.cjs';
+import { ApiKey } from './apiKey.cjs';
+
+type Campaign = {
+    name?: string;
+    source?: string;
+    medium?: string;
+    term?: string;
+    content?: string;
+};
+type Page = {
+    url: string;
+    title?: string;
+    referrer?: string;
+};
+type EvaluationContext = {
+    timeZone?: string;
+    campaign?: Campaign;
+    page?: Page;
+    attributes?: JsonObject;
+};
+type AllowedFetchOptions = Exclude<keyof RequestInit, 'method' | 'body' | 'headers' | 'signal'>;
+type ExtraFetchOptions<T extends keyof RequestInit = AllowedFetchOptions> = Pick<RequestInit, T> & {
+    [key in Exclude<keyof RequestInit, T>]?: never;
+} & Record<string, any>;
+type EvaluationOptions = {
+    clientId?: string;
+    clientIp?: string;
+    clientAgent?: string;
+    userToken?: Token | string;
+    timeout?: number;
+    context?: EvaluationContext;
+    extra?: ExtraFetchOptions;
+};
+declare enum EvaluationErrorType {
+    TIMEOUT = "https://croct.help/api/evaluation#timeout",
+    UNEXPECTED_ERROR = "https://croct.help/api/evaluation#unexpected-error",
+    INVALID_QUERY = "https://croct.help/api/evaluation#invalid-query",
+    TOO_COMPLEX_QUERY = "https://croct.help/api/evaluation#too-complex-query",
+    EVALUATION_FAILED = "https://croct.help/api/evaluation#evaluation-failed",
+    UNALLOWED_RESULT = "https://croct.help/api/evaluation#unallowed-result",
+    UNSERIALIZABLE_RESULT = "https://croct.help/api/evaluation#unserializable-result"
+}
+type ErrorResponse = {
+    type: EvaluationErrorType;
+    title: string;
+    status: number;
+    detail?: string;
+};
+declare class EvaluationError<T extends ErrorResponse = ErrorResponse> extends Error {
+    readonly response: T;
+    constructor(response: T);
+}
+type QueryErrorDetail = {
+    cause: string;
+    location: Location;
+};
+type QueryErrorResponse = ErrorResponse & {
+    errors: QueryErrorDetail[];
+};
+declare class QueryError extends EvaluationError<QueryErrorResponse> {
+    constructor(response: QueryErrorResponse);
+}
+type Configuration = {
+    appId?: string;
+    apiKey?: string | ApiKey;
+    baseEndpointUrl?: string;
+    logger?: Logger;
+    defaultTimeout?: number;
+};
+declare class Evaluator {
+    static readonly MAX_QUERY_LENGTH: number;
+    private readonly configuration;
+    private readonly endpoint;
+    private readonly logger;
+    constructor(configuration: Configuration);
+    evaluate(query: string, options?: EvaluationOptions): Promise<JsonValue>;
+    private fetch;
+    private logHelp;
+    toJSON(): never;
+}
+
+export { type Campaign, type Configuration, type ErrorResponse, type EvaluationContext, EvaluationError, EvaluationErrorType, type EvaluationOptions, Evaluator, type Page, QueryError, type QueryErrorResponse };

package/evaluator.js

@@ -1,8 +1,8 @@
-import { BASE_ENDPOINT_URL, CLIENT_LIBRARY, MAX_QUERY_LENGTH } from "./constants";
-import { formatMessage } from "./error";
-import { getLength, getLocation } from "./sourceLocation";
-import { NullLogger } from "./logging";
-import { Help } from "./help";
+import { BASE_ENDPOINT_URL, CLIENT_LIBRARY, MAX_QUERY_LENGTH } from "./constants.js";
+import { formatMessage } from "./error.js";
+import { getLength, getLocation } from "./sourceLocation.js";
+import { NullLogger } from "./logging/index.js";
+import { Help } from "./help.js";
 var EvaluationErrorType = /* @__PURE__ */ ((EvaluationErrorType2) => {
   EvaluationErrorType2["TIMEOUT"] = "https://croct.help/api/evaluation#timeout";
   EvaluationErrorType2["UNEXPECTED_ERROR"] = "https://croct.help/api/evaluation#unexpected-error";
@@ -190,4 +190,3 @@ export {
   Evaluator,
   QueryError
 };
-//# sourceMappingURL=evaluator.js.map

package/eventManager.cjs

@@ -50,4 +50,3 @@ class SynchronousEventManager {
 0 && (module.exports = {
   SynchronousEventManager
 });
-//# sourceMappingURL=eventManager.cjs.map

package/eventManager.d.cts

@@ -0,0 +1,21 @@
+interface EventListener<T> {
+    (event: T): void;
+}
+type EventMap = Record<string, Record<string, any>>;
+interface EventDispatcher<TEvents extends EventMap> {
+    dispatch<T extends keyof TEvents>(eventName: T, event: TEvents[T]): void;
+}
+interface EventSubscriber<TEvents extends EventMap> {
+    addListener<T extends keyof TEvents>(eventName: T, listener: EventListener<TEvents[T]>): void;
+    removeListener<T extends keyof TEvents>(eventName: T, listener: EventListener<TEvents[T]>): void;
+}
+interface EventManager<DEvents extends EventMap, SEvents extends EventMap = DEvents> extends EventDispatcher<DEvents>, EventSubscriber<SEvents> {
+}
+declare class SynchronousEventManager<TEvents extends EventMap> implements EventManager<TEvents> {
+    private readonly listeners;
+    addListener<T extends keyof TEvents>(type: T, listener: EventListener<TEvents[T]>): void;
+    removeListener<T extends keyof TEvents>(eventName: T, listener: EventListener<TEvents[T]>): void;
+    dispatch<T extends keyof TEvents>(eventName: T, event: TEvents[T]): void;
+}
+
+export { type EventDispatcher, type EventListener, type EventManager, type EventMap, type EventSubscriber, SynchronousEventManager };

package/eventManager.js

@@ -27,4 +27,3 @@ class SynchronousEventManager {
 export {
   SynchronousEventManager
 };
-//# sourceMappingURL=eventManager.js.map

package/eventSubjectProcessor.cjs

@@ -81,4 +81,3 @@ class EventSubjectProcessor {
 0 && (module.exports = {
   EventSubjectProcessor
 });
-//# sourceMappingURL=eventSubjectProcessor.cjs.map

package/eventSubjectProcessor.d.cts

@@ -0,0 +1,22 @@
+import { TrackingEventProcessor, QueuedEventInfo } from './tracker.cjs';
+import { Logger } from './logging/logger.cjs';
+import './tab.cjs';
+import './eventManager.cjs';
+import './channel/channel.cjs';
+import './retry/policy.cjs';
+import './token/token.cjs';
+import '@croct/json';
+import './apiKey.cjs';
+import './trackingEvents.cjs';
+import './patch.cjs';
+import './utilityTypes.cjs';
+
+declare class EventSubjectProcessor implements TrackingEventProcessor {
+    private currentToken?;
+    private logger;
+    constructor(logger: Logger);
+    process(event: QueuedEventInfo): QueuedEventInfo[];
+    private static isIdentificationEvent;
+}
+
+export { EventSubjectProcessor };

package/eventSubjectProcessor.js

@@ -58,4 +58,3 @@ class EventSubjectProcessor {
 export {
   EventSubjectProcessor
 };
-//# sourceMappingURL=eventSubjectProcessor.js.map

package/facade/contentFetcherFacade.cjs

@@ -20,8 +20,8 @@ __export(contentFetcherFacade_exports, {
   ContentFetcherFacade: () => ContentFetcherFacade
 });
 module.exports = __toCommonJS(contentFetcherFacade_exports);
-var import_error = require("../error");
-var import_schema = require("../schema");
+var import_error = require('../error.cjs');
+var import_schema = require('../schema/index.cjs');
 function validate(options) {
   try {
     import_schema.fetchOptionsSchema.validate(options);
@@ -58,4 +58,3 @@ class ContentFetcherFacade {
 0 && (module.exports = {
   ContentFetcherFacade
 });
-//# sourceMappingURL=contentFetcherFacade.cjs.map

package/facade/contentFetcherFacade.d.cts

@@ -0,0 +1,36 @@
+import { JsonObject } from '@croct/json';
+import { ContentFetcher, FetchResponse } from '../contentFetcher.cjs';
+import { ContextFactory } from './evaluatorFacade.cjs';
+import { TokenProvider } from '../token/token.cjs';
+import { CidAssigner } from '../cid/assigner.cjs';
+import '../evaluator.cjs';
+import '../sourceLocation.cjs';
+import '../logging/logger.cjs';
+import '../apiKey.cjs';
+import '../tab.cjs';
+import '../eventManager.cjs';
+
+type FetchOptions = {
+    version?: `${number}` | number;
+    preferredLocale?: string;
+    timeout?: number;
+    attributes?: JsonObject;
+};
+type Configuration = {
+    contentFetcher: ContentFetcher;
+    contextFactory: ContextFactory;
+    previewTokenProvider: TokenProvider;
+    userTokenProvider: TokenProvider;
+    cidAssigner: CidAssigner;
+};
+declare class ContentFetcherFacade {
+    private readonly fetcher;
+    private readonly contextFactory;
+    private readonly previewTokenProvider;
+    private readonly userTokenProvider;
+    private readonly cidAssigner;
+    constructor(configuration: Configuration);
+    fetch<P extends JsonObject>(slotId: string, options?: FetchOptions): Promise<FetchResponse<P>>;
+}
+
+export { type Configuration, ContentFetcherFacade, type FetchOptions };

package/facade/contentFetcherFacade.js

@@ -1,5 +1,5 @@
-import { formatCause } from "../error";
-import { fetchOptionsSchema as optionsSchema } from "../schema";
+import { formatCause } from "../error.js";
+import { fetchOptionsSchema as optionsSchema } from "../schema/index.js";
 function validate(options) {
   try {
     optionsSchema.validate(options);
@@ -35,4 +35,3 @@ class ContentFetcherFacade {
 export {
   ContentFetcherFacade
 };
-//# sourceMappingURL=contentFetcherFacade.js.map

package/facade/evaluatorFacade.cjs

@@ -22,8 +22,8 @@ __export(evaluatorFacade_exports, {
   TabContextFactory: () => TabContextFactory
 });
 module.exports = __toCommonJS(evaluatorFacade_exports);
-var import_schema = require("../schema");
-var import_error = require("../error");
+var import_schema = require('../schema/index.cjs');
+var import_error = require('../error.cjs');
 function validate(options) {
   try {
     import_schema.evaluationOptionsSchema.validate(options);
@@ -91,4 +91,3 @@ class TabContextFactory {
   MinimalContextFactory,
   TabContextFactory
 });
-//# sourceMappingURL=evaluatorFacade.cjs.map

package/facade/evaluatorFacade.d.cts

@@ -0,0 +1,41 @@
+import { JsonObject, JsonValue } from '@croct/json';
+import { EvaluationContext, Evaluator } from '../evaluator.cjs';
+import { Tab } from '../tab.cjs';
+import { TokenProvider } from '../token/token.cjs';
+import { CidAssigner } from '../cid/assigner.cjs';
+import '../sourceLocation.cjs';
+import '../logging/logger.cjs';
+import '../apiKey.cjs';
+import '../eventManager.cjs';
+
+type EvaluationOptions = {
+    timeout?: number;
+    attributes?: JsonObject;
+};
+interface ContextFactory {
+    createContext(attributes?: JsonObject): EvaluationContext;
+}
+type Configuration = {
+    evaluator: Evaluator;
+    contextFactory: ContextFactory;
+    userTokenProvider: TokenProvider;
+    cidAssigner: CidAssigner;
+};
+declare class EvaluatorFacade {
+    private readonly evaluator;
+    private readonly contextFactory;
+    private readonly tokenProvider;
+    private readonly cidAssigner;
+    constructor(configuration: Configuration);
+    evaluate(query: string, options?: EvaluationOptions): Promise<JsonValue>;
+}
+declare class MinimalContextFactory implements ContextFactory {
+    createContext(attributes?: JsonObject): EvaluationContext;
+}
+declare class TabContextFactory implements ContextFactory {
+    private readonly tab;
+    constructor(tab: Tab);
+    createContext(attributes?: JsonObject): EvaluationContext;
+}
+
+export { type Configuration, type ContextFactory, type EvaluationOptions, EvaluatorFacade, MinimalContextFactory, TabContextFactory };

package/facade/evaluatorFacade.js

@@ -1,5 +1,5 @@
-import { evaluationOptionsSchema as optionsSchema } from "../schema";
-import { formatCause } from "../error";
+import { evaluationOptionsSchema as optionsSchema } from "../schema/index.js";
+import { formatCause } from "../error.js";
 function validate(options) {
   try {
     optionsSchema.validate(options);
@@ -66,4 +66,3 @@ export {
   MinimalContextFactory,
   TabContextFactory
 };
-//# sourceMappingURL=evaluatorFacade.js.map

package/facade/index.cjs

@@ -17,7 +17,6 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var facade_exports = {};
 __export(facade_exports, {
-  ContextFactory: () => import_evaluatorFacade.ContextFactory,
   EvaluatorFacade: () => import_evaluatorFacade.EvaluatorFacade,
   MinimalContextFactory: () => import_evaluatorFacade.MinimalContextFactory,
   SdkFacade: () => import_sdkFacade.SdkFacade,
@@ -29,16 +28,15 @@ __export(facade_exports, {
   UserPatch: () => import_userPatch.UserPatch
 });
 module.exports = __toCommonJS(facade_exports);
-var import_evaluatorFacade = require("./evaluatorFacade");
-var import_sdkFacade = require("./sdkFacade");
-var import_sessionFacade = require("./sessionFacade");
-var import_sessionPatch = require("./sessionPatch");
-var import_trackerFacade = require("./trackerFacade");
-var import_userFacade = require("./userFacade");
-var import_userPatch = require("./userPatch");
+var import_evaluatorFacade = require('./evaluatorFacade.cjs');
+var import_sdkFacade = require('./sdkFacade.cjs');
+var import_sessionFacade = require('./sessionFacade.cjs');
+var import_sessionPatch = require('./sessionPatch.cjs');
+var import_trackerFacade = require('./trackerFacade.cjs');
+var import_userFacade = require('./userFacade.cjs');
+var import_userPatch = require('./userPatch.cjs');
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ContextFactory,
   EvaluatorFacade,
   MinimalContextFactory,
   SdkFacade,
@@ -49,4 +47,3 @@ var import_userPatch = require("./userPatch");
   UserFacade,
   UserPatch
 });
-//# sourceMappingURL=index.cjs.map

package/facade/index.d.cts

@@ -0,0 +1,29 @@
+export { ContextFactory, EvaluatorFacade, MinimalContextFactory, TabContextFactory } from './evaluatorFacade.cjs';
+export { SdkFacade } from './sdkFacade.cjs';
+export { SessionFacade } from './sessionFacade.cjs';
+export { SessionPatch } from './sessionPatch.cjs';
+export { TrackerFacade } from './trackerFacade.cjs';
+export { UserFacade } from './userFacade.cjs';
+export { UserPatch } from './userPatch.cjs';
+import '@croct/json';
+import '../evaluator.cjs';
+import '../token/token.cjs';
+import '../apiKey.cjs';
+import '../sourceLocation.cjs';
+import '../logging/logger.cjs';
+import '../tab.cjs';
+import '../eventManager.cjs';
+import '../cid/assigner.cjs';
+import '../context.cjs';
+import '../cache/cache.cjs';
+import '../sdkEvents.cjs';
+import './contentFetcherFacade.cjs';
+import '../contentFetcher.cjs';
+import '../cache/cookieCache.cjs';
+import '../trackingEvents.cjs';
+import '../patch.cjs';
+import '../utilityTypes.cjs';
+import '../tracker.cjs';
+import '../channel/channel.cjs';
+import '../retry/policy.cjs';
+import '../activeRecord.cjs';

package/facade/index.js

@@ -1,12 +1,11 @@
-import { EvaluatorFacade, ContextFactory, MinimalContextFactory, TabContextFactory } from "./evaluatorFacade";
-import { SdkFacade } from "./sdkFacade";
-import { SessionFacade } from "./sessionFacade";
-import { SessionPatch } from "./sessionPatch";
-import { TrackerFacade } from "./trackerFacade";
-import { UserFacade } from "./userFacade";
-import { UserPatch } from "./userPatch";
+import { EvaluatorFacade, MinimalContextFactory, TabContextFactory } from "./evaluatorFacade.js";
+import { SdkFacade } from "./sdkFacade.js";
+import { SessionFacade } from "./sessionFacade.js";
+import { SessionPatch } from "./sessionPatch.js";
+import { TrackerFacade } from "./trackerFacade.js";
+import { UserFacade } from "./userFacade.js";
+import { UserPatch } from "./userPatch.js";
 export {
-  ContextFactory,
   EvaluatorFacade,
   MinimalContextFactory,
   SdkFacade,
@@ -17,4 +16,3 @@ export {
   UserFacade,
   UserPatch
 };
-//# sourceMappingURL=index.js.map

package/facade/sdkFacade.cjs

@@ -20,16 +20,16 @@ __export(sdkFacade_exports, {
   SdkFacade: () => SdkFacade
 });
 module.exports = __toCommonJS(sdkFacade_exports);
-var import_evaluatorFacade = require("./evaluatorFacade");
-var import_trackerFacade = require("./trackerFacade");
-var import_userFacade = require("./userFacade");
-var import_token = require("../token");
-var import_error = require("../error");
-var import_schema = require("../schema");
-var import_sdk = require("../sdk");
-var import_sessionFacade = require("./sessionFacade");
-var import_contentFetcherFacade = require("./contentFetcherFacade");
-var import_eventSubjectProcessor = require("../eventSubjectProcessor");
+var import_evaluatorFacade = require('./evaluatorFacade.cjs');
+var import_trackerFacade = require('./trackerFacade.cjs');
+var import_userFacade = require('./userFacade.cjs');
+var import_token = require('../token/index.cjs');
+var import_error = require('../error.cjs');
+var import_schema = require('../schema/index.cjs');
+var import_sdk = require('../sdk.cjs');
+var import_sessionFacade = require('./sessionFacade.cjs');
+var import_contentFetcherFacade = require('./contentFetcherFacade.cjs');
+var import_eventSubjectProcessor = require('../eventSubjectProcessor.cjs');
 function validateConfiguration(configuration) {
   try {
     import_schema.sdkFacadeConfigurationSchema.validate(configuration);
@@ -226,4 +226,3 @@ class SdkFacade {
 0 && (module.exports = {
   SdkFacade
 });
-//# sourceMappingURL=sdkFacade.cjs.map

package/facade/sdkFacade.d.cts

@@ -0,0 +1,86 @@
+import { EvaluatorFacade } from './evaluatorFacade.cjs';
+import { TrackerFacade } from './trackerFacade.cjs';
+import { TokenScope, Context } from '../context.cjs';
+import { UserFacade } from './userFacade.cjs';
+import { TokenStore, Token } from '../token/token.cjs';
+import { SessionFacade } from './sessionFacade.cjs';
+import { Logger } from '../logging/logger.cjs';
+import { SdkEventMap } from '../sdkEvents.cjs';
+import { EventManager } from '../eventManager.cjs';
+import { CidAssigner } from '../cid/assigner.cjs';
+import { UrlSanitizer } from '../tab.cjs';
+import { ContentFetcherFacade } from './contentFetcherFacade.cjs';
+import { CookieCacheConfiguration } from '../cache/cookieCache.cjs';
+import './sessionPatch.cjs';
+import './userPatch.cjs';
+import '@croct/json';
+import '../evaluator.cjs';
+import '../sourceLocation.cjs';
+import '../apiKey.cjs';
+import '../trackingEvents.cjs';
+import '../patch.cjs';
+import '../utilityTypes.cjs';
+import '../tracker.cjs';
+import '../channel/channel.cjs';
+import '../retry/policy.cjs';
+import '../cache/cache.cjs';
+import '../activeRecord.cjs';
+import '../contentFetcher.cjs';
+
+type Configuration = {
+    appId: string;
+    tokenScope?: TokenScope;
+    debug?: boolean;
+    test?: boolean;
+    track?: boolean;
+    token?: string | null;
+    userId?: string | null;
+    clientId?: string;
+    eventMetadata?: {
+        [key: string]: string;
+    };
+    logger?: Logger;
+    urlSanitizer?: UrlSanitizer;
+    baseEndpointUrl?: string;
+    disableCidMirroring?: boolean;
+    cidAssignerEndpointUrl?: string;
+    cookie?: {
+        clientId?: CookieCacheConfiguration;
+        userToken?: CookieCacheConfiguration;
+        previewToken?: CookieCacheConfiguration;
+    };
+    defaultFetchTimeout?: number;
+    defaultPreferredLocale?: string;
+};
+declare class SdkFacade {
+    private readonly sdk;
+    private trackerFacade?;
+    private userFacade?;
+    private sessionFacade?;
+    private evaluatorFacade?;
+    private contentFetcherFacade?;
+    private constructor();
+    static init(configuration: Configuration): SdkFacade;
+    get context(): Context;
+    get cidAssigner(): CidAssigner;
+    get previewTokenStore(): TokenStore;
+    get userTokenStore(): TokenStore;
+    get tracker(): TrackerFacade;
+    get user(): UserFacade;
+    get session(): SessionFacade;
+    get evaluator(): EvaluatorFacade;
+    get contentFetcher(): ContentFetcherFacade;
+    get eventManager(): EventManager<Record<string, Record<string, unknown>>, SdkEventMap>;
+    identify(userId: string): void;
+    anonymize(): void;
+    getToken(): Token | null;
+    setToken(token: Token): void;
+    unsetToken(): void;
+    private trackInternalEvent;
+    getLogger(...namespace: string[]): Logger;
+    getTabStorage(namespace: string, ...subnamespace: string[]): Storage;
+    getBrowserStorage(namespace: string, ...subnamespace: string[]): Storage;
+    close(): Promise<void>;
+}
+
+export { type Configuration, SdkFacade };