@leanbase.com/js 0.2.1 → 0.2.2-alpha.0

package/dist/module.d.ts

@@ -1,5 +1,508 @@
 import { PostHogCoreOptions, FeatureFlagValue, JsonType, PostHogCore, PostHogFetchOptions, PostHogFetchResponse, PostHogPersistedProperty, PostHogEventProperties } from '@posthog/core';
 
+interface IMirror<TNode> {
+    getId(n: TNode | undefined | null): number;
+    getNode(id: number): TNode | null;
+    getIds(): number[];
+    getMeta(n: TNode): serializedNodeWithId | null;
+    removeNodeFromMap(n: TNode): void;
+    has(id: number): boolean;
+    hasNode(node: TNode): boolean;
+    add(n: TNode, meta: serializedNodeWithId): void;
+    replace(id: number, n: TNode): void;
+    reset(): void;
+}
+declare class Mirror implements IMirror<Node> {
+    private idNodeMap;
+    private nodeMetaMap;
+    getId(n: Node | undefined | null): number;
+    getNode(id: number): Node | null;
+    getIds(): number[];
+    getMeta(n: Node): serializedNodeWithId | null;
+    removeNodeFromMap(n: Node): void;
+    has(id: number): boolean;
+    hasNode(node: Node): boolean;
+    add(n: Node, meta: serializedNodeWithId): void;
+    replace(id: number, n: Node): void;
+    reset(): void;
+}
+type attributes = {
+    [key: string]: string | number | true | null;
+};
+declare enum NodeType {
+    Document = 0,
+    DocumentType = 1,
+    Element = 2,
+    Text = 3,
+    CDATA = 4,
+    Comment = 5
+}
+type documentNode = {
+    type: NodeType.Document;
+    childNodes: serializedNodeWithId[];
+    compatMode?: string;
+};
+type documentTypeNode = {
+    type: NodeType.DocumentType;
+    name: string;
+    publicId: string;
+    systemId: string;
+};
+type elementNode = {
+    type: NodeType.Element;
+    tagName: string;
+    attributes: attributes;
+    childNodes: serializedNodeWithId[];
+    isSVG?: true;
+    needBlock?: boolean;
+    isCustom?: true;
+};
+type textNode = {
+    type: NodeType.Text;
+    textContent: string;
+    isStyle?: true;
+};
+type cdataNode = {
+    type: NodeType.CDATA;
+    textContent: '';
+};
+type commentNode = {
+    type: NodeType.Comment;
+    textContent: string;
+};
+type serializedNode = (documentNode | documentTypeNode | elementNode | textNode | cdataNode | commentNode) & {
+    rootId?: number;
+    isShadowHost?: boolean;
+    isShadow?: boolean;
+};
+type serializedNodeWithId = serializedNode & {
+    id: number;
+};
+type blockClass = string | RegExp;
+type maskTextClass = string | RegExp;
+type IWindow = Window & typeof globalThis;
+type listenerHandler = () => void;
+type KeepIframeSrcFn = (src: string) => boolean;
+type PackFn = (event: eventWithTime) => string;
+declare enum EventType {
+    DomContentLoaded = 0,
+    Load = 1,
+    FullSnapshot = 2,
+    IncrementalSnapshot = 3,
+    Meta = 4,
+    Custom = 5,
+    Plugin = 6
+}
+declare enum IncrementalSource {
+    Mutation = 0,
+    MouseMove = 1,
+    MouseInteraction = 2,
+    Scroll = 3,
+    ViewportResize = 4,
+    Input = 5,
+    TouchMove = 6,
+    MediaInteraction = 7,
+    StyleSheetRule = 8,
+    CanvasMutation = 9,
+    Font = 10,
+    Log = 11,
+    Drag = 12,
+    StyleDeclaration = 13,
+    Selection = 14,
+    AdoptedStyleSheet = 15,
+    CustomElement = 16
+}
+type domContentLoadedEvent = {
+    type: EventType.DomContentLoaded;
+    data: unknown;
+};
+type loadedEvent = {
+    type: EventType.Load;
+    data: unknown;
+};
+type fullSnapshotEvent = {
+    type: EventType.FullSnapshot;
+    data: {
+        node: serializedNodeWithId;
+        initialOffset: {
+            top: number;
+            left: number;
+        };
+    };
+};
+type metaEvent = {
+    type: EventType.Meta;
+    data: {
+        href: string;
+        width: number;
+        height: number;
+    };
+};
+type customEvent<T = unknown> = {
+    type: EventType.Custom;
+    data: {
+        tag: string;
+        payload: T;
+    };
+};
+type pluginEvent<T = unknown> = {
+    type: EventType.Plugin;
+    data: {
+        plugin: string;
+        payload: T;
+    };
+};
+type styleOMValue = {
+    [key: string]: styleValueWithPriority | string | false;
+};
+type styleValueWithPriority = [string, string];
+type textMutation = {
+    id: number;
+    value: string | null;
+};
+type attributeMutation = {
+    id: number;
+    attributes: {
+        [key: string]: string | styleOMValue | null;
+    };
+};
+type removedNodeMutation = {
+    parentId: number;
+    id: number;
+    isShadow?: boolean;
+};
+type addedNodeMutation = {
+    parentId: number;
+    previousId?: number | null;
+    nextId: number | null;
+    node: serializedNodeWithId;
+};
+type mutationCallbackParam = {
+    texts: textMutation[];
+    attributes: attributeMutation[];
+    removes: removedNodeMutation[];
+    adds: addedNodeMutation[];
+    isAttachIframe?: true;
+};
+type mutationData = {
+    source: IncrementalSource.Mutation;
+} & mutationCallbackParam;
+type mousePosition = {
+    x: number;
+    y: number;
+    id: number;
+    timeOffset: number;
+};
+declare enum MouseInteractions {
+    MouseUp = 0,
+    MouseDown = 1,
+    Click = 2,
+    ContextMenu = 3,
+    DblClick = 4,
+    Focus = 5,
+    Blur = 6,
+    TouchStart = 7,
+    TouchMove_Departed = 8,
+    TouchEnd = 9,
+    TouchCancel = 10
+}
+declare enum PointerTypes {
+    Mouse = 0,
+    Pen = 1,
+    Touch = 2
+}
+type mouseInteractionParam = {
+    type: MouseInteractions;
+    id: number;
+    x?: number;
+    y?: number;
+    pointerType?: PointerTypes;
+};
+type mouseInteractionData = {
+    source: IncrementalSource.MouseInteraction;
+} & mouseInteractionParam;
+type mousemoveData = {
+    source: IncrementalSource.MouseMove | IncrementalSource.TouchMove | IncrementalSource.Drag;
+    positions: mousePosition[];
+};
+type scrollPosition = {
+    id: number;
+    x: number;
+    y: number;
+};
+type scrollData = {
+    source: IncrementalSource.Scroll;
+} & scrollPosition;
+type viewportResizeDimension = {
+    width: number;
+    height: number;
+};
+type viewportResizeData = {
+    source: IncrementalSource.ViewportResize;
+} & viewportResizeDimension;
+type inputValue = {
+    text: string;
+    isChecked: boolean;
+    userTriggered?: boolean;
+};
+type inputData = {
+    source: IncrementalSource.Input;
+    id: number;
+} & inputValue;
+declare enum MediaInteractions {
+    Play = 0,
+    Pause = 1,
+    Seeked = 2,
+    VolumeChange = 3,
+    RateChange = 4
+}
+type mediaInteractionParam = {
+    type: MediaInteractions;
+    id: number;
+    currentTime?: number;
+    volume?: number;
+    muted?: boolean;
+    loop?: boolean;
+    playbackRate?: number;
+};
+type mediaInteractionData = {
+    source: IncrementalSource.MediaInteraction;
+} & mediaInteractionParam;
+type styleSheetAddRule = {
+    rule: string;
+    index?: number | number[];
+};
+type styleSheetDeleteRule = {
+    index: number | number[];
+};
+type styleSheetRuleParam = {
+    id?: number;
+    styleId?: number;
+    removes?: styleSheetDeleteRule[];
+    adds?: styleSheetAddRule[];
+    replace?: string;
+    replaceSync?: string;
+};
+type styleSheetRuleData = {
+    source: IncrementalSource.StyleSheetRule;
+} & styleSheetRuleParam;
+declare enum CanvasContext {
+    '2D' = 0,
+    WebGL = 1,
+    WebGL2 = 2
+}
+type canvasMutationCommand = {
+    property: string;
+    args: Array<unknown>;
+    setter?: true;
+};
+type canvasMutationParam = {
+    id: number;
+    type: CanvasContext;
+    commands: canvasMutationCommand[];
+} | ({
+    id: number;
+    type: CanvasContext;
+} & canvasMutationCommand);
+type canvasMutationData = {
+    source: IncrementalSource.CanvasMutation;
+} & canvasMutationParam;
+type fontParam = {
+    family: string;
+    fontSource: string;
+    buffer: boolean;
+    descriptors?: FontFaceDescriptors;
+};
+type fontData = {
+    source: IncrementalSource.Font;
+} & fontParam;
+type SelectionRange = {
+    start: number;
+    startOffset: number;
+    end: number;
+    endOffset: number;
+};
+type selectionParam = {
+    ranges: Array<SelectionRange>;
+};
+type selectionData = {
+    source: IncrementalSource.Selection;
+} & selectionParam;
+type styleDeclarationParam = {
+    id?: number;
+    styleId?: number;
+    index: number[];
+    set?: {
+        property: string;
+        value: string | null;
+        priority: string | undefined;
+    };
+    remove?: {
+        property: string;
+    };
+};
+type styleDeclarationData = {
+    source: IncrementalSource.StyleDeclaration;
+} & styleDeclarationParam;
+type adoptedStyleSheetParam = {
+    id: number;
+    styles?: {
+        styleId: number;
+        rules: styleSheetAddRule[];
+    }[];
+    styleIds: number[];
+};
+type adoptedStyleSheetData = {
+    source: IncrementalSource.AdoptedStyleSheet;
+} & adoptedStyleSheetParam;
+type customElementParam = {
+    define?: {
+        name: string;
+    };
+};
+type customElementData = {
+    source: IncrementalSource.CustomElement;
+} & customElementParam;
+type incrementalData = mutationData | mousemoveData | mouseInteractionData | scrollData | viewportResizeData | inputData | mediaInteractionData | styleSheetRuleData | canvasMutationData | fontData | selectionData | styleDeclarationData | adoptedStyleSheetData | customElementData;
+type incrementalSnapshotEvent = {
+    type: EventType.IncrementalSnapshot;
+    data: incrementalData;
+};
+type eventWithoutTime = domContentLoadedEvent | loadedEvent | fullSnapshotEvent | incrementalSnapshotEvent | metaEvent | customEvent | pluginEvent;
+type eventWithTime = eventWithoutTime & {
+    timestamp: number;
+    delay?: number;
+};
+type mutationCallBack = (m: mutationCallbackParam) => void;
+type mousemoveCallBack = (p: mousePosition[], source: IncrementalSource.MouseMove | IncrementalSource.TouchMove | IncrementalSource.Drag) => void;
+type mouseInteractionCallBack = (d: mouseInteractionParam) => void;
+type scrollCallback = (p: scrollPosition) => void;
+type viewportResizeCallback = (d: viewportResizeDimension) => void;
+type inputCallback = (v: inputValue & {
+    id: number;
+}) => void;
+type mediaInteractionCallback = (p: mediaInteractionParam) => void;
+type styleSheetRuleCallback = (s: styleSheetRuleParam) => void;
+type styleDeclarationCallback = (s: styleDeclarationParam) => void;
+type canvasMutationCallback = (p: canvasMutationParam) => void;
+type fontCallback = (p: fontParam) => void;
+type selectionCallback = (p: selectionParam) => void;
+type customElementCallback = (c: customElementParam) => void;
+type hooksParam = {
+    mutation?: mutationCallBack;
+    mousemove?: mousemoveCallBack;
+    mouseInteraction?: mouseInteractionCallBack;
+    scroll?: scrollCallback;
+    viewportResize?: viewportResizeCallback;
+    input?: inputCallback;
+    mediaInteaction?: mediaInteractionCallback;
+    styleSheetRule?: styleSheetRuleCallback;
+    styleDeclaration?: styleDeclarationCallback;
+    canvasMutation?: canvasMutationCallback;
+    font?: fontCallback;
+    selection?: selectionCallback;
+    customElement?: customElementCallback;
+};
+type SamplingStrategy = Partial<{
+    mousemove: boolean | number;
+    mousemoveCallback: number;
+    mouseInteraction: boolean | Record<string, boolean | undefined>;
+    scroll: number;
+    media: number;
+    input: 'all' | 'last';
+    canvas: 'all' | number;
+}>;
+interface ICrossOriginIframeMirror {
+    getId(iframe: HTMLIFrameElement, remoteId: number, parentToRemoteMap?: Map<number, number>, remoteToParentMap?: Map<number, number>): number;
+    getIds(iframe: HTMLIFrameElement, remoteId: number[]): number[];
+    getRemoteId(iframe: HTMLIFrameElement, parentId: number, map?: Map<number, number>): number;
+    getRemoteIds(iframe: HTMLIFrameElement, parentId: number[]): number[];
+    reset(iframe?: HTMLIFrameElement): void;
+}
+type RecordPlugin<TOptions = unknown> = {
+    name: string;
+    observer?: (cb: (...args: Array<unknown>) => void, win: IWindow, options: TOptions) => listenerHandler;
+    eventProcessor?: <TExtend>(event: eventWithTime) => eventWithTime & TExtend;
+    getMirror?: (mirrors: {
+        nodeMirror: Mirror;
+        crossOriginIframeMirror: ICrossOriginIframeMirror;
+        crossOriginIframeStyleMirror: ICrossOriginIframeMirror;
+    }) => void;
+    options: TOptions;
+};
+
+type MaskInputOptions = Partial<{
+    color: boolean;
+    date: boolean;
+    'datetime-local': boolean;
+    email: boolean;
+    month: boolean;
+    number: boolean;
+    range: boolean;
+    search: boolean;
+    tel: boolean;
+    text: boolean;
+    time: boolean;
+    url: boolean;
+    week: boolean;
+    textarea: boolean;
+    select: boolean;
+    password: boolean;
+}>;
+type MaskInputFn = (text: string, element: HTMLElement) => string;
+type MaskTextFn = (text: string, element: HTMLElement | null) => string;
+type SlimDOMOptions = Partial<{
+    script: boolean;
+    comment: boolean;
+    headFavicon: boolean;
+    headWhitespace: boolean;
+    headMetaDescKeywords: boolean;
+    headMetaSocial: boolean;
+    headMetaRobots: boolean;
+    headMetaHttpEquiv: boolean;
+    headMetaAuthorship: boolean;
+    headMetaVerification: boolean;
+    headTitleMutations: boolean;
+}>;
+type DataURLOptions = Partial<{
+    type: string;
+    quality: number;
+}>;
+type ErrorHandler = (error: unknown) => void | boolean;
+type recordOptions = {
+    emit?: (e: eventWithTime, isCheckout?: boolean) => void;
+    checkoutEveryNth?: number;
+    checkoutEveryNms?: number;
+    blockClass?: blockClass;
+    blockSelector?: string;
+    ignoreClass?: string;
+    ignoreSelector?: string;
+    maskTextClass?: maskTextClass;
+    maskTextSelector?: string;
+    maskAllInputs?: boolean;
+    maskInputOptions?: MaskInputOptions;
+    maskInputFn?: MaskInputFn;
+    maskTextFn?: MaskTextFn;
+    slimDOMOptions?: SlimDOMOptions | 'all' | true;
+    ignoreCSSAttributes?: Set<string>;
+    inlineStylesheet?: boolean;
+    hooks?: hooksParam;
+    packFn?: PackFn;
+    sampling?: SamplingStrategy;
+    dataURLOptions?: DataURLOptions;
+    recordDOM?: boolean;
+    recordCanvas?: boolean;
+    recordCrossOriginIframes?: boolean;
+    recordAfter?: 'DOMContentLoaded' | 'load';
+    userTriggeredOnInput?: boolean;
+    collectFonts?: boolean;
+    inlineImages?: boolean;
+    plugins?: RecordPlugin[];
+    mousemoveWait?: number;
+    keepIframeSrcFn?: KeepIframeSrcFn;
+    errorHandler?: ErrorHandler;
+};
+
 type Property = any;
 type Properties = Record<string, Property>;
 type AutocaptureCompatibleElement = 'a' | 'button' | 'form' | 'input' | 'select' | 'textarea' | 'label';
@@ -102,6 +605,19 @@ interface LeanbaseConfig extends Partial<PostHogCoreOptions> {
      * @default true
      */
     autocapture: boolean | AutocaptureConfig;
+    /**
+     * Enables or disables session recording. When true, session recording is disabled on the client.
+     * @default false
+     */
+    disable_session_recording?: boolean;
+    /**
+     * Session recording configuration
+     */
+    session_recording?: SessionRecordingOptions;
+    /**
+     * Enable console.log recording for session replay (can be controlled remotely). Undefined defers to server.
+     */
+    enable_recording_console_log?: boolean;
     /**
      * Determines whether Leanbase should capture pageview events automatically.
      * Can be:
@@ -112,6 +628,12 @@ interface LeanbaseConfig extends Partial<PostHogCoreOptions> {
      * @default true
      */
     capture_pageview: boolean | 'history_change';
+    /**
+     * Enables performance capture. When true, network performance timing can be forwarded to replay when enabled.
+     */
+    capture_performance?: boolean | {
+        network_timing?: boolean;
+    };
     /**
      * Determines the session idle timeout in seconds.
      * Any new event that's happened after this timeout will create a new session.
@@ -336,6 +858,60 @@ interface LeanbaseConfig extends Partial<PostHogCoreOptions> {
      */
     loaded: (instance: Leanbase) => void;
 }
+type SessionRecordingCanvasOptions = {
+    recordCanvas?: boolean | null;
+    canvasFps?: number | null;
+    canvasQuality?: string | null;
+};
+interface SessionRecordingOptions {
+    blockClass?: string | RegExp;
+    blockSelector?: string | null;
+    ignoreClass?: string | RegExp;
+    maskTextClass?: string | RegExp;
+    maskTextSelector?: string | null;
+    maskTextFn?: ((text: string, element?: HTMLElement) => string) | null;
+    maskAllInputs?: boolean;
+    maskInputOptions?: recordOptions['maskInputOptions'];
+    maskInputFn?: ((text: string, element?: HTMLElement) => string) | null;
+    slimDOMOptions?: recordOptions['slimDOMOptions'];
+    collectFonts?: boolean;
+    inlineStylesheet?: boolean;
+    recordCrossOriginIframes?: boolean;
+    recordHeaders?: boolean;
+    recordBody?: boolean;
+    captureCanvas?: SessionRecordingCanvasOptions;
+    maskCapturedNetworkRequestFn?: ((data: CapturedNetworkRequest) => CapturedNetworkRequest | null | undefined) | null;
+    maskNetworkRequestFn?: ((data: NetworkRequest) => NetworkRequest | null | undefined) | null;
+    full_snapshot_interval_millis?: number;
+    compress_events?: boolean;
+    session_idle_threshold_ms?: number;
+    __mutationThrottlerRefillRate?: number;
+    __mutationThrottlerBucketSize?: number;
+    /**
+     * Force-enable session recording locally even if remote config disables it.
+     * Useful for dev/testing when the backend has sessionRecording set to false.
+     */
+    forceClientRecording?: boolean;
+}
+type SessionRecordingRemoteConfig = SessionRecordingCanvasOptions & {
+    endpoint?: string;
+    consoleLogRecordingEnabled?: boolean;
+    sampleRate?: string | null;
+    minimumDurationMilliseconds?: number;
+    linkedFlag?: string | {
+        flag: string;
+        variant: string;
+    } | null;
+    networkPayloadCapture?: Pick<NetworkRecordOptions, 'recordBody' | 'recordHeaders' | 'payloadHostDenyList'>;
+    masking?: Pick<SessionRecordingOptions, 'maskAllInputs' | 'maskTextSelector' | 'blockSelector'>;
+    urlTriggers?: SessionRecordingUrlTrigger[];
+    scriptConfig?: {
+        script?: string | undefined;
+    };
+    urlBlocklist?: SessionRecordingUrlTrigger[];
+    eventTriggers?: string[];
+    triggerMatchType?: 'any' | 'all';
+};
 interface RageclickConfig {
     /**
      * List of CSS selectors to ignore rageclicks on
@@ -454,6 +1030,10 @@ interface RemoteConfig {
     autocaptureExceptions?: boolean | {
         endpoint?: string;
     };
+    /**
+     * Session recording configuration options
+     */
+    sessionRecording?: SessionRecordingRemoteConfig | false;
     /**
      * @deprecated, moved to toolbarParams
      */
@@ -516,6 +1096,50 @@ interface RequestWithOptions {
         next?: NextOptions;
     };
 }
+type InitiatorType = 'audio' | 'beacon' | 'body' | 'css' | 'early-hint' | 'early-hints' | 'embed' | 'fetch' | 'frame' | 'iframe' | 'image' | 'img' | 'input' | 'link' | 'navigation' | 'object' | 'ping' | 'script' | 'track' | 'video' | 'xmlhttprequest';
+type NetworkRecordOptions = {
+    initiatorTypes?: InitiatorType[];
+    maskRequestFn?: (data: CapturedNetworkRequest) => CapturedNetworkRequest | undefined;
+    recordHeaders?: boolean | {
+        request: boolean;
+        response: boolean;
+    };
+    recordBody?: boolean | string[] | {
+        request: boolean | string[];
+        response: boolean | string[];
+    };
+    recordInitialRequests?: boolean;
+    recordPerformance?: boolean;
+    performanceEntryTypeToObserve: string[];
+    payloadSizeLimitBytes: number;
+    payloadHostDenyList?: string[];
+};
+type NetworkRequest = {
+    url: string;
+};
+type Headers = Record<string, any>;
+type Writable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+type CapturedNetworkRequest = Writable<Omit<PerformanceEntry, 'toJSON'>> & {
+    method?: string;
+    initiatorType?: InitiatorType;
+    status?: number;
+    timeOrigin?: number;
+    timestamp?: number;
+    startTime?: number;
+    endTime?: number;
+    requestHeaders?: Headers;
+    requestBody?: string | null;
+    responseHeaders?: Headers;
+    responseBody?: string | null;
+    isInitial?: boolean;
+};
+interface SessionRecordingUrlTrigger {
+    url: string;
+    matching: 'regex';
+}
+type SessionStartReason = 'sampling_overridden' | 'recording_initialized' | 'linked_flag_matched' | 'linked_flag_overridden' | 'sampled' | 'session_id_changed' | 'url_trigger_matched' | 'event_trigger_matched';
 type SessionIdChangedCallback = (sessionId: string, windowId: string | null | undefined, changeReason?: {
     noSessionId: boolean;
     activityTimeout: boolean;
@@ -808,6 +1432,88 @@ declare class ConsentManager {
     private _getDnt;
 }
 
+type TriggerType = 'url' | 'event';
+/**
+ * Session recording starts in buffering mode while waiting for "flags response".
+ * Once the response is received, it might be disabled, active or sampled.
+ * When "sampled" that means a sample rate is set, and the last time the session ID rotated
+ * the sample rate determined this session should be sent to the server.
+ */
+declare const sessionRecordingStatuses: readonly ["disabled", "sampled", "active", "buffering", "paused", "lazy_loading"];
+type SessionRecordingStatus = (typeof sessionRecordingStatuses)[number];
+
+declare class SessionRecording {
+    private readonly _instance;
+    _forceAllowLocalhostNetworkCapture: boolean;
+    private _receivedFlags;
+    private _bootstrapFailed;
+    private _warnedMissingConsent;
+    private _warnedMissingLoader;
+    private _persistFlagsOnSessionListener;
+    private _lazyLoadedSessionRecording;
+    get started(): boolean;
+    /**
+     * defaults to buffering mode until a flags response is received
+     * once a flags response is received status can be disabled, active or sampled
+     */
+    get status(): SessionRecordingStatus;
+    constructor(_instance: Leanbase);
+    private get _isRecordingEnabled();
+    startIfEnabledOrStop(startReason?: SessionStartReason): void;
+    /**
+     * session recording waits until it receives remote config before loading the script
+     * this is to ensure we can control the script name remotely
+     * and because we wait until we have local and remote config to determine if we should start at all
+     * if start is called and there is no remote config then we wait until there is
+     */
+    private _lazyLoadAndStart;
+    stopRecording(): void;
+    private _resetSampling;
+    private _persistRemoteConfig;
+    private _clearRemoteConfig;
+    onRemoteConfig(response: RemoteConfig): void;
+    log(message: string, level?: 'log' | 'warn' | 'error'): void;
+    private get _scriptName();
+    private _onScriptLoaded;
+    /**
+     * this is maintained on the public API only because it has always been on the public API
+     * if you are calling this directly you are certainly doing something wrong
+     * @deprecated
+     */
+    onRRwebEmit(rawEvent: eventWithTime): void;
+    /**
+     * this ignores the linked flag config and (if other conditions are met) causes capture to start
+     *
+     * It is not usual to call this directly,
+     * instead call `posthog.startSessionRecording({linked_flag: true})`
+     * */
+    overrideLinkedFlag(): void;
+    /**
+     * this ignores the sampling config and (if other conditions are met) causes capture to start
+     *
+     * It is not usual to call this directly,
+     * instead call `posthog.startSessionRecording({sampling: true})`
+     * */
+    overrideSampling(): void;
+    /**
+     * this ignores the URL/Event trigger config and (if other conditions are met) causes capture to start
+     *
+     * It is not usual to call this directly,
+     * instead call `posthog.startSessionRecording({trigger: 'url' | 'event'})`
+     * */
+    overrideTrigger(triggerType: TriggerType): void;
+    get sdkDebugProperties(): Properties;
+    /**
+     * This adds a custom event to the session recording
+     *
+     * It is not intended for arbitrary public use - playback only displays known custom events
+     * And is exposed on the public interface only so that other parts of the SDK are able to use it
+     *
+     * if you are calling this from client code, you're probably looking for `posthog.capture('$custom_event', {...})`
+     */
+    tryAddCustomEvent(tag: string, payload: any): boolean;
+}
+
 declare class Leanbase extends PostHogCore {
     config: LeanbaseConfig;
     scrollManager: ScrollManager;
@@ -818,6 +1524,7 @@ declare class Leanbase extends PostHogCore {
     sessionPersistence?: LeanbasePersistence;
     sessionManager?: SessionIdManager;
     sessionPropsManager?: SessionPropsManager;
+    sessionRecording?: SessionRecording;
     isRemoteConfigLoaded?: boolean;
     personProcessingSetOncePropertiesSent: boolean;
     isLoaded: boolean;
@@ -835,6 +1542,7 @@ declare class Leanbase extends PostHogCore {
     getLibraryVersion(): string;
     getCustomUserAgent(): void;
     getPersistedProperty<T>(key: PostHogPersistedProperty): T | undefined;
+    getPersistedProperty<T>(key: string): T | undefined;
     setPersistedProperty<T>(key: PostHogPersistedProperty, value: T | null): void;
     calculateEventProperties(eventName: string, eventProperties: PostHogEventProperties, timestamp: Date, uuid: string, readOnly?: boolean): Properties;
     isIdentified(): boolean;