@croct/plug/plug.d.ts

A fully-featured devkit for building natively personalized applications.

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.js';
import { VersionedSlotId, SlotContent } from './slot.js';
import { JsonValue, JsonObject } from '@croct/json/mutable';
import '@croct/sdk/token';
import './sdk/index.js';
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.js';
import './component.js';

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 };