@leanbase-giangnd/js 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,1484 @@
+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';
+type DomAutocaptureEvents = 'click' | 'change' | 'submit';
+interface BootstrapConfig {
+    distinctId?: string;
+    isIdentifiedId?: boolean;
+    featureFlags?: Record<string, FeatureFlagValue>;
+    featureFlagPayloads?: Record<string, JsonType>;
+    /**
+     * Optionally provide a sessionID, this is so that you can provide an existing sessionID here to continue a user's session across a domain or device. It MUST be:
+     * - unique to this user
+     * - a valid UUID v7
+     * - the timestamp part must be <= the timestamp of the first event in the session
+     * - the timestamp of the last event in the session must be < the timestamp part + 24 hours
+     * **/
+    sessionID?: string;
+}
+/**
+ * If an array is passed for an allowlist, autocapture events will only be sent for elements matching
+ * at least one of the elements in the array. Multiple allowlists can be used
+ */
+interface AutocaptureConfig {
+    /**
+     * List of URLs to allow autocapture on, can be strings to match
+     * or regexes e.g. ['https://example.com', 'test.com/.*']
+     * this is useful when you want to autocapture on specific pages only
+     *
+     * if you set both url_allowlist and url_ignorelist,
+     * we check the allowlist first and then the ignorelist.
+     * the ignorelist can override the allowlist
+     */
+    url_allowlist?: (string | RegExp)[];
+    /**
+     * List of URLs to not allow autocapture on, can be strings to match
+     * or regexes e.g. ['https://example.com', 'test.com/.*']
+     * this is useful when you want to autocapture on most pages but not some specific ones
+     *
+     * if you set both url_allowlist and url_ignorelist,
+     * we check the allowlist first and then the ignorelist.
+     * the ignorelist can override the allowlist
+     */
+    url_ignorelist?: (string | RegExp)[];
+    /**
+     * List of DOM events to allow autocapture on  e.g. ['click', 'change', 'submit']
+     */
+    dom_event_allowlist?: DomAutocaptureEvents[];
+    /**
+     * List of DOM elements to allow autocapture on
+     * e.g. ['a', 'button', 'form', 'input', 'select', 'textarea', 'label']
+     *
+     * We consider the tree of elements from the root to the target element of the click event
+     * so for the tree `div > div > button > svg`
+     * if the allowlist has `button` then we allow the capture when the `button` or the `svg` is the click target
+     * but not if either of the `div`s are detected as the click target
+     */
+    element_allowlist?: AutocaptureCompatibleElement[];
+    /**
+     * List of CSS selectors to allow autocapture on
+     * e.g. ['[ph-capture]']
+     * we consider the tree of elements from the root to the target element of the click event
+     * so for the tree div > div > button > svg
+     * and allow list config `['[id]']`
+     * we will capture the click if the click-target or its parents has any id
+     *
+     * Everything is allowed when there's no allowlist
+     */
+    css_selector_allowlist?: string[];
+    /**
+     * Exclude certain element attributes from autocapture
+     * E.g. ['aria-label'] or [data-attr-pii]
+     */
+    element_attribute_ignorelist?: string[];
+    /**
+     * When set to true, autocapture will capture the text of any element that is cut or copied.
+     */
+    capture_copied_text?: boolean;
+}
+interface LeanbaseConfig extends Partial<PostHogCoreOptions> {
+    /**
+     * API host for Leanbase
+     * @default 'https://i.leanbase.co'
+     */
+    host?: string;
+    /**
+     * The token for your Leanbase project.
+     * It should NOT be provided manually in the config, but rather passed as the first parameter to `leanbase.init()`.
+     */
+    token: string;
+    /**
+     * Enables debug mode, which provides more verbose logging for development purposes.
+     * @default false
+     */
+    debug?: boolean;
+    /**
+     * Determines whether Leanbase should autocapture events.
+     * This setting does not affect capturing pageview events (see `capture_pageview`).
+     *
+     * by default autocapture is ignored on elements that match a `ph-no-capture` css class on the element or a parent
+     * @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:
+     * - `true`: Capture regular pageviews (default)
+     * - `false`: Don't capture any pageviews
+     * - `'history_change'`: Only capture pageviews on history API changes (pushState, replaceState, popstate)
+     *
+     * @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.
+     *
+     * @default 30 * 60 -- 30 minutes
+     */
+    session_idle_timeout_seconds: number;
+    /**
+     * An object containing the `distinctID`, `isIdentifiedID`, and `featureFlags` keys,
+     * where `distinctID` is a string, and `featureFlags` is an object of key-value pairs.
+     *
+     * Since there is a delay between initializing PostHog and fetching feature flags,
+     * feature flags are not always available immediately.
+     * This makes them unusable if you want to do something like redirecting a user
+     * to a different page based on a feature flag.
+     *
+     * You can, therefore, fetch the feature flags in your server and pre-fill them here,
+     * allowing PostHog to know the feature flag values immediately.
+     *
+     * After the SDK fetches feature flags from PostHog, it will use those flag values instead of bootstrapped ones.
+     *
+     * @default {}
+     */
+    bootstrap: BootstrapConfig;
+    /**
+     * Determines whether Leanbase should capture pageleave events.
+     * If set to `true`, it will capture pageleave events for all pages.
+     * If set to `'if_capture_pageview'`, it will only capture pageleave events if `capture_pageview` is also set to `true` or `'history_change'`.
+     *
+     * @default 'if_capture_pageview'
+     */
+    capture_pageleave: boolean | 'if_capture_pageview';
+    /**
+     * Determines whether Leanbase should capture rage clicks.
+     *
+     * by default rageclicks are ignored on elements that match a `ph-no-capture` or `ph-no-rageclick` css class on the element or a parent
+     * @default true
+     */
+    rageclick: boolean | RageclickConfig;
+    /**
+     * Determines where to store the Leanbase persistence information.
+     */
+    persistence: 'localStorage' | 'cookie' | 'memory' | 'localStorage+cookie' | 'sessionStorage';
+    /**
+     * The name for the super properties persistent store
+     *
+     * @default ''
+     */
+    persistence_name: string;
+    /**
+     * Prevent autocapture from capturing any attribute names on elements.
+     *
+     * @default false
+     */
+    mask_all_element_attributes: boolean;
+    /**
+     * Prevent autocapture from capturing `textContent` on elements.
+     *
+     * @default false
+     */
+    mask_all_text: boolean;
+    /**
+     * Used to extend the list of campaign parameters that are saved by default.
+     *
+     * @see {CAMPAIGN_PARAMS} from './utils/event-utils' - Default campaign parameters like utm_source, utm_medium, etc.
+     * @default []
+     */
+    custom_campaign_params: string[];
+    /**
+     * Mask personal data properties from the current URL.
+     * This will mask personal data properties such as advertising IDs (gclid, fbclid, etc.), and you can also add
+     * custom properties to mask with `custom_personal_data_properties`.
+     * @default false
+     * @see {PERSONAL_DATA_CAMPAIGN_PARAMS} - Default campaign parameters that are masked by default.
+     * @see {LeanbaseConfig.custom_personal_data_properties} - Custom list of personal data properties to mask.
+     */
+    mask_personal_data_properties: boolean;
+    /**
+     * Custom list of personal data properties to mask.
+     *
+     * E.g. if you added `email` to this list, then any `email` property in the URL will be masked.
+     * https://www.example.com/login?email=john.doe%40example.com => https://www.example.com/login?email=<MASKED>
+     *
+     * @default []
+     * @see {LeanbaseConfig.mask_personal_data_properties} - Must be enabled for this to take effect.
+     */
+    custom_personal_data_properties: string[];
+    /**
+     * Determines the number of days to store cookies for.
+     *
+     * @default 365
+     */
+    cookie_expiration: number;
+    /**
+     * Determines whether Leanbase should use secure cookies.
+     * If this is `true`, Leanbase cookies will be marked as secure,
+     * meaning they will only be transmitted over HTTPS.
+     *
+     * @default window.location.protocol === 'https:'
+     */
+    secure_cookie: boolean;
+    /**
+     * Determines if cookie should be set on the top level domain (example.com).
+     * If leanbase-js is loaded on a subdomain (test.example.com), and `cross_subdomain_cookie` is set to false,
+     * it'll set the cookie on the subdomain only (test.example.com).
+     *
+     * NOTE: It will be set to `false` if we detect that the domain is a subdomain of a platform that is excluded from cross-subdomain cookie setting.
+     * The current list of excluded platforms is `herokuapp.com`, `vercel.app`, and `netlify.app`.
+     *
+     * @see `isCrossDomainCookie`
+     * @default true
+     */
+    cross_subdomain_cookie: boolean;
+    /**
+     * Determines whether Leanbase should disable persistence.
+     * If set to `true`, the library will not save any data to the browser. It will also delete any data previously saved to the browser.
+     *
+     * @default false
+     */
+    disable_persistence: boolean;
+    /**
+     * Enables cookieless mode. In this mode, Leanbase will not set any cookies, or use session or local storage. User
+     * identity is handled by generating a privacy-preserving hash on Leanbase's servers.
+     * - 'always' - enable cookieless mode immediately on startup, use this if you do not intend to show a cookie banner
+     * - 'on_reject' - enable cookieless mode only if the user rejects cookies, use this if you want to show a cookie banner. If the user accepts cookies, cookieless mode will not be used, and PostHog will use cookies and local storage as usual.
+     *
+     * Note that you MUST enable cookieless mode in your Leanbase project's settings, otherwise all your cookieless events will be ignored. We plan to remove this requirement in the future.
+     * */
+    cookieless_mode?: 'always' | 'on_reject';
+    /**
+     * Determines whether PostHog should save referrer information.
+     *
+     * @default true
+     */
+    save_referrer: boolean;
+    /**
+     * Determines whether PostHog should save marketing parameters.
+     * These are `utm_*` paramaters and friends.
+     *
+     * @see {CAMPAIGN_PARAMS} from './utils/event-utils' - Default campaign parameters like utm_source, utm_medium, etc.
+     * @default true
+     */
+    save_campaign_params: boolean;
+    /**
+     * Determines whether to disable scroll properties.
+     * These allow you to keep track of how far down someone scrolled in your website.
+     *
+     * @default false
+     */
+    disable_scroll_properties?: boolean;
+    /**
+     * Let the pageview scroll stats use a custom css selector for the root element, e.g. `main`
+     * It will use `window.document.documentElement` if not specified.
+     */
+    scroll_root_selector?: string | string[];
+    /**
+     * Determines if users should be opted out of user agent filtering such as googlebot or other bots.
+     * If this is set to `true`, PostHog will set `$browser_type` to either `bot` or `browser` for all events,
+     * but will process all events as if they were from a browser.
+     *
+     * @default false
+     */
+    opt_out_useragent_filter: boolean;
+    /**
+     * Determines the maximum length of the properties string that can be sent with capture calls.
+     *
+     * @default 65535
+     */
+    properties_string_max_length: number;
+    /**
+     * A function to be called once the Leanbase scripts have loaded successfully.
+     *
+     * @param instance - The Leanbase instance that has been loaded.
+     */
+    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
+     * e.g. ['.my-calendar-button']
+     * we consider the tree of elements from the root to the target element of the click event
+     * so for the tree div > div > button > svg
+     * and ignore list config `['[id]']`
+     * we will ignore the rageclick if the click-target or its parents has any id
+     *
+     * Nothing is ignored when there's an empty ignorelist, e.g. []
+     * If no ignorelist is set, we default to ignoring .ph-no-rageclick
+     * If an element has .ph-no-capture, it will always be ignored by rageclick and autocapture
+     */
+    css_selector_ignorelist?: string[];
+}
+type PropertyMatchType = 'regex' | 'not_regex' | 'exact' | 'is_not' | 'icontains' | 'not_icontains';
+interface ErrorTrackingSuppressionRule {
+    type: 'AND' | 'OR';
+    values: ErrorTrackingSuppressionRuleValue[];
+}
+interface ErrorTrackingSuppressionRuleValue {
+    key: '$exception_types' | '$exception_values';
+    operator: PropertyMatchType;
+    value: string | string[];
+    type: string;
+}
+declare enum Compression {
+    GZipJS = "gzip-js",
+    Base64 = "base64"
+}
+type SupportedWebVitalsMetrics = 'LCP' | 'CLS' | 'FCP' | 'INP';
+interface PerformanceCaptureConfig {
+    /**
+     *  Works with session replay to use the browser's native performance observer to capture performance metrics
+     */
+    network_timing?: boolean;
+    /**
+     * Use chrome's web vitals library to wrap fetch and capture web vitals
+     */
+    web_vitals?: boolean;
+    /**
+     * We observe very large values reported by the Chrome web vitals library
+     * These outliers are likely not real, useful values, and we exclude them
+     * You can set this to 0 in order to include all values, NB this is not recommended
+     *
+     * @default 15 * 60 * 1000 (15 minutes)
+     */
+    __web_vitals_max_value?: number;
+    /**
+     * By default all 4 metrics are captured
+     * You can set this config to restrict which metrics are captured
+     * e.g. ['CLS', 'FCP'] to only capture those two metrics
+     * NB setting this does not override whether the capture is enabled
+     *
+     * @default ['LCP', 'CLS', 'FCP', 'INP']
+     */
+    web_vitals_allowed_metrics?: SupportedWebVitalsMetrics[];
+    /**
+     * We delay flushing web vitals metrics to reduce the number of events we send
+     * This is the maximum time we will wait before sending the metrics
+     *
+     * @default 5000
+     */
+    web_vitals_delayed_flush_ms?: number;
+}
+/**
+ * Remote configuration for the Leanbase instance
+ *
+ * All of these settings can be configured directly in your Leanbase instance
+ * Any configuration set in the client overrides the information from the server
+ */
+interface RemoteConfig {
+    /**
+     * Supported compression algorithms
+     */
+    supportedCompression: Compression[];
+    /**
+     * If set, disables autocapture
+     */
+    autocapture_opt_out?: boolean;
+    /**
+     *     originally capturePerformance was replay only and so boolean true
+     *     is equivalent to { network_timing: true }
+     *     now capture performance can be separately enabled within replay
+     *     and as a standalone web vitals tracker
+     *     people can have them enabled separately
+     *     they work standalone but enhance each other
+     *     TODO: deprecate this so we make a new config that doesn't need this explanation
+     */
+    capturePerformance?: boolean | PerformanceCaptureConfig;
+    /**
+     * Whether we should use a custom endpoint for analytics
+     *
+     * @default { endpoint: "/e" }
+     */
+    analytics?: {
+        endpoint?: string;
+    };
+    /**
+     * Whether the `$elements_chain` property should be sent as a string or as an array
+     *
+     * @default false
+     */
+    elementsChainAsString?: boolean;
+    /**
+     * Error tracking configuration options
+     */
+    errorTracking?: {
+        autocaptureExceptions?: boolean;
+        captureExtensionExceptions?: boolean;
+        suppressionRules?: ErrorTrackingSuppressionRule[];
+    };
+    /**
+     * This is currently in development and may have breaking changes without a major version bump
+     */
+    autocaptureExceptions?: boolean | {
+        endpoint?: string;
+    };
+    /**
+     * Session recording configuration options
+     */
+    sessionRecording?: SessionRecordingRemoteConfig | false;
+    /**
+     * @deprecated, moved to toolbarParams
+     */
+    toolbarVersion: 'toolbar';
+    /**
+     * Whether the user is authenticated
+     */
+    isAuthenticated: boolean;
+    /**
+     * List of site apps with their IDs and URLs
+     */
+    siteApps: {
+        id: string;
+        url: string;
+    }[];
+    /**
+     * Whether heatmaps are enabled
+     */
+    heatmaps?: boolean;
+    /**
+     * Whether to only capture identified users by default
+     */
+    defaultIdentifiedOnly?: boolean;
+    /**
+     * Whether to capture dead clicks
+     */
+    captureDeadClicks?: boolean;
+    /**
+     * Indicates if the team has any flags enabled (if not we don't need to load them)
+     */
+    hasFeatureFlags?: boolean;
+}
+interface RequestResponse {
+    statusCode: number;
+    text?: string;
+    json?: any;
+}
+type RequestCallback = (response: RequestResponse) => void;
+type NextOptions = {
+    revalidate: false | 0 | number;
+    tags: string[];
+};
+interface RequestWithOptions {
+    url: string;
+    data?: Record<string, any> | Record<string, any>[];
+    headers?: Record<string, any>;
+    transport?: 'XHR' | 'fetch' | 'sendBeacon';
+    method?: 'POST' | 'GET';
+    urlQueryArgs?: {
+        compression: Compression;
+    };
+    callback?: RequestCallback;
+    timeout?: number;
+    noRetries?: boolean;
+    disableTransport?: ('XHR' | 'fetch' | 'sendBeacon')[];
+    disableXHRCredentials?: boolean;
+    compression?: Compression | 'best-available';
+    fetchOptions?: {
+        cache?: RequestInit['cache'];
+        next?: NextOptions;
+    };
+}
+type InitiatorType = 'audio' | 'beacon' | 'body' | 'css' | '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;
+    sessionPastMaximumLength: boolean;
+}) => void;
+type LeanbasegCaptureOptions = {
+    /** If provided overrides the auto-generated event ID */
+    uuid?: string;
+    disableGeoip?: boolean;
+    /**
+     * Used when `$identify` is called
+     * Will set person properties overriding previous values
+     */
+    $set?: Properties;
+    /**
+     * Used when `$identify` is called
+     * Will set person properties but only once, it will NOT override previous values
+     */
+    $set_once?: Properties;
+    /**
+     * Used to override the desired endpoint for the captured event
+     */
+    _url?: string;
+    /**
+     * key of queue, e.g. 'sessionRecording' vs 'event'
+     */
+    _batchKey?: string;
+    /**
+     * If set, overrides and disables config.properties_string_max_length
+     */
+    _noTruncate?: boolean;
+    /**
+     * If set, skips the batched queue
+     */
+    send_instantly?: boolean;
+    /**
+     * If set, skips the client side rate limiting
+     */
+    skip_client_rate_limiting?: boolean;
+    /**
+     * If set, overrides the desired transport method
+     */
+    transport?: RequestWithOptions['transport'];
+    /**
+     * If set, overrides the current timestamp
+     */
+    timestamp?: Date;
+};
+
+/**
+ * Leanbase Persistence Object
+ * @constructor
+ */
+declare class LeanbasePersistence {
+    private _config;
+    props: Properties;
+    private _storage;
+    private _campaign_params_saved;
+    private readonly _name;
+    _disabled: boolean | undefined;
+    private _secure;
+    private _expire_days;
+    private _default_expiry;
+    private _cross_subdomain;
+    /**
+     * @param {LeanbaseConfig} config initial PostHog configuration
+     * @param {boolean=} isDisabled should persistence be disabled (e.g. because of consent management)
+     */
+    constructor(config: LeanbaseConfig, isDisabled?: boolean);
+    /**
+     * Returns whether persistence is disabled. Only available in SDKs > 1.257.1. Do not use on extensions, otherwise
+     * it'll break backwards compatibility for any version before 1.257.1.
+     */
+    isDisabled?(): boolean;
+    private _buildStorage;
+    properties(): Properties;
+    load(): void;
+    /**
+     * NOTE: Saving frequently causes issues with Recordings and Consent Management Platform (CMP) tools which
+     * observe cookie changes, and modify their UI, often causing infinite loops.
+     * As such callers of this should ideally check that the data has changed beforehand
+     */
+    save(): void;
+    remove(): void;
+    clear(): void;
+    /**
+     * @param {Object} props
+     * @param {*=} default_value
+     * @param {number=} days
+     */
+    register_once(props: Properties, default_value: any, days?: number): boolean;
+    /**
+     * @param {Object} props
+     * @param {number=} days
+     */
+    register(props: Properties, days?: number): boolean;
+    unregister(prop: string): void;
+    update_campaign_params(): void;
+    update_search_keyword(): void;
+    update_referrer_info(): void;
+    set_initial_person_info(): void;
+    get_initial_props(): Properties;
+    safe_merge(props: Properties): Properties;
+    update_config(config: LeanbaseConfig, oldConfig: LeanbaseConfig, isDisabled?: boolean): void;
+    set_disabled(disabled: boolean): void;
+    set_cross_subdomain(cross_subdomain: boolean): void;
+    set_secure(secure: boolean): void;
+    set_event_timer(event_name: string, timestamp: number): void;
+    remove_event_timer(event_name: string): number;
+    get_property(prop: string): any;
+    set_property(prop: string, to: any): void;
+}
+
+declare class RageClick {
+    clicks: {
+        x: number;
+        y: number;
+        timestamp: number;
+    }[];
+    constructor();
+    isRageClick(x: number, y: number, timestamp: number): boolean;
+}
+
+declare class Autocapture {
+    instance: Leanbase;
+    _initialized: boolean;
+    _isDisabledServerSide: boolean | null;
+    _elementSelectors: Set<string> | null;
+    rageclicks: RageClick;
+    _elementsChainAsString: boolean;
+    constructor(instance: Leanbase);
+    private get _config();
+    _addDomEventHandlers(): void;
+    startIfEnabled(): void;
+    onRemoteConfig(response: RemoteConfig): void;
+    setElementSelectors(selectors: Set<string>): void;
+    getElementSelectors(element: Element | null): string[] | null;
+    get isEnabled(): boolean;
+    private _captureEvent;
+    isBrowserSupported(): boolean;
+}
+
+declare class SessionIdManager {
+    private readonly _sessionIdGenerator;
+    private readonly _windowIdGenerator;
+    private _config;
+    private _persistence;
+    private _windowId;
+    private _sessionId;
+    private readonly _window_id_storage_key;
+    private readonly _primary_window_exists_storage_key;
+    private _sessionStartTimestamp;
+    private _sessionActivityTimestamp;
+    private _sessionIdChangedHandlers;
+    private readonly _sessionTimeoutMs;
+    private _enforceIdleTimeout;
+    private _beforeUnloadListener;
+    private _eventEmitter;
+    on(event: 'forcedIdleReset', handler: () => void): () => void;
+    constructor(instance: Leanbase, sessionIdGenerator?: () => string, windowIdGenerator?: () => string);
+    get sessionTimeoutMs(): number;
+    onSessionId(callback: SessionIdChangedCallback): () => void;
+    private _canUseSessionStorage;
+    private _setWindowId;
+    private _getWindowId;
+    private _setSessionId;
+    private _getSessionId;
+    resetSessionId(): void;
+    /**
+     * Cleans up resources used by SessionIdManager.
+     * Should be called when the SessionIdManager is no longer needed to prevent memory leaks.
+     */
+    destroy(): void;
+    private _listenToReloadWindow;
+    private _sessionHasBeenIdleTooLong;
+    checkAndGetSessionAndWindowId(readOnly?: boolean, _timestamp?: number | null): {
+        sessionId: string;
+        windowId: string;
+        sessionStartTimestamp: number;
+        changeReason: {
+            noSessionId: boolean;
+            activityTimeout: boolean;
+            sessionPastMaximumLength: boolean;
+        } | undefined;
+        lastActivityTimestamp: number;
+    };
+    private _resetIdleTimer;
+}
+
+interface LegacySessionSourceProps {
+    initialPathName: string;
+    referringDomain: string;
+    utm_medium?: string;
+    utm_source?: string;
+    utm_campaign?: string;
+    utm_content?: string;
+    utm_term?: string;
+}
+interface CurrentSessionSourceProps {
+    r: string;
+    u: string | undefined;
+}
+interface StoredSessionSourceProps {
+    sessionId: string;
+    props: LegacySessionSourceProps | CurrentSessionSourceProps;
+}
+declare class SessionPropsManager {
+    private readonly _instance;
+    private readonly _sessionIdManager;
+    private readonly _persistence;
+    private readonly _sessionSourceParamGenerator;
+    constructor(instance: Leanbase, sessionIdManager: SessionIdManager, persistence: LeanbasePersistence, sessionSourceParamGenerator?: (instance?: Leanbase) => LegacySessionSourceProps | CurrentSessionSourceProps);
+    _getStored(): StoredSessionSourceProps | undefined;
+    _onSessionIdCallback: (sessionId: string) => void;
+    getSetOnceProps(): Record<string, any>;
+    getSessionProps(): Record<string, any>;
+}
+
+interface PageViewEventProperties {
+    $pageview_id?: string;
+    $prev_pageview_id?: string;
+    $prev_pageview_pathname?: string;
+    $prev_pageview_duration?: number;
+    $prev_pageview_last_scroll?: number;
+    $prev_pageview_last_scroll_percentage?: number;
+    $prev_pageview_max_scroll?: number;
+    $prev_pageview_max_scroll_percentage?: number;
+    $prev_pageview_last_content?: number;
+    $prev_pageview_last_content_percentage?: number;
+    $prev_pageview_max_content?: number;
+    $prev_pageview_max_content_percentage?: number;
+}
+declare class PageViewManager {
+    _currentPageview?: {
+        timestamp: Date;
+        pageViewId: string | undefined;
+        pathname: string | undefined;
+    };
+    _instance: Leanbase;
+    constructor(instance: Leanbase);
+    doPageView(timestamp: Date, pageViewId?: string): PageViewEventProperties;
+    doPageLeave(timestamp: Date): PageViewEventProperties;
+    doEvent(): PageViewEventProperties;
+    private _previousPageViewProperties;
+}
+
+interface ScrollContext {
+    maxScrollHeight?: number;
+    maxScrollY?: number;
+    lastScrollY?: number;
+    maxContentHeight?: number;
+    maxContentY?: number;
+    lastContentY?: number;
+}
+declare class ScrollManager {
+    private _instance;
+    private _context;
+    constructor(_instance: Leanbase);
+    getContext(): ScrollContext | undefined;
+    resetContext(): ScrollContext | undefined;
+    private _updateScrollData;
+    startMeasuringScrollPosition(): void;
+    scrollElement(): Element | undefined;
+    scrollY(): number;
+    scrollX(): number;
+}
+
+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 _serverRecordingEnabled;
+    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 _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;
+    pageViewManager: PageViewManager;
+    replayAutocapture?: Autocapture;
+    persistence?: LeanbasePersistence;
+    sessionPersistence?: LeanbasePersistence;
+    sessionManager?: SessionIdManager;
+    sessionPropsManager?: SessionPropsManager;
+    sessionRecording?: SessionRecording;
+    isRemoteConfigLoaded?: boolean;
+    personProcessingSetOncePropertiesSent: boolean;
+    isLoaded: boolean;
+    initialPageviewCaptured: boolean;
+    visibilityStateListener: (() => void) | null;
+    constructor(token: string, config?: Partial<LeanbaseConfig>);
+    init(token: string, config: Partial<LeanbaseConfig>): void;
+    captureInitialPageview(): void;
+    capturePageLeave(): void;
+    loadRemoteConfig(): Promise<void>;
+    onRemoteConfig(config: RemoteConfig): void;
+    fetch(url: string, options: PostHogFetchOptions): Promise<PostHogFetchResponse>;
+    setConfig(config: Partial<LeanbaseConfig>): void;
+    getLibraryId(): string;
+    getLibraryVersion(): string;
+    getCustomUserAgent(): void;
+    getPersistedProperty<T>(key: PostHogPersistedProperty): T | undefined;
+    get_property<T = any>(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;
+    /**
+     * Add additional set_once properties to the event when creating a person profile. This allows us to create the
+     * profile with mostly-accurate properties, despite earlier events not setting them. We do this by storing them in
+     * persistence.
+     * @param dataSetOnce
+     */
+    calculateSetOnceProperties(dataSetOnce?: Properties): Properties | undefined;
+    capture(event: string, properties?: PostHogEventProperties, options?: LeanbasegCaptureOptions): void;
+    identify(distinctId?: string, properties?: PostHogEventProperties, options?: LeanbasegCaptureOptions): void;
+    destroy(): void;
+}
+
+export { Leanbase, type LeanbaseConfig as LeanbaseOptions };