@sprig-technologies/sprig-bundled 2.24.7 → 2.35.0

package/dist/index.d.ts

@@ -1,1485 +1,637 @@
-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 attributes = {
-    [key: string]: string | number | true | null;
-};
-type elementNode = {
-    type: NodeType.Element;
-    tagName: string;
-    attributes: attributes;
-    childNodes: serializedNodeWithId[];
-    isSVG?: true;
-    needBlock?: boolean;
-};
-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;
-};
-interface INode extends Node {
-    __sn: serializedNodeWithId;
-}
-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;
-}
-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 SlimDOMOptions = Partial<{
-    script: boolean;
-    comment: boolean;
-    headFavicon: boolean;
-    headWhitespace: boolean;
-    headMetaDescKeywords: boolean;
-    headMetaSocial: boolean;
-    headMetaRobots: boolean;
-    headMetaHttpEquiv: boolean;
-    headMetaAuthorship: boolean;
-    headMetaVerification: boolean;
-}>;
-type DataURLOptions = Partial<{
-    type: string;
-    quality: number;
-}>;
-type MaskTextFn = (text: string) => string;
-type MaskInputFn = (text: string, element: HTMLElement) => string;
-
-declare class Mirror$1 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;
-}
-
-declare enum EventType {
-    DomContentLoaded = 0,
-    Load = 1,
-    FullSnapshot = 2,
-    IncrementalSnapshot = 3,
-    Meta = 4,
-    Custom = 5,
-    Plugin = 6
-}
-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 incrementalSnapshotEvent = {
-    type: EventType.IncrementalSnapshot;
-    data: incrementalData;
-};
-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;
-    };
-};
-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
-}
-type mutationData = {
-    source: IncrementalSource.Mutation;
-} & mutationCallbackParam;
-type mousemoveData = {
-    source: IncrementalSource.MouseMove | IncrementalSource.TouchMove | IncrementalSource.Drag;
-    positions: mousePosition[];
-};
-type mouseInteractionData = {
-    source: IncrementalSource.MouseInteraction;
-} & mouseInteractionParam;
-type scrollData = {
-    source: IncrementalSource.Scroll;
-} & scrollPosition;
-type viewportResizeData = {
-    source: IncrementalSource.ViewportResize;
-} & viewportResizeDimension;
-type inputData = {
-    source: IncrementalSource.Input;
-    id: number;
-} & inputValue;
-type mediaInteractionData = {
-    source: IncrementalSource.MediaInteraction;
-} & mediaInteractionParam;
-type styleSheetRuleData = {
-    source: IncrementalSource.StyleSheetRule;
-} & styleSheetRuleParam;
-type styleDeclarationData = {
-    source: IncrementalSource.StyleDeclaration;
-} & styleDeclarationParam;
-type canvasMutationData = {
-    source: IncrementalSource.CanvasMutation;
-} & canvasMutationParam;
-type fontData = {
-    source: IncrementalSource.Font;
-} & fontParam;
-type selectionData = {
-    source: IncrementalSource.Selection;
-} & selectionParam;
-type adoptedStyleSheetData = {
-    source: IncrementalSource.AdoptedStyleSheet;
-} & adoptedStyleSheetParam;
-type incrementalData = mutationData | mousemoveData | mouseInteractionData | scrollData | viewportResizeData | inputData | mediaInteractionData | styleSheetRuleData | canvasMutationData | fontData | selectionData | styleDeclarationData | adoptedStyleSheetData;
-type event = domContentLoadedEvent | loadedEvent | fullSnapshotEvent | incrementalSnapshotEvent | metaEvent | customEvent | pluginEvent;
-type eventWithTime = event & {
-    timestamp: number;
-    delay?: number;
-};
-type canvasEventWithTime = eventWithTime & {
-    type: EventType.IncrementalSnapshot;
-    data: canvasMutationData;
-};
-type blockClass = string | RegExp;
-type maskTextClass = string | RegExp;
-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$1;
-        crossOriginIframeMirror: ICrossOriginIframeMirror;
-        crossOriginIframeStyleMirror: ICrossOriginIframeMirror;
-    }) => void;
-    options: TOptions;
-};
-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;
-};
-type textMutation = {
-    id: number;
-    value: string | null;
-};
-type styleOMValue = {
-    [key: string]: styleValueWithPriority | string | false;
-};
-type styleValueWithPriority = [string, string];
-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 mutationCallBack = (m: mutationCallbackParam) => void;
-type mousemoveCallBack = (p: mousePosition[], source: IncrementalSource.MouseMove | IncrementalSource.TouchMove | IncrementalSource.Drag) => void;
-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
-}
-declare enum CanvasContext {
-    '2D' = 0,
-    WebGL = 1,
-    WebGL2 = 2
-}
-type mouseInteractionParam = {
-    type: MouseInteractions;
-    id: number;
-    x: number;
-    y: number;
-    pointerType?: PointerTypes;
-};
-type mouseInteractionCallBack = (d: mouseInteractionParam) => void;
-type scrollPosition = {
-    id: number;
-    x: number;
-    y: number;
-};
-type scrollCallback = (p: scrollPosition) => void;
-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 styleSheetRuleCallback = (s: styleSheetRuleParam) => void;
-type adoptedStyleSheetParam = {
-    id: number;
-    styles?: {
-        styleId: number;
-        rules: styleSheetAddRule[];
-    }[];
-    styleIds: number[];
-};
-type styleDeclarationParam = {
-    id?: number;
-    styleId?: number;
-    index: number[];
-    set?: {
-        property: string;
-        value: string | null;
-        priority: string | undefined;
-    };
-    remove?: {
-        property: string;
-    };
-};
-type styleDeclarationCallback = (s: styleDeclarationParam) => void;
-type canvasMutationCommand = {
-    property: string;
-    args: Array<unknown>;
-    setter?: true;
-};
-type canvasMutationParam = {
-    id: number;
-    type: CanvasContext;
-    commands: canvasMutationCommand[];
-} | ({
-    id: number;
-    type: CanvasContext;
-} & canvasMutationCommand);
-type canvasMutationCallback = (p: canvasMutationParam) => void;
-type fontParam = {
-    family: string;
-    fontSource: string;
-    buffer: boolean;
-    descriptors?: FontFaceDescriptors;
-};
-type fontCallback = (p: fontParam) => void;
-type viewportResizeDimension = {
-    width: number;
-    height: number;
-};
-type viewportResizeCallback = (d: viewportResizeDimension) => void;
-type inputValue = {
-    text: string;
-    isChecked: boolean;
-    userTriggered?: boolean;
-};
-type inputCallback = (v: inputValue & {
-    id: number;
-}) => void;
-declare const enum MediaInteractions {
-    Play = 0,
-    Pause = 1,
-    Seeked = 2,
-    VolumeChange = 3,
-    RateChange = 4
-}
-type mediaInteractionParam = {
-    type: MediaInteractions;
-    id: number;
-    currentTime?: number;
-    volume?: number;
-    muted?: boolean;
-    playbackRate?: number;
-};
-type mediaInteractionCallback = (p: mediaInteractionParam) => void;
-type DocumentDimension = {
-    x: number;
-    y: number;
-    relativeScale: number;
-    absoluteScale: number;
-};
-type SelectionRange = {
-    start: number;
-    startOffset: number;
-    end: number;
-    endOffset: number;
-};
-type selectionParam = {
-    ranges: Array<SelectionRange>;
-};
-type selectionCallback = (p: selectionParam) => void;
-type DeprecatedMirror = {
-    map: {
-        [key: number]: INode;
-    };
-    getId: (n: Node) => number;
-    getNode: (id: number) => INode | null;
-    removeNodeFromMap: (n: Node) => void;
-    has: (id: number) => boolean;
-    reset: () => void;
-};
-type throttleOptions = {
-    leading?: boolean;
-    trailing?: boolean;
-};
-type listenerHandler = () => void;
-type hookResetter = () => void;
-type playerMetaData = {
-    startTime: number;
-    endTime: number;
-    totalTime: number;
-};
-type actionWithDelay = {
-    doAction: () => void;
-    delay: number;
-};
-type Handler = (event?: unknown) => void;
-type Emitter$1 = {
-    on(type: string, handler: Handler): void;
-    emit(type: string, event?: unknown): void;
-    off(type: string, handler: Handler): void;
-};
-declare enum ReplayerEvents {
-    Start = "start",
-    Pause = "pause",
-    Resume = "resume",
-    Resize = "resize",
-    Finish = "finish",
-    FullsnapshotRebuilded = "fullsnapshot-rebuilded",
-    LoadStylesheetStart = "load-stylesheet-start",
-    LoadStylesheetEnd = "load-stylesheet-end",
-    SkipStart = "skip-start",
-    SkipEnd = "skip-end",
-    MouseInteraction = "mouse-interaction",
-    EventCast = "event-cast",
-    CustomEvent = "custom-event",
-    Flush = "flush",
-    StateChange = "state-change",
-    PlayBack = "play-back",
-    Destroy = "destroy"
-}
-type KeepIframeSrcFn = (src: string) => boolean;
-declare global {
-    interface Window {
-        FontFace: typeof FontFace;
-    }
-}
-type IWindow = Window & typeof globalThis;
-
-type PackFn = (event: eventWithTime) => string;
-type UnpackFn = (raw: string) => eventWithTime;
-
-interface IRRNode {
-    parentElement: IRRNode | null;
-    parentNode: IRRNode | null;
-    ownerDocument: IRRDocument;
-    readonly childNodes: IRRNode[];
-    readonly ELEMENT_NODE: number;
-    readonly TEXT_NODE: number;
-    readonly nodeType: number;
-    readonly nodeName: string;
-    readonly RRNodeType: NodeType;
-    firstChild: IRRNode | null;
-    lastChild: IRRNode | null;
-    previousSibling: IRRNode | null;
-    nextSibling: IRRNode | null;
-    textContent: string | null;
-    contains(node: IRRNode): boolean;
-    appendChild(newChild: IRRNode): IRRNode;
-    insertBefore(newChild: IRRNode, refChild: IRRNode | null): IRRNode;
-    removeChild(node: IRRNode): IRRNode;
-    toString(): string;
-}
-interface IRRDocument extends IRRNode {
-    documentElement: IRRElement | null;
-    body: IRRElement | null;
-    head: IRRElement | null;
-    implementation: IRRDocument;
-    firstElementChild: IRRElement | null;
-    readonly nodeName: '#document';
-    compatMode: 'BackCompat' | 'CSS1Compat';
-    createDocument(_namespace: string | null, _qualifiedName: string | null, _doctype?: DocumentType | null): IRRDocument;
-    createDocumentType(qualifiedName: string, publicId: string, systemId: string): IRRDocumentType;
-    createElement(tagName: string): IRRElement;
-    createElementNS(_namespaceURI: string, qualifiedName: string): IRRElement;
-    createTextNode(data: string): IRRText;
-    createComment(data: string): IRRComment;
-    createCDATASection(data: string): IRRCDATASection;
-    open(): void;
-    close(): void;
-    write(content: string): void;
-}
-interface IRRElement extends IRRNode {
+declare type attributes = {
+    [key: string]: string | number | true | null;
+};
+
+declare type cdataNode = {
+    type: NodeType.CDATA;
+    textContent: '';
+};
+
+declare type commentNode = {
+    type: NodeType.Comment;
+    textContent: string;
+};
+
+declare type DataURLOptions = Partial<{
+    type: string;
+    quality: number;
+}>;
+
+declare type documentNode = {
+    type: NodeType.Document;
+    childNodes: serializedNodeWithId[];
+    compatMode?: string;
+};
+
+declare type documentTypeNode = {
+    type: NodeType.DocumentType;
+    name: string;
+    publicId: string;
+    systemId: string;
+};
+
+declare type elementNode = {
+    type: NodeType.Element;
     tagName: string;
-    attributes: Record<string, string>;
-    shadowRoot: IRRElement | null;
-    scrollLeft?: number;
-    scrollTop?: number;
-    id: string;
-    className: string;
-    classList: ClassList;
-    style: CSSStyleDeclaration;
-    attachShadow(init: ShadowRootInit): IRRElement;
-    getAttribute(name: string): string | null;
-    setAttribute(name: string, attribute: string): void;
-    setAttributeNS(namespace: string | null, qualifiedName: string, value: string): void;
-    removeAttribute(name: string): void;
-    dispatchEvent(event: Event): boolean;
-}
-interface IRRDocumentType extends IRRNode {
-    readonly name: string;
-    readonly publicId: string;
-    readonly systemId: string;
-}
-interface IRRText extends IRRNode {
-    readonly nodeName: '#text';
-    data: string;
-}
-interface IRRComment extends IRRNode {
-    readonly nodeName: '#comment';
-    data: string;
-}
-interface IRRCDATASection extends IRRNode {
-    readonly nodeName: '#cdata-section';
-    data: string;
+    attributes: attributes;
+    childNodes: serializedNodeWithId[];
+    isSVG?: true;
+    needBlock?: boolean;
+    isCustom?: true;
+};
+
+declare 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 BaseRRNode implements IRRNode {
-    parentElement: IRRNode | null;
-    parentNode: IRRNode | null;
-    ownerDocument: IRRDocument;
-    firstChild: IRRNode | null;
-    lastChild: IRRNode | null;
-    previousSibling: IRRNode | null;
-    nextSibling: IRRNode | null;
-    textContent: string | null;
-    readonly ELEMENT_NODE: number;
-    readonly TEXT_NODE: number;
-    readonly nodeType: number;
-    readonly nodeName: string;
-    readonly RRNodeType: NodeType;
-    constructor(..._args: any[]);
-    get childNodes(): IRRNode[];
-    contains(node: IRRNode): boolean;
-    appendChild(_newChild: IRRNode): IRRNode;
-    insertBefore(_newChild: IRRNode, _refChild: IRRNode | null): IRRNode;
-    removeChild(_node: IRRNode): IRRNode;
-    toString(): string;
+
+declare type MaskInputFn = (text: string, element: HTMLElement) => string;
+
+declare 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;
+}>;
+
+declare type MaskTextFn = (text: string, element: HTMLElement | null) => string;
+
+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;
 }
-declare class ClassList {
-    private onChange;
-    classes: string[];
-    constructor(classText?: string, onChange?: ((newClassText: string) => void) | undefined);
-    add: (...classNames: string[]) => void;
-    remove: (...classNames: string[]) => void;
+
+declare enum NodeType {
+    Document = 0,
+    DocumentType = 1,
+    Element = 2,
+    Text = 3,
+    CDATA = 4,
+    Comment = 5
 }
-type CSSStyleDeclaration = Record<string, string> & {
-    setProperty: (name: string, value: string | null, priority?: string | null) => void;
-    removeProperty: (name: string) => string;
+
+declare type serializedNode = (documentNode | documentTypeNode | elementNode | textNode | cdataNode | commentNode) & {
+    rootId?: number;
+    isShadowHost?: boolean;
+    isShadow?: boolean;
+};
+
+declare type serializedNodeWithId = serializedNode & {
+    id: number;
+};
+
+declare 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;
+}>;
+
+declare type textNode = {
+    type: NodeType.Text;
+    textContent: string;
+    isStyle?: true;
 };
 
-declare const RRDocument_base: {
-    new (...args: any[]): {
-        readonly nodeType: number;
-        readonly nodeName: "#document";
-        readonly compatMode: "BackCompat" | "CSS1Compat";
-        readonly RRNodeType: NodeType.Document;
-        readonly documentElement: IRRElement | null;
-        readonly body: IRRElement | null;
-        readonly head: IRRElement | null;
-        readonly implementation: IRRDocument;
-        readonly firstElementChild: IRRElement | null;
-        appendChild(newChild: IRRNode): IRRNode;
-        insertBefore(newChild: IRRNode, refChild: IRRNode | null): IRRNode;
-        removeChild(node: IRRNode): IRRNode;
-        open(): void;
-        close(): void;
-        write(content: string): void;
-        createDocument(_namespace: string | null, _qualifiedName: string | null, _doctype?: DocumentType | null | undefined): IRRDocument;
-        createDocumentType(qualifiedName: string, publicId: string, systemId: string): IRRDocumentType;
-        createElement(tagName: string): IRRElement;
-        createElementNS(_namespaceURI: string, qualifiedName: string): IRRElement;
-        createTextNode(data: string): IRRText;
-        createComment(data: string): IRRComment;
-        createCDATASection(data: string): IRRCDATASection;
-        toString(): string;
-        parentElement: IRRNode | null;
-        parentNode: IRRNode | null;
-        ownerDocument: IRRDocument;
-        readonly childNodes: IRRNode[];
-        readonly ELEMENT_NODE: number;
-        readonly TEXT_NODE: number;
-        firstChild: IRRNode | null;
-        lastChild: IRRNode | null;
-        previousSibling: IRRNode | null;
-        nextSibling: IRRNode | null;
-        textContent: string | null;
-        contains(node: IRRNode): boolean;
+declare type addedNodeMutation = {
+    parentId: number;
+    previousId?: number | null;
+    nextId: number | null;
+    node: serializedNodeWithId;
+};
+
+declare type adoptedStyleSheetData = {
+    source: IncrementalSource.AdoptedStyleSheet;
+} & adoptedStyleSheetParam;
+
+declare type adoptedStyleSheetParam = {
+    id: number;
+    styles?: {
+        styleId: number;
+        rules: styleSheetAddRule[];
+    }[];
+    styleIds: number[];
+};
+
+declare type attributeMutation = {
+    id: number;
+    attributes: {
+        [key: string]: string | styleOMValue | null;
     };
-} & typeof BaseRRNode;
-declare class RRDocument extends RRDocument_base {
-    private UNSERIALIZED_STARTING_ID;
-    private _unserializedId;
-    get unserializedId(): number;
-    mirror: Mirror;
-    scrollData: scrollData | null;
-    constructor(mirror?: Mirror);
-    createDocument(_namespace: string | null, _qualifiedName: string | null, _doctype?: DocumentType | null): RRDocument;
-    createDocumentType(qualifiedName: string, publicId: string, systemId: string): {
-        readonly nodeType: number;
-        readonly RRNodeType: NodeType.DocumentType;
-        readonly nodeName: string;
-        readonly name: string;
-        readonly publicId: string;
-        readonly systemId: string;
-        toString(): string;
-        parentElement: IRRNode | null;
-        parentNode: IRRNode | null;
-        ownerDocument: IRRDocument;
-        readonly childNodes: IRRNode[];
-        readonly ELEMENT_NODE: number;
-        readonly TEXT_NODE: number;
-        firstChild: IRRNode | null;
-        lastChild: IRRNode | null;
-        previousSibling: IRRNode | null;
-        nextSibling: IRRNode | null;
-        textContent: string | null;
-        contains(node: IRRNode): boolean;
-        appendChild(newChild: IRRNode): IRRNode;
-        insertBefore(newChild: IRRNode, refChild: IRRNode | null): IRRNode;
-        removeChild(node: IRRNode): IRRNode;
-    } & BaseRRNode;
-    createElement<K extends keyof HTMLElementTagNameMap>(tagName: K): RRElementType<K>;
-    createElement(tagName: string): RRElement;
-    createComment(data: string): {
-        readonly nodeType: number;
-        readonly nodeName: "#comment";
-        readonly RRNodeType: NodeType.Comment;
-        data: string;
-        textContent: string;
-        toString(): string;
-        parentElement: IRRNode | null;
-        parentNode: IRRNode | null;
-        ownerDocument: IRRDocument;
-        readonly childNodes: IRRNode[];
-        readonly ELEMENT_NODE: number;
-        readonly TEXT_NODE: number;
-        firstChild: IRRNode | null;
-        lastChild: IRRNode | null;
-        previousSibling: IRRNode | null;
-        nextSibling: IRRNode | null;
-        contains(node: IRRNode): boolean;
-        appendChild(newChild: IRRNode): IRRNode;
-        insertBefore(newChild: IRRNode, refChild: IRRNode | null): IRRNode;
-        removeChild(node: IRRNode): IRRNode;
-    } & BaseRRNode;
-    createCDATASection(data: string): {
-        readonly nodeName: "#cdata-section";
-        readonly nodeType: number;
-        readonly RRNodeType: NodeType.CDATA;
-        data: string;
-        textContent: string;
-        toString(): string;
-        parentElement: IRRNode | null;
-        parentNode: IRRNode | null;
-        ownerDocument: IRRDocument;
-        readonly childNodes: IRRNode[];
-        readonly ELEMENT_NODE: number;
-        readonly TEXT_NODE: number;
-        firstChild: IRRNode | null;
-        lastChild: IRRNode | null;
-        previousSibling: IRRNode | null;
-        nextSibling: IRRNode | null;
-        contains(node: IRRNode): boolean;
-        appendChild(newChild: IRRNode): IRRNode;
-        insertBefore(newChild: IRRNode, refChild: IRRNode | null): IRRNode;
-        removeChild(node: IRRNode): IRRNode;
-    } & BaseRRNode;
-    createTextNode(data: string): {
-        readonly nodeType: number;
-        readonly nodeName: "#text";
-        readonly RRNodeType: NodeType.Text;
-        data: string;
-        textContent: string;
-        toString(): string;
-        parentElement: IRRNode | null;
-        parentNode: IRRNode | null;
-        ownerDocument: IRRDocument;
-        readonly childNodes: IRRNode[];
-        readonly ELEMENT_NODE: number;
-        readonly TEXT_NODE: number;
-        firstChild: IRRNode | null;
-        lastChild: IRRNode | null;
-        previousSibling: IRRNode | null;
-        nextSibling: IRRNode | null;
-        contains(node: IRRNode): boolean;
-        appendChild(newChild: IRRNode): IRRNode;
-        insertBefore(newChild: IRRNode, refChild: IRRNode | null): IRRNode;
-        removeChild(node: IRRNode): IRRNode;
-    } & BaseRRNode;
-    destroyTree(): void;
-    open(): void;
+};
+
+declare type blockClass = string | RegExp;
+
+declare enum CanvasContext {
+    '2D' = 0,
+    WebGL = 1,
+    WebGL2 = 2
 }
-declare const RRElement_base: {
-    new (tagName: string): {
-        readonly nodeType: number;
-        readonly RRNodeType: NodeType.Element;
-        readonly nodeName: string;
-        tagName: string;
-        attributes: Record<string, string>;
-        shadowRoot: IRRElement | null;
-        scrollLeft?: number | undefined;
-        scrollTop?: number | undefined;
-        textContent: string;
-        readonly classList: ClassList;
-        readonly id: string;
-        readonly className: string;
-        readonly style: CSSStyleDeclaration;
-        getAttribute(name: string): string | null;
-        setAttribute(name: string, attribute: string): void;
-        setAttributeNS(_namespace: string | null, qualifiedName: string, value: string): void;
-        removeAttribute(name: string): void;
-        appendChild(newChild: IRRNode): IRRNode;
-        insertBefore(newChild: IRRNode, refChild: IRRNode | null): IRRNode;
-        removeChild(node: IRRNode): IRRNode;
-        attachShadow(_init: ShadowRootInit): IRRElement;
-        dispatchEvent(_event: Event): boolean;
-        toString(): string;
-        parentElement: IRRNode | null;
-        parentNode: IRRNode | null;
-        ownerDocument: IRRDocument;
-        readonly childNodes: IRRNode[];
-        readonly ELEMENT_NODE: number;
-        readonly TEXT_NODE: number;
-        firstChild: IRRNode | null;
-        lastChild: IRRNode | null;
-        previousSibling: IRRNode | null;
-        nextSibling: IRRNode | null;
-        contains(node: IRRNode): boolean;
+
+declare type canvasMutationCallback = (p: canvasMutationParam) => void;
+
+declare type canvasMutationCommand = {
+    property: string;
+    args: Array<unknown>;
+    setter?: true;
+};
+
+declare type canvasMutationData = {
+    source: IncrementalSource.CanvasMutation;
+} & canvasMutationParam;
+
+declare type canvasMutationParam = {
+    id: number;
+    type: CanvasContext;
+    commands: canvasMutationCommand[];
+} | ({
+    id: number;
+    type: CanvasContext;
+} & canvasMutationCommand);
+
+declare type customElementCallback = (c: customElementParam) => void;
+
+declare type customElementData = {
+    source: IncrementalSource.CustomElement;
+} & customElementParam;
+
+declare type customElementParam = {
+    define?: {
+        name: string;
     };
-} & typeof BaseRRNode;
-declare class RRElement extends RRElement_base {
-    inputData: inputData | null;
-    scrollData: scrollData | null;
-}
-declare const RRMediaElement_base: {
-    new (...args: any[]): {
-        currentTime?: number | undefined;
-        volume?: number | undefined;
-        paused?: boolean | undefined;
-        muted?: boolean | undefined;
-        playbackRate?: number | undefined;
-        attachShadow(_init: ShadowRootInit): IRRElement;
-        play(): void;
-        pause(): void;
-        tagName: string;
-        attributes: Record<string, string>;
-        shadowRoot: IRRElement | null;
-        scrollLeft?: number | undefined;
-        scrollTop?: number | undefined;
-        id: string;
-        className: string;
-        classList: ClassList;
-        style: CSSStyleDeclaration;
-        getAttribute(name: string): string | null;
-        setAttribute(name: string, attribute: string): void;
-        setAttributeNS(namespace: string | null, qualifiedName: string, value: string): void;
-        removeAttribute(name: string): void;
-        dispatchEvent(event: Event): boolean;
-        parentElement: IRRNode | null;
-        parentNode: IRRNode | null;
-        ownerDocument: IRRDocument;
-        readonly childNodes: IRRNode[];
-        readonly ELEMENT_NODE: number;
-        readonly TEXT_NODE: number;
-        readonly nodeType: number;
-        readonly nodeName: string;
-        readonly RRNodeType: NodeType;
-        firstChild: IRRNode | null;
-        lastChild: IRRNode | null;
-        previousSibling: IRRNode | null;
-        nextSibling: IRRNode | null;
-        textContent: string | null;
-        contains(node: IRRNode): boolean;
-        appendChild(newChild: IRRNode): IRRNode;
-        insertBefore(newChild: IRRNode, refChild: IRRNode | null): IRRNode;
-        removeChild(node: IRRNode): IRRNode;
-        toString(): string;
+};
+
+declare type customEvent<T = unknown> = {
+    type: EventType.Custom;
+    data: {
+        tag: string;
+        payload: T;
     };
-} & typeof RRElement;
-declare class RRMediaElement extends RRMediaElement_base {
-}
-declare class RRCanvasElement extends RRElement implements IRRElement {
-    rr_dataURL: string | null;
-    canvasMutations: {
-        event: canvasEventWithTime;
-        mutation: canvasMutationData;
-    }[];
-    getContext(): RenderingContext | null;
+};
+
+declare type domContentLoadedEvent = {
+    type: EventType.DomContentLoaded;
+    data: unknown;
+};
+
+declare enum EventType {
+    DomContentLoaded = 0,
+    Load = 1,
+    FullSnapshot = 2,
+    IncrementalSnapshot = 3,
+    Meta = 4,
+    Custom = 5,
+    Plugin = 6
 }
-declare class RRStyleElement extends RRElement {
-    rules: (styleSheetRuleData | styleDeclarationData)[];
+
+declare type eventWithoutTime = domContentLoadedEvent | loadedEvent | fullSnapshotEvent | incrementalSnapshotEvent | metaEvent | customEvent | pluginEvent;
+
+declare type eventWithTime = eventWithoutTime & {
+    timestamp: number;
+    delay?: number;
+};
+
+declare type fontCallback = (p: fontParam) => void;
+
+declare type fontData = {
+    source: IncrementalSource.Font;
+} & fontParam;
+
+declare type fontParam = {
+    family: string;
+    fontSource: string;
+    buffer: boolean;
+    descriptors?: FontFaceDescriptors;
+};
+
+declare type fullSnapshotEvent = {
+    type: EventType.FullSnapshot;
+    data: {
+        node: serializedNodeWithId;
+        initialOffset: {
+            top: number;
+            left: number;
+        };
+    };
+};
+
+declare 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;
+};
+
+declare 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;
 }
-declare class RRIFrameElement extends RRElement {
-    contentDocument: RRDocument;
-    constructor(upperTagName: string, mirror: Mirror);
+
+declare type incrementalData = mutationData | mousemoveData | mouseInteractionData | scrollData | viewportResizeData | inputData | mediaInteractionData | styleSheetRuleData | canvasMutationData | fontData | selectionData | styleDeclarationData | adoptedStyleSheetData | customElementData;
+
+declare type incrementalSnapshotEvent = {
+    type: EventType.IncrementalSnapshot;
+    data: incrementalData;
+};
+
+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
 }
-interface RRElementTagNameMap {
-    audio: RRMediaElement;
-    canvas: RRCanvasElement;
-    iframe: RRIFrameElement;
-    style: RRStyleElement;
-    video: RRMediaElement;
+
+declare type inputCallback = (v: inputValue & {
+    id: number;
+}) => void;
+
+declare type inputData = {
+    source: IncrementalSource.Input;
+    id: number;
+} & inputValue;
+
+declare type inputValue = {
+    text: string;
+    isChecked: boolean;
+    userTriggered?: boolean;
+};
+
+declare type IWindow = Window & typeof globalThis;
+
+declare type KeepIframeSrcFn = (src: string) => boolean;
+
+declare type listenerHandler = () => void;
+
+declare type loadedEvent = {
+    type: EventType.Load;
+    data: unknown;
+};
+
+declare type maskTextClass = string | RegExp;
+
+declare type mediaInteractionCallback = (p: mediaInteractionParam) => void;
+
+declare type mediaInteractionData = {
+    source: IncrementalSource.MediaInteraction;
+} & mediaInteractionParam;
+
+declare type mediaInteractionParam = {
+    type: MediaInteractions;
+    id: number;
+    currentTime?: number;
+    volume?: number;
+    muted?: boolean;
+    loop?: boolean;
+    playbackRate?: number;
+};
+
+declare enum MediaInteractions {
+    Play = 0,
+    Pause = 1,
+    Seeked = 2,
+    VolumeChange = 3,
+    RateChange = 4
 }
-type RRElementType<K extends keyof HTMLElementTagNameMap> = K extends keyof RRElementTagNameMap ? RRElementTagNameMap[K] : RRElement;
-declare class Mirror implements IMirror<BaseRRNode> {
-    private idNodeMap;
-    private nodeMetaMap;
-    getId(n: BaseRRNode | undefined | null): number;
-    getNode(id: number): BaseRRNode | null;
-    getIds(): number[];
-    getMeta(n: BaseRRNode): serializedNodeWithId | null;
-    removeNodeFromMap(n: BaseRRNode): void;
-    has(id: number): boolean;
-    hasNode(node: BaseRRNode): boolean;
-    add(n: BaseRRNode, meta: serializedNodeWithId): void;
-    replace(id: number, n: BaseRRNode): void;
-    reset(): void;
-}
-
-declare function on(type: string, fn: EventListenerOrEventListenerObject, target?: Document | IWindow): listenerHandler;
-declare let _mirror: DeprecatedMirror;
-declare function throttle<T>(func: (arg: T) => void, wait: number, options?: throttleOptions): (...args: T[]) => void;
-declare function hookSetter<T>(target: T, key: string | number | symbol, d: PropertyDescriptor, isRevoked?: boolean, win?: Window & typeof globalThis): hookResetter;
-declare function patch(source: {
-    [key: string]: any;
-}, name: string, replacement: (...args: unknown[]) => unknown): () => void;
-declare let nowTimestamp: () => number;
-
-declare function getWindowScroll(win: Window): {
-    left: number;
-    top: number;
-};
-declare function getWindowHeight(): number;
-declare function getWindowWidth(): number;
-declare function isBlocked(node: Node | null, blockClass: blockClass, blockSelector: string | null, checkAncestors: boolean): boolean;
-declare function isSerialized(n: Node, mirror: Mirror$1): boolean;
-declare function isIgnored(n: Node, mirror: Mirror$1): boolean;
-declare function isAncestorRemoved(target: Node, mirror: Mirror$1): boolean;
-declare function legacy_isTouchEvent(event: MouseEvent | TouchEvent | PointerEvent): event is TouchEvent;
-declare function polyfill(win?: Window & typeof globalThis): void;
-type ResolveTree = {
-    value: addedNodeMutation;
-    children: ResolveTree[];
-    parent: ResolveTree | null;
-};
-declare function queueToResolveTrees(queue: addedNodeMutation[]): ResolveTree[];
-declare function iterateResolveTree(tree: ResolveTree, cb: (mutation: addedNodeMutation) => unknown): void;
-type AppendedIframe = {
-    mutationInQueue: addedNodeMutation;
-    builtNode: HTMLIFrameElement | RRIFrameElement;
-};
-declare function isSerializedIframe<TNode extends Node | BaseRRNode>(n: TNode, mirror: IMirror<TNode>): boolean;
-declare function isSerializedStylesheet<TNode extends Node | BaseRRNode>(n: TNode, mirror: IMirror<TNode>): boolean;
-declare function getBaseDimension(node: Node, rootIframe: Node): DocumentDimension;
-declare function hasShadowRoot<T extends Node | BaseRRNode>(n: T): n is T & {
-    shadowRoot: ShadowRoot;
-};
-declare function getNestedRule(rules: CSSRuleList, position: number[]): CSSGroupingRule;
-declare function getPositionsAndIndex(nestedIndex: number[]): {
-    positions: number[];
-    index: number | undefined;
-};
-declare function uniqueTextMutations(mutations: textMutation[]): textMutation[];
-declare class StyleSheetMirror {
-    private id;
-    private styleIDMap;
-    private idStyleMap;
-    getId(stylesheet: CSSStyleSheet): number;
-    has(stylesheet: CSSStyleSheet): boolean;
-    add(stylesheet: CSSStyleSheet, id?: number): number;
-    getStyle(id: number): CSSStyleSheet | null;
-    reset(): void;
-    generateId(): number;
-}
-declare function getShadowHost(n: Node): Element | null;
-declare function getRootShadowHost(n: Node): Node;
-declare function shadowHostInDom(n: Node): boolean;
-declare function inDom(n: Node): boolean;
-
-type utils_d_AppendedIframe = AppendedIframe;
-type utils_d_StyleSheetMirror = StyleSheetMirror;
-declare const utils_d_StyleSheetMirror: typeof StyleSheetMirror;
-declare const utils_d__mirror: typeof _mirror;
-declare const utils_d_getBaseDimension: typeof getBaseDimension;
-declare const utils_d_getNestedRule: typeof getNestedRule;
-declare const utils_d_getPositionsAndIndex: typeof getPositionsAndIndex;
-declare const utils_d_getRootShadowHost: typeof getRootShadowHost;
-declare const utils_d_getShadowHost: typeof getShadowHost;
-declare const utils_d_getWindowHeight: typeof getWindowHeight;
-declare const utils_d_getWindowScroll: typeof getWindowScroll;
-declare const utils_d_getWindowWidth: typeof getWindowWidth;
-declare const utils_d_hasShadowRoot: typeof hasShadowRoot;
-declare const utils_d_hookSetter: typeof hookSetter;
-declare const utils_d_inDom: typeof inDom;
-declare const utils_d_isAncestorRemoved: typeof isAncestorRemoved;
-declare const utils_d_isBlocked: typeof isBlocked;
-declare const utils_d_isIgnored: typeof isIgnored;
-declare const utils_d_isSerialized: typeof isSerialized;
-declare const utils_d_isSerializedIframe: typeof isSerializedIframe;
-declare const utils_d_isSerializedStylesheet: typeof isSerializedStylesheet;
-declare const utils_d_iterateResolveTree: typeof iterateResolveTree;
-declare const utils_d_legacy_isTouchEvent: typeof legacy_isTouchEvent;
-declare const utils_d_nowTimestamp: typeof nowTimestamp;
-declare const utils_d_on: typeof on;
-declare const utils_d_patch: typeof patch;
-declare const utils_d_polyfill: typeof polyfill;
-declare const utils_d_queueToResolveTrees: typeof queueToResolveTrees;
-declare const utils_d_shadowHostInDom: typeof shadowHostInDom;
-declare const utils_d_throttle: typeof throttle;
-declare const utils_d_uniqueTextMutations: typeof uniqueTextMutations;
-declare namespace utils_d {
-  export {
-    utils_d_AppendedIframe as AppendedIframe,
-    utils_d_StyleSheetMirror as StyleSheetMirror,
-    utils_d__mirror as _mirror,
-    utils_d_getBaseDimension as getBaseDimension,
-    utils_d_getNestedRule as getNestedRule,
-    utils_d_getPositionsAndIndex as getPositionsAndIndex,
-    utils_d_getRootShadowHost as getRootShadowHost,
-    utils_d_getShadowHost as getShadowHost,
-    utils_d_getWindowHeight as getWindowHeight,
-    utils_d_getWindowScroll as getWindowScroll,
-    utils_d_getWindowWidth as getWindowWidth,
-    utils_d_hasShadowRoot as hasShadowRoot,
-    utils_d_hookSetter as hookSetter,
-    utils_d_inDom as inDom,
-    utils_d_isAncestorRemoved as isAncestorRemoved,
-    utils_d_isBlocked as isBlocked,
-    utils_d_isIgnored as isIgnored,
-    utils_d_isSerialized as isSerialized,
-    utils_d_isSerializedIframe as isSerializedIframe,
-    utils_d_isSerializedStylesheet as isSerializedStylesheet,
-    utils_d_iterateResolveTree as iterateResolveTree,
-    utils_d_legacy_isTouchEvent as legacy_isTouchEvent,
-    utils_d_nowTimestamp as nowTimestamp,
-    utils_d_on as on,
-    utils_d_patch as patch,
-    utils_d_polyfill as polyfill,
-    utils_d_queueToResolveTrees as queueToResolveTrees,
-    utils_d_shadowHostInDom as shadowHostInDom,
-    utils_d_throttle as throttle,
-    utils_d_uniqueTextMutations as uniqueTextMutations,
-  };
-}
-
-declare class Timer {
-    timeOffset: number;
-    speed: number;
-    private actions;
-    private raf;
-    private lastTimestamp;
-    constructor(actions: actionWithDelay[] | undefined, config: {
-        speed: number;
-    });
-    addAction(action: actionWithDelay): void;
-    start(): void;
-    private rafCheck;
-    clear(): void;
-    setSpeed(speed: number): void;
-    isActive(): boolean;
-    private findActionIndex;
-}
-
-declare enum InterpreterStatus {
-    NotStarted = 0,
-    Running = 1,
-    Stopped = 2
+
+declare type metaEvent = {
+    type: EventType.Meta;
+    data: {
+        href: string;
+        width: number;
+        height: number;
+    };
+};
+
+declare type mouseInteractionCallBack = (d: mouseInteractionParam) => void;
+
+declare type mouseInteractionData = {
+    source: IncrementalSource.MouseInteraction;
+} & mouseInteractionParam;
+
+declare type mouseInteractionParam = {
+    type: MouseInteractions;
+    id: number;
+    x?: number;
+    y?: number;
+    pointerType?: PointerTypes;
+};
+
+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 type SingleOrArray<T> = T[] | T;
-interface EventObject {
-    type: string;
+
+declare type mousemoveCallBack = (p: mousePosition[], source: IncrementalSource.MouseMove | IncrementalSource.TouchMove | IncrementalSource.Drag) => void;
+
+declare type mousemoveData = {
+    source: IncrementalSource.MouseMove | IncrementalSource.TouchMove | IncrementalSource.Drag;
+    positions: mousePosition[];
+};
+
+declare type mousePosition = {
+    x: number;
+    y: number;
+    id: number;
+    timeOffset: number;
+};
+
+declare type mutationCallBack = (m: mutationCallbackParam) => void;
+
+declare type mutationCallbackParam = {
+    texts: textMutation[];
+    attributes: attributeMutation[];
+    removes: removedNodeMutation[];
+    adds: addedNodeMutation[];
+    isAttachIframe?: true;
+};
+
+declare type mutationData = {
+    source: IncrementalSource.Mutation;
+} & mutationCallbackParam;
+
+declare type PackFn = (event: eventWithTime) => string;
+
+declare type pluginEvent<T = unknown> = {
+    type: EventType.Plugin;
+    data: {
+        plugin: string;
+        payload: T;
+    };
+};
+
+declare enum PointerTypes {
+    Mouse = 0,
+    Pen = 1,
+    Touch = 2
 }
-declare type InitEvent = {
-    type: 'xstate.init';
+
+declare 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;
+};
+
+declare type removedNodeMutation = {
+    parentId: number;
+    id: number;
+    isShadow?: boolean;
+};
+
+declare type SamplingStrategy = Partial<{
+    mousemove: boolean | number;
+    mousemoveCallback: number;
+    mouseInteraction: boolean | Record<string, boolean | undefined>;
+    scroll: number;
+    media: number;
+    input: 'all' | 'last';
+    canvas: 'all' | number;
+}>;
+
+declare type scrollCallback = (p: scrollPosition) => void;
+
+declare type scrollData = {
+    source: IncrementalSource.Scroll;
+} & scrollPosition;
+
+declare type scrollPosition = {
+    id: number;
+    x: number;
+    y: number;
+};
+
+declare type selectionCallback = (p: selectionParam) => void;
+
+declare type selectionData = {
+    source: IncrementalSource.Selection;
+} & selectionParam;
+
+declare type selectionParam = {
+    ranges: Array<SelectionRange>;
+};
+
+declare type SelectionRange = {
+    start: number;
+    startOffset: number;
+    end: number;
+    endOffset: number;
 };
-declare namespace StateMachine {
-    type Action<TContext extends object, TEvent extends EventObject> = string | AssignActionObject<TContext, TEvent> | ActionObject<TContext, TEvent> | ActionFunction<TContext, TEvent>;
-    type ActionMap<TContext extends object, TEvent extends EventObject> = Record<string, Exclude<Action<TContext, TEvent>, string>>;
-    interface ActionObject<TContext extends object, TEvent extends EventObject> {
-        type: string;
-        exec?: ActionFunction<TContext, TEvent>;
-        [key: string]: any;
-    }
-    type ActionFunction<TContext extends object, TEvent extends EventObject> = (context: TContext, event: TEvent | InitEvent) => void;
-    type AssignAction = 'xstate.assign';
-    interface AssignActionObject<TContext extends object, TEvent extends EventObject> extends ActionObject<TContext, TEvent> {
-        type: AssignAction;
-        assignment: Assigner<TContext, TEvent> | PropertyAssigner<TContext, TEvent>;
-    }
-    type Transition<TContext extends object, TEvent extends EventObject> = string | {
-        target?: string;
-        actions?: SingleOrArray<Action<TContext, TEvent>>;
-        cond?: (context: TContext, event: TEvent) => boolean;
+
+declare type styleDeclarationCallback = (s: styleDeclarationParam) => void;
+
+declare type styleDeclarationData = {
+    source: IncrementalSource.StyleDeclaration;
+} & styleDeclarationParam;
+
+declare type styleDeclarationParam = {
+    id?: number;
+    styleId?: number;
+    index: number[];
+    set?: {
+        property: string;
+        value: string | null;
+        priority: string | undefined;
     };
-    interface State<TContext extends object, TEvent extends EventObject, TState extends Typestate<TContext>> {
-        value: TState['value'];
-        context: TContext;
-        actions: Array<ActionObject<TContext, TEvent>>;
-        changed?: boolean | undefined;
-        matches: <TSV extends TState['value']>(value: TSV) => this is TState extends {
-            value: TSV;
-        } ? TState & {
-            value: TSV;
-        } : never;
-    }
-    type AnyState = State<any, any, any>;
-    interface Config<TContext extends object, TEvent extends EventObject, TState extends Typestate<TContext> = {
-        value: any;
-        context: TContext;
-    }> {
-        id?: string;
-        initial: string;
-        context?: TContext;
-        states: {
-            [key in TState['value']]: {
-                on?: {
-                    [K in TEvent['type']]?: SingleOrArray<Transition<TContext, TEvent extends {
-                        type: K;
-                    } ? TEvent : never>>;
-                };
-                exit?: SingleOrArray<Action<TContext, TEvent>>;
-                entry?: SingleOrArray<Action<TContext, TEvent>>;
-            };
-        };
-    }
-    interface Machine<TContext extends object, TEvent extends EventObject, TState extends Typestate<TContext>> {
-        config: StateMachine.Config<TContext, TEvent, TState>;
-        initialState: State<TContext, TEvent, TState>;
-        transition: (state: string | State<TContext, TEvent, TState>, event: TEvent['type'] | TEvent) => State<TContext, TEvent, TState>;
-    }
-    type StateListener<T extends AnyState> = (state: T) => void;
-    interface Service<TContext extends object, TEvent extends EventObject, TState extends Typestate<TContext> = {
-        value: any;
-        context: TContext;
-    }> {
-        send: (event: TEvent | TEvent['type']) => void;
-        subscribe: (listener: StateListener<State<TContext, TEvent, TState>>) => {
-            unsubscribe: () => void;
-        };
-        start: (initialState?: TState['value'] | {
-            context: TContext;
-            value: TState['value'];
-        }) => Service<TContext, TEvent, TState>;
-        stop: () => Service<TContext, TEvent, TState>;
-        readonly status: InterpreterStatus;
-        readonly state: State<TContext, TEvent, TState>;
-    }
-    type Assigner<TContext extends object, TEvent extends EventObject> = (context: TContext, event: TEvent) => Partial<TContext>;
-    type PropertyAssigner<TContext extends object, TEvent extends EventObject> = {
-        [K in keyof TContext]?: ((context: TContext, event: TEvent) => TContext[K]) | TContext[K];
+    remove?: {
+        property: string;
     };
-}
-interface Typestate<TContext extends object> {
-    value: string;
-    context: TContext;
-}
-
-type PlayerContext = {
-    events: eventWithTime[];
-    timer: Timer;
-    timeOffset: number;
-    baselineTime: number;
-    lastPlayedEvent: eventWithTime | null;
-};
-type PlayerEvent = {
-    type: 'PLAY';
-    payload: {
-        timeOffset: number;
-    };
-} | {
-    type: 'CAST_EVENT';
-    payload: {
-        event: eventWithTime;
-    };
-} | {
-    type: 'PAUSE';
-} | {
-    type: 'TO_LIVE';
-    payload: {
-        baselineTime?: number;
-    };
-} | {
-    type: 'ADD_EVENT';
-    payload: {
-        event: eventWithTime;
-    };
-} | {
-    type: 'END';
-};
-type PlayerState = {
-    value: 'playing';
-    context: PlayerContext;
-} | {
-    value: 'paused';
-    context: PlayerContext;
-} | {
-    value: 'live';
-    context: PlayerContext;
-};
-type PlayerAssets = {
-    emitter: Emitter$1;
-    applyEventsSynchronously(events: Array<eventWithTime>): void;
-    getCastFn(event: eventWithTime, isSync: boolean): () => void;
-};
-declare function createPlayerService(context: PlayerContext, { getCastFn, applyEventsSynchronously, emitter }: PlayerAssets): StateMachine.Service<PlayerContext, PlayerEvent, PlayerState>;
-type SpeedContext = {
-    normalSpeed: playerConfig['speed'];
-    timer: Timer;
-};
-type SpeedEvent = {
-    type: 'FAST_FORWARD';
-    payload: {
-        speed: playerConfig['speed'];
-    };
-} | {
-    type: 'BACK_TO_NORMAL';
-} | {
-    type: 'SET_SPEED';
-    payload: {
-        speed: playerConfig['speed'];
-    };
-};
-type SpeedState = {
-    value: 'normal';
-    context: SpeedContext;
-} | {
-    value: 'skipping';
-    context: SpeedContext;
-};
-declare function createSpeedService(context: SpeedContext): StateMachine.Service<SpeedContext, SpeedEvent, SpeedState>;
+};
+
+declare type styleOMValue = {
+    [key: string]: styleValueWithPriority | string | false;
+};
+
+declare type styleSheetAddRule = {
+    rule: string;
+    index?: number | number[];
+};
+
+declare type styleSheetDeleteRule = {
+    index: number | number[];
+};
+
+declare type styleSheetRuleCallback = (s: styleSheetRuleParam) => void;
+
+declare type styleSheetRuleData = {
+    source: IncrementalSource.StyleSheetRule;
+} & styleSheetRuleParam;
+
+declare type styleSheetRuleParam = {
+    id?: number;
+    styleId?: number;
+    removes?: styleSheetDeleteRule[];
+    adds?: styleSheetAddRule[];
+    replace?: string;
+    replaceSync?: string;
+};
+
+declare type styleValueWithPriority = [string, string];
+
+declare type textMutation = {
+    id: number;
+    value: string | null;
+};
+
+declare type viewportResizeCallback = (d: viewportResizeDimension) => void;
+
+declare type viewportResizeData = {
+    source: IncrementalSource.ViewportResize;
+} & viewportResizeDimension;
+
+declare type viewportResizeDimension = {
+    width: number;
+    height: number;
+};
+
 
-declare class Replayer {
-    wrapper: HTMLDivElement;
-    iframe: HTMLIFrameElement;
-    service: ReturnType<typeof createPlayerService>;
-    speedService: ReturnType<typeof createSpeedService>;
-    get timer(): Timer;
-    config: playerConfig;
-    usingVirtualDom: boolean;
-    virtualDom: RRDocument;
-    private mouse;
-    private mouseTail;
-    private tailPositions;
-    private emitter;
-    private nextUserInteractionEvent;
-    private legacy_missingNodeRetryMap;
-    private cache;
-    private imageMap;
-    private canvasEventMap;
-    private mirror;
-    private styleMirror;
-    private firstFullSnapshot;
-    private newDocumentQueue;
-    private mousePos;
-    private touchActive;
-    private lastMouseDownEvent;
-    private lastHoveredRootNode;
-    private lastSelectionData;
-    private constructedStyleMutations;
-    private adoptedStyleSheets;
-    constructor(events: Array<eventWithTime | string>, config?: Partial<playerConfig>);
-    on(event: string, handler: Handler): this;
-    off(event: string, handler: Handler): this;
-    setConfig(config: Partial<playerConfig>): void;
-    getMetaData(): playerMetaData;
-    getCurrentTime(): number;
-    getTimeOffset(): number;
-    getMirror(): Mirror$1;
-    play(timeOffset?: number): void;
-    pause(timeOffset?: number): void;
-    resume(timeOffset?: number): void;
-    destroy(): void;
-    startLive(baselineTime?: number): void;
-    addEvent(rawEvent: eventWithTime | string): void;
-    enableInteract(): void;
-    disableInteract(): void;
-    resetCache(): void;
-    private setupDom;
-    private handleResize;
-    private applyEventsSynchronously;
-    private getCastFn;
-    private rebuildFullSnapshot;
-    private insertStyleRules;
-    private attachDocumentToIframe;
-    private collectIframeAndAttachDocument;
-    private waitForStylesheetLoad;
-    private preloadAllImages;
-    private preloadImages;
-    private deserializeAndPreloadCanvasEvents;
-    private applyIncremental;
-    private applyMutation;
-    private applyScroll;
-    private applyInput;
-    private applySelection;
-    private applyStyleSheetMutation;
-    private applyStyleSheetRule;
-    private applyStyleDeclaration;
-    private applyAdoptedStyleSheet;
-    private legacy_resolveMissingNode;
-    private moveAndHover;
-    private drawMouseTail;
-    private hoverElements;
-    private isUserInteraction;
-    private backToNormal;
-    private warnNodeNotFound;
-    private warnCanvasMutationFailed;
-    private debugNodeNotFound;
-    private warn;
-    private debug;
-}
 
-type recordOptions<T> = {
-    emit?: (e: T, 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;
-    recordCanvas?: boolean;
-    recordCrossOriginIframes?: boolean;
-    recordAfter?: 'DOMContentLoaded' | 'load';
-    userTriggeredOnInput?: boolean;
-    collectFonts?: boolean;
-    inlineImages?: boolean;
-    plugins?: RecordPlugin[];
-    mousemoveWait?: number;
-    keepIframeSrcFn?: KeepIframeSrcFn;
-    errorHandler?: ErrorHandler;
-};
-type ReplayPlugin = {
-    handler?: (event: eventWithTime, isSync: boolean, context: {
-        replayer: Replayer;
-    }) => void;
-    onBuild?: (node: Node | BaseRRNode, context: {
-        id: number;
-        replayer: Replayer;
-    }) => void;
-    getMirror?: (mirrors: {
-        nodeMirror: Mirror$1;
-    }) => void;
-};
-type playerConfig = {
-    speed: number;
-    maxSpeed: number;
-    root: Element;
-    loadTimeout: number;
-    skipInactive: boolean;
-    showWarning: boolean;
-    showDebug: boolean;
-    blockClass: string;
-    liveMode: boolean;
-    insertStyleRules: string[];
-    triggerFocus: boolean;
-    UNSAFE_replayCanvas: boolean;
-    pauseAnimation?: boolean;
-    mouseTail: boolean | {
-        duration?: number;
-        lineCap?: string;
-        lineWidth?: number;
-        strokeStyle?: string;
-    };
-    unpackFn?: UnpackFn;
-    useVirtualDom: boolean;
-    logger: {
-        log: (...args: Parameters<typeof console.log>) => void;
-        warn: (...args: Parameters<typeof console.warn>) => void;
-    };
-    plugins?: ReplayPlugin[];
-};
 declare global {
     interface Window {
         FontFace: typeof FontFace;
     }
 }
-type ErrorHandler = (error: unknown) => void | boolean;
 
-declare function record<T = eventWithTime>(options?: recordOptions<T>): listenerHandler | undefined;
+declare type ErrorHandler = (error: unknown) => void | boolean;
+
+
+declare type recordOptions<T> = {
+    emit?: (e: T, 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;
+};
+
+declare function record<T = eventWithTime>(options?: recordOptions<T>): listenerHandler | undefined;
+
+declare namespace record {
+    var addCustomEvent: <T>(tag: string, payload: T) => void;
+    var freezePage: () => void;
+    var takeFullSnapshot: (isCheckout?: boolean | undefined) => void;
+    var mirror: Mirror;
+}
+
+
 declare namespace record {
     var addCustomEvent: <T>(tag: string, payload: T) => void;
     var freezePage: () => void;
     var takeFullSnapshot: (isCheckout?: boolean | undefined) => void;
-    var mirror: Mirror$1;
+    var mirror: Mirror;
 }
 
-declare const addCustomEvent: <T>(tag: string, payload: T) => void;
-declare const freezePage: () => void;
-
-declare const pack: PackFn;
-
-declare const unpack: UnpackFn;
 
-type StringifyOptions = {
-    stringLengthLimit?: number;
-    numOfKeysLimit: number;
-    depthOfLimit: number;
-};
-type LogRecordOptions = {
-    level?: LogLevel[];
-    lengthThreshold?: number;
-    stringifyOptions?: StringifyOptions;
-    logger?: Logger | 'console';
-};
-type LogData = {
-    level: LogLevel;
-    trace: string[];
-    payload: string[];
-};
-type Logger = {
-    assert?: typeof console.assert;
-    clear?: typeof console.clear;
-    count?: typeof console.count;
-    countReset?: typeof console.countReset;
-    debug?: typeof console.debug;
-    dir?: typeof console.dir;
-    dirxml?: typeof console.dirxml;
-    error?: typeof console.error;
-    group?: typeof console.group;
-    groupCollapsed?: typeof console.groupCollapsed;
-    groupEnd?: () => void;
-    info?: typeof console.info;
-    log?: typeof console.log;
-    table?: typeof console.table;
-    time?: typeof console.time;
-    timeEnd?: typeof console.timeEnd;
-    timeLog?: typeof console.timeLog;
-    trace?: typeof console.trace;
-    warn?: typeof console.warn;
-};
-type LogLevel = keyof Logger;
-declare const PLUGIN_NAME = "rrweb/console@1";
-declare const getRecordConsolePlugin: (options?: LogRecordOptions) => RecordPlugin;
-
-type ReplayLogger = Partial<Record<LogLevel, (data: LogData) => void>>;
-type LogReplayConfig = {
-    level?: LogLevel[];
-    replayLogger?: ReplayLogger;
-};
-declare const getReplayConsolePlugin: (options?: LogReplayConfig) => ReplayPlugin;
+declare global {
+    interface Window {
+        FontFace: typeof FontFace;
+        Array: typeof Array;
+    }
+}
 
-type rrweb_EventType = EventType;
-declare const rrweb_EventType: typeof EventType;
-type rrweb_IncrementalSource = IncrementalSource;
-declare const rrweb_IncrementalSource: typeof IncrementalSource;
-type rrweb_LogData = LogData;
-type rrweb_LogLevel = LogLevel;
-type rrweb_Logger = Logger;
-type rrweb_MouseInteractions = MouseInteractions;
-declare const rrweb_MouseInteractions: typeof MouseInteractions;
-declare const rrweb_PLUGIN_NAME: typeof PLUGIN_NAME;
-type rrweb_Replayer = Replayer;
-declare const rrweb_Replayer: typeof Replayer;
-type rrweb_ReplayerEvents = ReplayerEvents;
-declare const rrweb_ReplayerEvents: typeof ReplayerEvents;
-type rrweb_StringifyOptions = StringifyOptions;
-declare const rrweb_addCustomEvent: typeof addCustomEvent;
-declare const rrweb_freezePage: typeof freezePage;
-declare const rrweb_getRecordConsolePlugin: typeof getRecordConsolePlugin;
-declare const rrweb_getReplayConsolePlugin: typeof getReplayConsolePlugin;
-declare const rrweb_pack: typeof pack;
-declare const rrweb_record: typeof record;
-type rrweb_recordOptions<T> = recordOptions<T>;
-declare const rrweb_unpack: typeof unpack;
-declare namespace rrweb {
-  export {
-    rrweb_EventType as EventType,
-    rrweb_IncrementalSource as IncrementalSource,
-    rrweb_LogData as LogData,
-    rrweb_LogLevel as LogLevel,
-    rrweb_Logger as Logger,
-    rrweb_MouseInteractions as MouseInteractions,
-    rrweb_PLUGIN_NAME as PLUGIN_NAME,
-    rrweb_Replayer as Replayer,
-    rrweb_ReplayerEvents as ReplayerEvents,
-    rrweb_StringifyOptions as StringifyOptions,
-    rrweb_addCustomEvent as addCustomEvent,
-    rrweb_freezePage as freezePage,
-    rrweb_getRecordConsolePlugin as getRecordConsolePlugin,
-    rrweb_getReplayConsolePlugin as getReplayConsolePlugin,
-    _mirror as mirror,
-    rrweb_pack as pack,
-    rrweb_record as record,
-    rrweb_recordOptions as recordOptions,
-    rrweb_unpack as unpack,
-    utils_d as utils,
-  };
+declare const _rrweb_record_record: typeof record;
+declare namespace _rrweb_record {
+  export { _rrweb_record_record as record };
 }
 
 interface XhrResponse {
@@ -1495,14 +647,6 @@ interface XhrHeaders {
   [key: string]: string;
 }
 
-declare const isValidChunkSize: (chunkSize: any, { minChunkSize, maxChunkSize, }?: {
-    minChunkSize?: number | undefined;
-    maxChunkSize?: number | undefined;
-}) => chunkSize is number | null | undefined;
-declare const getChunkSizeError: (chunkSize: any, { minChunkSize, maxChunkSize, }?: {
-    minChunkSize?: number | undefined;
-    maxChunkSize?: number | undefined;
-}) => TypeError;
 declare type ChunkedStreamIterableOptions = {
     defaultChunkSize?: number;
     minChunkSize?: number;
@@ -1608,27 +752,7 @@ declare class UpChunk {
      */
     private sendChunks;
 }
-declare const createUpload$1: typeof UpChunk.createUpload;
-
-type _mux_upchunk_ChunkedStreamIterable = ChunkedStreamIterable;
-declare const _mux_upchunk_ChunkedStreamIterable: typeof ChunkedStreamIterable;
-type _mux_upchunk_ChunkedStreamIterableOptions = ChunkedStreamIterableOptions;
-type _mux_upchunk_UpChunk = UpChunk;
-declare const _mux_upchunk_UpChunk: typeof UpChunk;
-type _mux_upchunk_UpChunkOptions = UpChunkOptions;
-declare const _mux_upchunk_getChunkSizeError: typeof getChunkSizeError;
-declare const _mux_upchunk_isValidChunkSize: typeof isValidChunkSize;
-declare namespace _mux_upchunk {
-  export {
-    _mux_upchunk_ChunkedStreamIterable as ChunkedStreamIterable,
-    _mux_upchunk_ChunkedStreamIterableOptions as ChunkedStreamIterableOptions,
-    _mux_upchunk_UpChunk as UpChunk,
-    _mux_upchunk_UpChunkOptions as UpChunkOptions,
-    createUpload$1 as createUpload,
-    _mux_upchunk_getChunkSizeError as getChunkSizeError,
-    _mux_upchunk_isValidChunkSize as isValidChunkSize,
-  };
-}
+declare const createUpload: typeof UpChunk.createUpload;
 
 declare enum NOTIFICATION_TYPES {
     ACTIVATE = "ACTIVATE:experiment, user_id,attributes, variation, event",
@@ -1876,106 +1000,8 @@ declare class Emitter<Events extends EventMap> {
     rawListeners<EventName extends keyof Events>(eventName: EventName): Array<Listener<Events[EventName]>>;
 }
 
-declare enum DismissReason {
-    Closed = "close.click",
-    Complete = "survey.completed",
-    PageChange = "page.change",
-    API = "api",
-    Override = "override"
-}
-declare enum SprigEvent {
-    SDKReady = "sdk.ready",
-    SurveyAppeared = "survey.appeared",
-    SurveyClosed = "survey.closed",
-    SurveyDimensions = "survey.dimensions",
-    SurveyFadingOut = "survey.fadingOut",
-    SurveyHeight = "survey.height",
-    SurveyPresented = "survey.presented",
-    SurveyLifeCycle = "survey.lifeCycle",
-    SurveyWillClose = "survey.willClose",
-    SurveyWillPresent = "survey.will.present",
-    CloseSurveyOnOverlayClick = "close.survey.overlayClick",
-    VisitorIDUpdated = "visitor.id.updated",
-    QuestionAnswered = "question.answered"
-}
-declare enum SprigEventData {
-    SurveyId = "survey.id"
-}
-declare const EVENTS: {
-    SDK_READY: SprigEvent;
-    SURVEY_APPEARED: SprigEvent;
-    SURVEY_CLOSED: SprigEvent;
-    SURVEY_DIMENSIONS: SprigEvent;
-    SURVEY_FADING_OUT: SprigEvent;
-    SURVEY_HEIGHT: SprigEvent;
-    SURVEY_PRESENTED: SprigEvent;
-    SURVEY_LIFE_CYCLE: SprigEvent;
-    SURVEY_WILL_CLOSE: SprigEvent;
-    SURVEY_WILL_PRESENT: SprigEvent;
-    QUESTION_ANSWERED: SprigEvent;
-    CLOSE_SURVEY_ON_OVERLAY_CLICK: SprigEvent;
-    VISITOR_ID_UPDATED: SprigEvent;
-    DATA: {
-        DISMISS_REASONS: {
-            API: DismissReason;
-            CLOSED: DismissReason;
-            COMPLETE: DismissReason;
-            PAGE_CHANGE: DismissReason;
-            OVERRIDE: DismissReason;
-        };
-        SURVEY_ID: SprigEventData;
-    };
-};
-declare const enum InternalEventName {
-    VerifyViewVersion = "verify.view.version",
-    CurrentQuestion = "survey.question",
-    ViewPrototypeClick = "question.prototype.click",
-    ViewAgreementClick = "question.agreement.click",
-    RecordedTaskStart = "recorded.task.start",
-    RecordedTaskPermissionScreen = "recorded.task.permission.screen",
-    SurveyComplete = "survey.complete"
-}
-declare const enum InternalEventData {
-    ViewVersion = "view.version",
-    QuestionId = "qid",
-    Props = "props"
-}
-
-declare const enum MediaType {
-    Video = "video",
-    Audio = "audio",
-    Screen = "screen"
-}
-declare const enum SprigRecordingEvent {
-    PermissionStatus = "permission.status",
-    AvPermission = "av.permission",
-    ScreenPermission = "screen.permission",
-    BeginRecording = "begin.recording",
-    StartTask = "start.task",
-    FinishTask = "finish.task"
-}
-declare const enum TaskStatus {
-    Abandoned = "abandoned",
-    GivenUp = "given.up",
-    Completed = "completed"
-}
-declare const enum SprigRecordingEventData {
-    ScreenPermissionRequested = "screen.permission.requested",
-    PermissionDescriptors = "permission.descriptors",
-    PermissionStatusCallback = "permission.status.callback",
-    StreamReadyCallback = "stream.ready.callback",
-    StreamCanceledCallback = "stream.canceled.callback",
-    TaskCompleteCallback = "task.complete.callback",
-    TaskResponse = "task.response",
-    TaskStatus = "task.status",
-    RecordingMediaTypes = "recording.media.types",
-    StartRecordingCallback = "start.recording.callback",
-    PassthroughData = "passthrough.data",
-    CurrentIndex = "current.index",
-    UploadCallback = "upload.callback",
-    ProgressCallback = "progress.callback",
-    BeginCallback = "begin.callback"
-}
+type MediaType = "video" | "audio" | "screen";
+type TaskStatus = "abandoned" | "given.up" | "completed";
 interface PassthroughData {
     questionId: number;
     surveyId: number;
@@ -1983,82 +1009,30 @@ interface PassthroughData {
     responseGroupUid: UUID;
 }
 
-interface Experiment {
-    id: string;
-    variation?: string;
-}
-
-type QueueItem = [string, ...unknown[]] | (() => void);
-declare class SprigQueue {
-    paused: boolean;
-    queue: QueueItem[];
-    ul: WindowSprig;
-    constructor(ul: WindowSprig, queue: QueueItem[]);
-    flush(queue: QueueItem[]): void;
-    isPaused(): boolean;
-    pause(): void;
-    unpause(): void;
-    push(action: QueueItem): void;
-    perform(func: () => void): void | Promise<unknown>;
-    /**
-     * Removes all queued items
-     */
-    empty(): void;
-}
-
-declare enum SurveyState {
-    Ready = "ready",
-    NoSurvey = "no survey"
-}
-
 interface RecordedTaskResponseValueType {
     mediaRecordingUids?: string[] | null;
     taskDurationMillisecond?: number;
     taskStatus: TaskStatus;
 }
-declare enum BooleanOperator {
-    And = 1,
-    Or = 2
-}
+declare const BOOLEAN_OPERATOR: {
+    readonly And: 1;
+    readonly Or: 2;
+};
+type BooleanOperator = (typeof BOOLEAN_OPERATOR)[keyof typeof BOOLEAN_OPERATOR];
 
-declare const enum CardType {
-    ConsentLegal = "consentlegal",
-    Likert = "likert",
-    MultipleChoice = "multiplechoice",
-    MultipleSelect = "multipleselect",
-    NPS = "nps",
-    Open = "open",
-    RecordedTask = "recordedtask",
-    TextUrlPrompt = "texturlprompt",
-    Thanks = "thanks",
-    Uploading = "uploading",
-    VideoVoice = "videovoice"
-}
+type CardType = "consentlegal" | "likert" | "matrix" | "multiplechoice" | "multipleselect" | "nps" | "open" | "rankorder" | "recordedtask" | "texturlprompt" | "thanks" | "uploading" | "videovoice";
 type ConceptUrl = string | null;
 interface BaseCard {
     name: number;
     surveyId: number;
     updatedAt: string;
     value?: unknown;
+    type: CardType;
+    groupId?: number;
 }
-declare const enum Comparator {
-    Answered = "answered",
-    Equal = "eq",
-    NotEqual = "neq",
-    Skipped = "skipped",
-    LessThan = "lt",
-    LessThanOrEqual = "lte",
-    GivenUp = "given_up",
-    GreaterThan = "gt",
-    GreaterThanOrEqual = "gte",
-    ListAll = "list_all",
-    ListAtLeastOne = "list_alo",
-    ListExact = "list_exact",
-    DoesNotInclude = "list_dni",
-    Contains = "contains",
-    DoesNotContain = "notcontains"
-}
-type DefaultComparator = Comparator.Answered | Comparator.Skipped;
+type Comparator = "answered" | "contains" | "notcontains" | "list_dni" | "eq" | "given_up" | "gt" | "gte" | "lt" | "lte" | "list_all" | "list_alo" | "list_exact" | "neq" | "partial" | "skipped";
+type Randomize = "none" | "all";
+type DefaultComparator = Extract<Comparator, "answered" | "skipped">;
 type RoutingOption<C extends Comparator = DefaultComparator> = OldRoutingOption<C> | GroupRoutingOption;
 type OldRoutingOption<C extends Comparator = DefaultComparator> = {
     comparator: C;
@@ -2080,10 +1054,12 @@ type RoutingGroupOption = {
 type RoutingOptions<C extends Comparator = DefaultComparator> = RoutingOption<C | DefaultComparator>[] | null;
 /** @example <p>Body</p> */
 type RichTextBody = string;
-declare const enum PromptActionType {
-    Continue = "CONTINUE",
-    External = "EXTERNAL"
+declare enum PromptActionTypeEnum {
+    CONTINUE = "CONTINUE",
+    EXTERNAL = "EXTERNAL",
+    NO_BUTTON = "NO_BUTTON"
 }
+type PromptActionType = keyof typeof PromptActionTypeEnum;
 interface TextUrlPromptCard extends BaseCard {
     props: {
         message: string;
@@ -2097,16 +1073,13 @@ interface TextUrlPromptCard extends BaseCard {
             promptActionType: PromptActionType;
             required: boolean;
             richTextBody: RichTextBody;
+            questionHtml?: string;
         };
         routingOptions: RoutingOptions;
     };
-    type: CardType.TextUrlPrompt;
-}
-declare const enum AvPermission {
-    Camera = "camera",
-    Microphone = "microphone",
-    Screen = "screen"
+    type: "texturlprompt";
 }
+type AvPermission = "camera" | "microphone" | "screen";
 interface ConsentLegalCard extends BaseCard {
     props: {
         message: string;
@@ -2126,21 +1099,18 @@ interface ConsentLegalCard extends BaseCard {
             richTextBody: RichTextBody;
             skipButtonText: string;
             submitButtonText: string;
+            questionHtml?: string;
         };
         routingOptions: RoutingOptions;
     };
-    type: CardType.ConsentLegal;
+    type: "consentlegal";
 }
 interface BaseTaskPage {
     buttonText: string;
     headline: string;
+    type: RecordedTaskPageType;
 }
-declare const enum RecordedTaskPageType {
-    AvPermission = "av_permission",
-    ScreenPermission = "screen_permission",
-    StartTask = "start_task",
-    CompleteTask = "complete_task"
-}
+type RecordedTaskPageType = "av_permission" | "screen_permission" | "start_task" | "complete_task";
 interface PermissionTaskPage extends BaseTaskPage {
     captionText: string;
     headline: string;
@@ -2152,7 +1122,7 @@ interface PermissionTaskPage extends BaseTaskPage {
     skipButtonText?: string;
     svg: string;
     tryAgainButtonText: string;
-    type: RecordedTaskPageType.AvPermission;
+    type: "av_permission";
 }
 interface ScreenTaskPage extends BaseTaskPage {
     captionText: string;
@@ -2160,19 +1130,19 @@ interface ScreenTaskPage extends BaseTaskPage {
     permissionDeniedHeadline: string;
     selectTabText: string;
     skipButtonText: string;
-    type: RecordedTaskPageType.ScreenPermission;
+    type: "screen_permission";
 }
 interface StartTaskPage extends BaseTaskPage {
     captionText?: string;
     skipButtonText: string;
     taskDetail: string;
-    type: RecordedTaskPageType.StartTask;
+    type: "start_task";
 }
 interface CompleteTaskPage extends BaseTaskPage {
     captionText?: string;
     skipButtonText: string;
     taskDetail: string;
-    type: RecordedTaskPageType.CompleteTask;
+    type: "complete_task";
 }
 type RecordedTaskPage = PermissionTaskPage | ScreenTaskPage | StartTaskPage | CompleteTaskPage;
 interface RecordedTaskCardProperties {
@@ -2188,9 +1158,9 @@ interface RecordedTaskCard extends BaseCard {
         message: string;
         options: [];
         properties: RecordedTaskCardProperties;
-        routingOptions: RoutingOptions<Comparator.GivenUp>;
+        routingOptions: RoutingOptions<"given_up">;
     };
-    type: CardType.RecordedTask;
+    type: "recordedtask";
 }
 interface Labels {
     left: string;
@@ -2200,11 +1170,7 @@ interface RatingIcon {
     idx?: number;
     svg: string;
 }
-declare enum ScaleLabelType {
-    Number = "number",
-    Smiley = "smiley",
-    Star = "star"
-}
+type ScaleLabelType = "number" | "smiley" | "star";
 interface LikertCard extends BaseCard {
     props: {
         labels: Labels;
@@ -2220,9 +1186,9 @@ interface LikertCard extends BaseCard {
             scaleLabelType: ScaleLabelType;
             required: boolean;
         };
-        routingOptions: RoutingOptions<Comparator.Equal | Comparator.GivenUp | Comparator.GreaterThan | Comparator.GreaterThanOrEqual | Comparator.LessThan | Comparator.LessThanOrEqual | Comparator.NotEqual>;
+        routingOptions: RoutingOptions<"eq" | "given_up" | "gt" | "gte" | "lt" | "lte" | "neq">;
     };
-    type: CardType.Likert;
+    type: "likert";
 }
 interface OpenTextCard extends BaseCard {
     props: {
@@ -2233,14 +1199,15 @@ interface OpenTextCard extends BaseCard {
             buttonText?: string;
             captionText?: string;
             conceptUrl: ConceptUrl;
+            footerHtml?: string;
             openTextPlaceholder?: string;
             required: boolean;
             richTextBody: RichTextBody;
             skipButtonText?: string;
         };
-        routingOptions: RoutingOptions<Comparator.Contains | Comparator.DoesNotContain>;
+        routingOptions: RoutingOptions<"contains" | "notcontains">;
     };
-    type: CardType.Open;
+    type: "open";
 }
 interface MultipleChoiceOption {
     createdAt: string;
@@ -2248,7 +1215,9 @@ interface MultipleChoiceOption {
     id: number;
     label: string;
     optionProperties: null | {
-        allowsTextEntry: boolean;
+        allowsTextEntry?: boolean;
+        noneOfTheAbove?: boolean;
+        isPinned?: boolean;
     };
     order: number;
     productId: number;
@@ -2264,7 +1233,16 @@ interface CommonMultipleChoiceProps {
         buttonText?: string;
         captionText: string;
         conceptUrl: ConceptUrl;
-        randomize: "none" | "keeplast" | "all";
+        isDropdown?: boolean;
+        /**
+         * Placeholder text on the dropdown button when no items are selected
+         */
+        dropdownPlaceholderText?: string;
+        /**
+         * Text when multiple items are selected, such as "2 items selected" / "3 items selected"
+         */
+        dropdownMultiselectedText?: string;
+        randomize: Randomize;
         required: boolean;
     };
 }
@@ -2273,33 +1251,76 @@ interface MultiChoiceCard<C extends Comparator = DefaultComparator> extends Base
         routingOptions: RoutingOptions<C>;
     };
 }
-interface MultipleChoiceSingleSelectCard extends MultiChoiceCard<Comparator.Equal | Comparator.NotEqual | Comparator.ListAtLeastOne | Comparator.DoesNotInclude> {
-    type: CardType.MultipleChoice;
+interface MultipleChoiceSingleSelectCard extends MultiChoiceCard<"eq" | "neq" | "list_alo" | "list_dni"> {
+    type: "multiplechoice";
 }
-interface MultipleChoiceMultiSelectCard extends MultiChoiceCard<Comparator.ListAll | Comparator.ListAtLeastOne | Comparator.ListExact | Comparator.DoesNotInclude> {
-    type: CardType.MultipleSelect;
+interface MultipleChoiceMultiSelectCard extends MultiChoiceCard<"list_all" | "list_alo" | "list_exact" | "list_dni"> {
+    type: "multipleselect";
 }
-interface NPSCard extends BaseCard {
+interface MatrixCard extends BaseCard {
     props: {
-        labels: {
-            left: string;
-            right: string;
+        options: MultipleChoiceOption[];
+        message: string;
+        routingOptions: RoutingOptions<"skipped" | "partial" | "answered">;
+        properties: {
+            buttonText?: string;
+            captionText: string;
+            conceptUrl: ConceptUrl;
+            displayMatrixAsAccordion?: boolean;
+            matrixColumn: {
+                label: string;
+                value: string;
+            }[];
+            randomize: Randomize;
+            required: boolean;
         };
+    };
+    type: "matrix";
+}
+interface NPSCard extends BaseCard {
+    props: {
+        labels: Labels;
         message: string;
         options: [];
         properties: {
             buttonText?: string;
             captionText: string;
             conceptUrl: null;
-            labels: {
-                left: string;
-                right: string;
-            };
+            labels: Labels;
+            required: boolean;
+        };
+        routingOptions: RoutingOptions<"eq" | "gt" | "gte" | "lt" | "lte" | "neq">;
+    };
+    type: "nps";
+}
+interface RankOrderOption {
+    createdAt: string;
+    deletedAt: null;
+    id: number;
+    label: string;
+    order: number;
+    productId: number;
+    surveyId: number;
+    surveyQuestionId: number;
+    updatedAt: string;
+    value: string;
+}
+interface RankOderType extends BaseCard {
+    props: {
+        labels: Labels;
+        message: string;
+        options: RankOrderOption[];
+        properties: {
+            captionText: string;
+            buttonText?: string;
+            conceptUrl: ConceptUrl;
+            labels: Labels;
             required: boolean;
+            randomize: Randomize;
         };
-        routingOptions: RoutingOptions<Comparator.Equal | Comparator.GreaterThan | Comparator.GreaterThanOrEqual | Comparator.LessThan | Comparator.LessThanOrEqual | Comparator.NotEqual>;
+        routingOptions: RoutingOptions<"eq" | "gt" | "gte" | "lt" | "lte" | "neq">;
     };
-    type: CardType.NPS;
+    type: "rankorder";
 }
 interface VideoVoiceCard extends BaseCard {
     props: {
@@ -2309,6 +1330,7 @@ interface VideoVoiceCard extends BaseCard {
             buttonText: string;
             captionText: string;
             conceptUrl: null;
+            hideRecordedPrompt?: boolean;
             mediaType: "video" | "audio";
             required: boolean;
             skipButtonText: string;
@@ -2317,9 +1339,95 @@ interface VideoVoiceCard extends BaseCard {
         };
         routingOptions: RoutingOptions;
     };
-    type: CardType.VideoVoice;
+    type: "videovoice";
+}
+type Card = TextUrlPromptCard | ConsentLegalCard | RecordedTaskCard | LikertCard | OpenTextCard | MatrixCard | MultipleChoiceSingleSelectCard | MultipleChoiceMultiSelectCard | NPSCard | RankOderType | VideoVoiceCard;
+
+type InteractiveMatchType = "exactly" | "legacy";
+type PageUrlMatchType = "contains" | "exactly" | "legacy" | "notContains" | "regex" | "startsWith";
+interface InteractiveEvent {
+    id: number;
+    matchType: InteractiveMatchType;
+    name: string;
+    pattern: string;
+    properties: {
+        innerText: string;
+        selector?: string;
+        type?: "click";
+    };
+}
+interface PageUrlEvent {
+    id: number;
+    matchType: PageUrlMatchType;
+    pattern: string;
+}
+
+declare enum DismissReason {
+    Closed = "close.click",// user clicked the close button
+    Complete = "survey.completed",// user answered all questions
+    FeedbackClosed = "feedback.closed",// user either clicked on feedback button or close button
+    PageChange = "page.change",// productConfig.dismissOnPageChange == true and we detected a page change (excludes hash/query param changes)
+    API = "api",// JS called Sprig('dismissActiveSurvey')
+    Override = "override"
+}
+type StudyType = "feedbackButton" | "inProductSurvey" | "longFormSurvey";
+declare enum SprigEvent {
+    ReplayCapture = "replay.capture",
+    ReplayPaused = "replay.paused",
+    ReplayResumed = "replay.resumed",
+    FeedbackButtonLoaded = "feedback.button.loaded",
+    SDKReady = "sdk.ready",
+    SurveyAppeared = "survey.appeared",
+    SurveyCloseRequested = "survey.closeRequested",//This event signals to mobile the survey overlay can close
+    SurveyClosed = "survey.closed",
+    SurveyDimensions = "survey.dimensions",
+    SurveyFadingOut = "survey.fadingOut",
+    SurveyHeight = "survey.height",
+    SurveyPresented = "survey.presented",
+    SurveyLifeCycle = "survey.lifeCycle",
+    SurveyWidth = "survey.width",
+    SurveyWillClose = "survey.willClose",
+    SurveyWillPresent = "survey.will.present",
+    CloseSurveyOnOverlayClick = "close.survey.overlayClick",
+    VisitorIDUpdated = "visitor.id.updated",
+    QuestionAnswered = "question.answered"
+}
+declare const EVENTS: {
+    FEEDBACK_BUTTON_LOADED: SprigEvent;
+    SDK_READY: SprigEvent;
+    SURVEY_APPEARED: SprigEvent;
+    SURVEY_CLOSED: SprigEvent;
+    SURVEY_DIMENSIONS: SprigEvent;
+    SURVEY_FADING_OUT: SprigEvent;
+    SURVEY_HEIGHT: SprigEvent;
+    SURVEY_WIDTH: SprigEvent;
+    SURVEY_PRESENTED: SprigEvent;
+    SURVEY_LIFE_CYCLE: SprigEvent;
+    SURVEY_WILL_CLOSE: SprigEvent;
+    SURVEY_WILL_PRESENT: SprigEvent;
+    QUESTION_ANSWERED: SprigEvent;
+    REPLAY_CAPTURE: SprigEvent;
+    CLOSE_SURVEY_ON_OVERLAY_CLICK: SprigEvent;
+    VISITOR_ID_UPDATED: SprigEvent;
+    DATA: {
+        DISMISS_REASONS: {
+            API: DismissReason;
+            CLOSED: DismissReason;
+            COMPLETE: DismissReason;
+            PAGE_CHANGE: DismissReason;
+            OVERRIDE: DismissReason;
+        };
+        SURVEY_ID: string;
+    };
+};
+
+type Metric = "sdk_event_queue_latency_seconds" | "sdk_replay_add_event_batch_seconds" | "sdk_replay_cleanup_seconds" | "sdk_replay_compression_seconds" | "sdk_replay_get_events_between_seconds" | "sdk_replay_snapshot_seconds" | "sdk_mutations_nodes_added" | "sdk_mutations_nodes_removed" | "sdk_mutations_attributes_changed" | "sdk_mutations_character_data" | "sdk_dom_nodes_count" | "sdk_page_html_characters";
+type ThresholdType = "max" | "min";
+interface MetricThreshold {
+    metric: Metric;
+    type: ThresholdType;
+    value: number;
 }
-type Card = TextUrlPromptCard | ConsentLegalCard | RecordedTaskCard | LikertCard | OpenTextCard | MultipleChoiceSingleSelectCard | MultipleChoiceMultiSelectCard | NPSCard | VideoVoiceCard;
 
 interface RecordedTaskResponseType {
     questionId: number;
@@ -2327,35 +1435,63 @@ interface RecordedTaskResponseType {
     value: RecordedTaskResponseValueType;
 }
 
+type SurveyState = "ready" | "no survey";
+type ReplayDurationType = "after" | "before" | "beforeAndAfter";
+
+interface MobileReplayConfig {
+    mobileMetricsReportingEnabled?: boolean;
+    metricsReportingInterval?: number;
+    metricsThresholds?: MetricThreshold[];
+    maxMobileReplayDurationSeconds?: number;
+    mobileReplaySettings?: {
+        hideAllFormContents: boolean;
+        hidePasswordsOnly: boolean;
+        hideAllImages: boolean;
+    };
+}
 type SprigEventMap = {
-    [InternalEventName.CurrentQuestion]: [
+    "survey.question": [
         {
-            [InternalEventData.QuestionId]: number;
-            [InternalEventData.Props]: unknown;
+            qid: number;
+            props: unknown;
         }
     ];
-    [InternalEventName.RecordedTaskPermissionScreen]: [];
-    [InternalEventName.RecordedTaskStart]: [];
-    [InternalEventName.SurveyComplete]: [];
-    [InternalEventName.VerifyViewVersion]: [
+    "recorded.task.permission.screen": [];
+    "recorded.task.start": [];
+    "survey.complete": [number];
+    "verify.view.version": [
         {
-            [InternalEventData.ViewVersion]: string;
+            "view.version": string;
         }
     ];
     [SprigEvent.CloseSurveyOnOverlayClick]: [];
-    [SprigEvent.SDKReady]: [];
-    [SprigEvent.SurveyAppeared]: [];
+    [SprigEvent.FeedbackButtonLoaded]: [
+        {
+            name: string;
+            "survey.id"?: number;
+        }
+    ];
+    [SprigEvent.SDKReady]: [MobileReplayConfig];
+    [SprigEvent.SurveyAppeared]: [
+        {
+            name: string;
+            "survey.id": number;
+        }
+    ];
     [SprigEvent.SurveyDimensions]: [
         {
             contentFrameHeight: number;
             contentFrameWidth: number;
             name: string;
+            "survey.id": number;
         }
     ];
     [SprigEvent.SurveyClosed]: [
         {
             initiator?: string;
             name: string;
+            studyType?: StudyType;
+            "survey.id": number;
         }
     ];
     [SprigEvent.SurveyFadingOut]: [];
@@ -2363,6 +1499,14 @@ type SprigEventMap = {
         {
             name: string;
             contentFrameHeight: number;
+            "survey.id": number;
+        }
+    ];
+    [SprigEvent.SurveyWidth]: [
+        {
+            name: string;
+            contentFrameWidth: number;
+            "survey.id": number;
         }
     ];
     [SprigEvent.SurveyLifeCycle]: [{
@@ -2371,12 +1515,23 @@ type SprigEventMap = {
     [SprigEvent.SurveyPresented]: [
         {
             name: string;
+            "survey.id": number;
+        }
+    ];
+    [SprigEvent.SurveyCloseRequested]: [
+        {
+            initiator: DismissReason;
+            name?: string;
+            studyType?: StudyType;
+            "survey.id": number;
         }
     ];
     [SprigEvent.SurveyWillClose]: [
         {
             initiator: DismissReason;
             name?: string;
+            studyType?: StudyType;
+            "survey.id": number;
         }
     ];
     [SprigEvent.SurveyWillPresent]: [
@@ -2393,104 +1548,87 @@ type SprigEventMap = {
             answeredAt?: number;
             questionIndex?: number;
             value: unknown;
+            "survey.id": number;
+        }
+    ];
+    [SprigEvent.ReplayCapture]: [
+        {
+            responseGroupUid: string;
+            hasQuestions: boolean;
+            uploadId: string;
+            seconds: number;
+            replayType: ReplayDurationType;
+            generateVideoUploadUrlPayload: {
+                isReplay: boolean;
+                mediaRecordingUid: string;
+                mediaType: MediaType;
+                questionId: number;
+                responseGroupUid: string;
+                surveyId: number;
+                updatedAt: string;
+                visitorId: string | null;
+            };
+            surveyId: number;
         }
     ];
-    [SprigRecordingEvent.AvPermission]: [
+    [SprigEvent.ReplayPaused]: [];
+    [SprigEvent.ReplayResumed]: [];
+    "av.permission": [
         {
-            [SprigRecordingEventData.StreamReadyCallback]: (avStream: MediaStream | null, captureStream?: MediaStream | null) => void;
-            [SprigRecordingEventData.PermissionDescriptors]: AvPermission[];
+            "stream.ready": (avStream: MediaStream | null, captureStream?: MediaStream | null) => void;
+            "permission.descriptors": AvPermission[];
         }
     ];
-    [SprigRecordingEvent.BeginRecording]: [
+    "begin.recording": [
         {
-            [SprigRecordingEventData.RecordingMediaTypes]: MediaType[];
-            [SprigRecordingEventData.StartRecordingCallback]: (mediaRecordingUids: UUID[]) => void;
+            "recording.media.types": MediaType[];
+            "start.recording.callback": (mediaRecordingUids: UUID[]) => void;
         }
     ];
-    [SprigRecordingEvent.FinishTask]: [
+    "finish.task": [
         {
-            [SprigRecordingEventData.BeginCallback]: (mediaRecordingUid: UUID) => void;
-            [SprigRecordingEventData.CurrentIndex]: number;
-            [SprigRecordingEventData.PassthroughData]: PassthroughData;
-            [SprigRecordingEventData.ProgressCallback]: (mediaRecordingUid: UUID, data: {
+            "begin.callback": (mediaRecordingUid: UUID) => void;
+            "current.index": number;
+            "passthrough.data": PassthroughData;
+            "progress.callback": (mediaRecordingUid: UUID, data: {
                 detail: number;
             }) => void;
-            [SprigRecordingEventData.TaskCompleteCallback]: (taskDurationMillisecond: number) => void;
-            [SprigRecordingEventData.TaskResponse]: RecordedTaskResponseType;
-            [SprigRecordingEventData.UploadCallback]: (mediaRecordingUid: UUID | null, successOrError: true | unknown) => void;
+            "task.complete.callback": (taskDurationMillisecond: number) => void;
+            "task.response": RecordedTaskResponseType;
+            "upload.callback": (mediaRecordingUid: UUID | null, successOrError: true | unknown) => void;
         }
     ];
-    [SprigRecordingEvent.PermissionStatus]: [
+    "permission.status": [
         {
-            [SprigRecordingEventData.PermissionStatusCallback]: (avStream: MediaStream | undefined, hasVideoPermission: boolean, hasScreenPermission: boolean, captureStream: MediaStream | undefined) => void;
+            "permission.status.callback": (avStream: MediaStream | undefined, hasVideoPermission: boolean, hasScreenPermission: boolean, captureStream: MediaStream | undefined) => void;
         }
     ];
-    [SprigRecordingEvent.ScreenPermission]: [
+    "screen.permission": [
         {
-            [SprigRecordingEventData.ScreenPermissionRequested]?: (data: boolean) => void;
-            [SprigRecordingEventData.StreamReadyCallback]: (avStream: MediaStream | null, captureStream: MediaStream | null) => void;
+            "screen.permission.requested"?: (data: boolean) => void;
+            "stream.ready.callback": (avStream: MediaStream | null, captureStream: MediaStream | null) => void;
         }
     ];
-    [SprigRecordingEvent.StartTask]: [];
+    "start.task": [];
 };
 declare const eventEmitter: Emitter<SprigEventMap>;
 type SprigEventEmitter = typeof eventEmitter;
 
-type MatchType = "exactly" | "legacy";
-interface InteractiveEvent {
-    id: number;
-    matchType: MatchType;
-    name: string;
-    pattern: string;
-    properties: {
-        innerText: string;
-        selector?: string;
-        type?: "click";
-    };
-}
-interface PageUrlEvent {
-    id: number;
-    matchType: MatchType | "contains" | "notContains" | "regex" | "startsWith";
-    pattern: string;
-}
-
-declare const enum FramePosition {
-    BottomLeft = "bottomLeft",
-    BottomRight = "bottomRight",
-    Center = "center",
-    TopLeft = "topLeft",
-    TopRight = "topRight"
-}
-declare const enum HttpHeader {
-    Error = "x-ul-error",
-    EnvironmentID = "x-ul-environment-id",
-    InstallationMethod = "x-ul-installation-method",
-    PartnerAnonymousId = "x-ul-anonymous-id",
-    Platform = "userleap-platform",
-    PreviewMode = "x-ul-preview-mode",
-    UserID = "x-ul-user-id",
-    VisitorID = "x-ul-visitor-id"
-}
-declare const enum Platform {
-    Email = "email",
-    Link = "link",
-    Web = "web"
-}
-declare const enum InstallationMethod {
-    Npm = "web-npm",
-    NpmBundled = "web-npm-bundled",
-    Gtm = "web-gtm",
-    Segment = "web-segment",
-    SegmentAndroid = "android-segment",
-    SegmentReactNative = "react-native-segment",
-    SegmentIOS = "ios-segment",
-    Snippet = "web-snippet"
-}
+type FramePosition = "bottomLeft" | "bottomRight" | "center" | "topLeft" | "topRight";
+type Platform = "email" | "link" | "web";
+type InstallationMethod = "web-npm" | "web-npm-bundled" | "web-gtm" | "web-segment" | "android-segment" | "react-native-segment" | "ios-segment" | "web-snippet";
 interface Answer {
     questionId: number;
     value: unknown;
 }
-interface Config {
+type FeedbackPlacement = "center-left" | "center-right" | "bottom-left" | "bottom-right";
+type FeedbackDesktopDisplay = "center-modal" | "slider";
+interface AppProductConfig {
+    framePosition?: FramePosition;
+    desktopDisplay?: FeedbackDesktopDisplay;
+    placement?: FeedbackPlacement;
+}
+interface Config extends MobileReplayConfig {
     allResponses: unknown[];
     answers?: Answer[];
     apiURL: string;
@@ -2508,7 +1646,7 @@ interface Config {
         };
     };
     customMetadata?: Record<string, unknown>;
-    customStyles: string;
+    customStyles?: string;
     dismissOnPageChange: boolean;
     forceBrandedLogo?: boolean;
     endCard?: {
@@ -2526,30 +1664,37 @@ interface Config {
     frame: HTMLIFrameElement & {
         eventEmitter?: SprigEventEmitter;
         setHeight?: (height: number) => void;
+        setWidth?: (width: number) => void;
     };
     framePosition: FramePosition;
     headers: {
         "accept-language"?: string;
         /** @example "Bearer 123" */
         Authorization?: string;
-        "Content-Type": string;
-        "userleap-platform": Platform;
+        "Content-Type"?: string;
+        "userleap-platform": Platform | "ios" | "android" | "video_recorder";
+        "sprig-modules"?: string;
         /** @example "SJcVfq-7QQ" */
-        [HttpHeader.EnvironmentID]?: string;
-        [HttpHeader.InstallationMethod]: InstallationMethod;
-        [HttpHeader.PartnerAnonymousId]?: string;
-        [HttpHeader.PreviewMode]?: string;
+        "x-ul-environment-id"?: string;
+        "x-ul-installation-method": InstallationMethod;
+        "x-ul-anonymous-id"?: string;
+        "x-ul-error"?: string;
+        "x-ul-preview-mode"?: string;
         /** @example "2.18.0" */
-        "x-ul-sdk-version": string;
-        [HttpHeader.UserID]?: string;
-        [HttpHeader.VisitorID]?: UUID;
+        "x-ul-sdk-version"?: string;
+        /** For web-bundled sdk */
+        "x-ul-package-version"?: string;
+        "x-ul-user-id"?: string;
+        "x-ul-visitor-id"?: string;
     };
     installationMethod?: InstallationMethod;
     interactiveEvents: InteractiveEvent[];
     interactiveEventsHandler?: (e: MouseEvent) => void;
+    isOnQuestionsTab?: boolean;
     isPreview?: boolean;
     launchDarklyEnabled?: boolean;
     locale: string;
+    logBufferLimit?: number;
     marketingUrl?: string;
     maxAttrNameLength: number;
     maxAttrValueLength: number;
@@ -2561,13 +1706,15 @@ interface Config {
     mode?: string;
     mute?: boolean;
     optimizelyEnabled?: boolean;
+    outstandingTransactionLimit?: number | null;
     overlayStyle: "light";
     overlayStyleMobile: "none";
     pageUrlEvents: PageUrlEvent[];
     path?: string;
     platform?: Platform;
     previewKey?: string | null;
-    replayNonce?: string;
+    previewMode?: boolean;
+    productConfig?: AppProductConfig;
     replaySettings?: object;
     requireUserIdForTracking: boolean;
     responseGroupUid: UUID;
@@ -2576,10 +1723,13 @@ interface Config {
     slugName: null;
     startingQuestionIdx?: number | null;
     styleNonce?: string;
+    studyType?: StudyType;
     surveyId: number;
     tabTitle: string;
+    trackPageViewUrl?: string;
     ulEvents: typeof SprigEvent;
     UpChunk: Window["UpChunk"];
+    upchunkLibraryURL?: string;
     useDesktopPrototype?: boolean;
     useMobileStyling: boolean;
     userId: UUID | null;
@@ -2592,33 +1742,54 @@ interface Config {
     };
 }
 
-declare enum ReplayEventType {
-    Click = "Sprig_Click",
-    Event = "Sprig_TrackEvent",
-    PageView = "Sprig_PageView",
-    SurveyShown = "Sprig_ShowSurvey",
-    SurveySubmitted = "Sprig_SubmitSurvey",
-    Noop = "Sprig_Noop"
+interface Experiment {
+    id: string;
+    variation?: string;
 }
+
+type QueueItem = [string, ...unknown[]] | (() => void);
+declare class SprigQueue {
+    paused: boolean;
+    queue: QueueItem[];
+    ul: WindowSprig;
+    constructor(ul: WindowSprig, queue: QueueItem[]);
+    flush(queue: QueueItem[]): void;
+    isPaused(): boolean;
+    pause(): void;
+    unpause(): void;
+    push(action: QueueItem): void;
+    perform(func: () => void): void | Promise<unknown>;
+    /**
+     * Removes all queued items
+     */
+    empty(): void;
+}
+
 type EventDigest = {
     timestamp: number;
-    type: ReplayEventType.Click;
+    type: "Sprig_Click";
 } | {
     timestamp: number;
     name: string;
-    type: ReplayEventType.Event;
+    type: "Sprig_TrackEvent";
 } | {
     timestamp: number;
-    type: ReplayEventType.PageView;
+    type: "Sprig_PageView";
     url: string;
 } | {
     timestamp: number;
     surveyId: string;
-    type: ReplayEventType.SurveyShown;
+    type: "Sprig_ShowSurvey";
 } | {
     timestamp: number;
     surveyId: string;
-    type: ReplayEventType.SurveySubmitted;
+    type: "Sprig_SubmitSurvey";
+} | {
+    timestamp: number;
+    type: "Sprig_ReplayPaused";
+} | {
+    timestamp: number;
+    type: "Sprig_ReplayResumed";
 };
 
 declare namespace optimizely {
@@ -2663,6 +1834,7 @@ declare namespace optimizely {
 declare namespace sprigConfig {
   type IdentifyResult = Promise<
     | {
+        error?: Error;
         success: boolean;
         message?: string;
         surveyState?: SurveyState;
@@ -2687,7 +1859,7 @@ declare namespace sprigConfig {
       surveyId: number;
       responseGroupUuid: string;
       eventDigest?: EventDigest[];
-    }) => Promise<void>;
+    }) => Promise<boolean>;
     _generateVideoUploadUrl: (body: {
       mediaRecordingUid?: string;
       mediaType?: MediaType;
@@ -2696,13 +1868,16 @@ declare namespace sprigConfig {
       surveyId?: number;
       updatedAt?: string;
       visitorId?: string | null;
+      isReplay?: boolean;
     }) => Promise<string | null>;
     _previewSurvey: (surveyTemplateId: UUID) => void;
     _reviewSurvey: (surveyId: number) => void;
+    _reportMetric: (name: Metric, value: number) => void;
 
     // external apis
     addListener: (event: SprigEvent, listener: SprigListener) => Promise<void>;
     addSurveyListener: (listener: SprigListener) => Promise<void>;
+    applyFeedbackStyles: (styles: { button?: string; view?: string }) => void;
     applyStyles: (styleString: string) => void;
     dismissActiveSurvey: (reason?: DismissReason) => void;
     displaySurvey: (surveyId: number) => IdentifyResult;
@@ -2715,7 +1890,7 @@ declare namespace sprigConfig {
     importLaunchDarklyData: (data: Record<string, number | undefined>) => void;
     integrateOptimizely: (
       strData: string | { experiments: Experiment[] },
-      isOverride?: boolean
+      isOverride?: boolean,
     ) => void;
     integrateOptimizelyClient: (client: Client) => void;
     logoutUser: () => void;
@@ -2725,22 +1900,25 @@ declare namespace sprigConfig {
     removeAttributes: (attributes: SprigAttributes) => IdentifyResult;
     removeListener: (
       event: SprigEvent,
-      listener: SprigListener
+      listener: SprigListener,
     ) => Promise<void>;
     removeSurveyListener: (listener: SprigListener) => Promise<void>;
     reviewSurvey: (surveyId: number) => void;
-    setAttribute: (attribute: string, value: string | number) => IdentifyResult;
+    setAttribute: (
+      attribute: string,
+      value: string | number | boolean,
+    ) => IdentifyResult;
     setAttributes: (attributes?: SprigAttributes) => IdentifyResult;
     setPartnerAnonymousId: (
-      partnerAnonymousId: string
+      partnerAnonymousId: string,
     ) => Promise<{ success: boolean; message?: string }>;
     setVisitorAttribute: (
       attribute: string,
-      value: string | number
+      value: string | number,
     ) => IdentifyResult;
     setWindowDimensions: (
       width: number | string,
-      height: number | string
+      height: number | string,
     ) => void;
     setEmail: (email: string) => IdentifyResult;
     setPreviewKey: (previewKey: string) => void;
@@ -2752,14 +1930,18 @@ declare namespace sprigConfig {
       eventName: string,
       properties?: TrackPayload["properties"],
       metadata?: SprigMetadata,
-      showSurveyCallback?: (surveyId?: number) => Promise<boolean>
+      showSurveyCallback?: (surveyId?: number) => Promise<boolean>,
     ) => IdentifyResult;
     trackPageView: (
       url: string,
       properties?: SprigProperties,
-      showSurveyCallback?: (surveyId?: number) => Promise<boolean>
+      showSurveyCallback?: (surveyId?: number) => Promise<boolean>,
+      calledFromApi?: boolean,
     ) => void;
+    trackHistory?: ({ event: string }) => void;
     unmute: () => void;
+    pauseReplayRecording: () => void;
+    resumeReplayRecording: () => void;
   }
 
   type SprigCommand = keyof SprigAPIActions;
@@ -2772,7 +1954,10 @@ declare namespace sprigConfig {
     SprigAPIActions &
     SprigCommands & {
       _API_URL: string;
-      _config: Config;
+      _config: Config & {
+        desktopDisplay?: string;
+        previewLanguage?: string;
+      };
       _gtm: unknown; // TODO: determine if boolean?
       _queue: SprigQueue;
       _segment: unknown; // TODO: determine if boolean?
@@ -2784,19 +1969,29 @@ declare namespace sprigConfig {
       email?: string | null;
       envId: string;
       error?: Error;
+      feedbackCustomStyles?: string;
+      forceDirectEmbed?: boolean;
       frameId: string;
+      isMobileSDK?: boolean;
       loaded: boolean;
       locale?: string;
-      localStorageAvailable: boolean;
       maxHeight?: number | string;
       maxInflightReplayRequests?: number;
+      outstandingTransactionLimit?: number | null;
       mobileHeadersJSON?: string;
       nonce?: string;
       partnerAnonymousId: string | null;
-      replayNonce?: string;
-      reportError: (name: string, err: Error, extraInfo?: object) => void;
+      pointerDownTarget?: EventTarget | null;
+      replayLibraryURL?: string;
+      reportError: (
+        name: string,
+        err: Error,
+        extraInfo?: object,
+        bodyInfo?: object,
+      ) => void;
       sampleRate?: number;
       token: string | null;
+      upchunkLibraryURL?: string;
       UPDATES: typeof EVENTS;
       viewSDKURL?: string;
       windowDimensions?: {
@@ -2805,49 +2000,42 @@ declare namespace sprigConfig {
       };
     };
 }
-type ArgumentTypes<F> = F extends (...args: infer A) => unknown
-  ? A
-  : never;
-type ArgumentType<T> = T extends (arg1: infer U, ...args: unknown[]) => unknown
-  ? U
-  : unknown;
-type PublicOf<T> = { [K in keyof T]: T[K] };
-type createUpload = typeof _mux_upchunk["createUpload"];
-type rrwebRecord = typeof rrweb["record"];
-type rrwebCustomEvent = typeof rrweb["record"]["addCustomEvent"];
+
 declare global {
   interface Window {
     __cfg: Config;
     attachEvent?: typeof window.addEventListener;
+    Backbone: {
+      history: typeof window.history;
+    };
     Intercom: { ul_wasVisible?: boolean } & ((
       method: string,
-      data: unknown
+      data?: unknown,
     ) => void);
     optimizely?: optimizely.Optimizely;
     optimizelyDatafile?: object;
     previewMode?: unknown;
     UpChunk: {
-      createUpload: (
-        ...args: ArgumentTypes<createUpload>
-      ) => PublicOf<ReturnType<createUpload>>;
+      createUpload: typeof createUpload;
     };
     _Sprig?: sprigConfig.WindowSprig;
     Sprig: sprigConfig.WindowSprig;
     UserLeap: sprigConfig.WindowSprig;
-    rrwebRecord?: {
-      addCustomEvent: (
-        ...args: ArgumentTypes<rrwebCustomEvent>
-      ) => PublicOf<ReturnType<rrwebCustomEvent>>;
-    } & ((
-      arg: Omit<ArgumentType<rrwebRecord>, "hooks">
-    ) => PublicOf<ReturnType<rrwebRecord>>);
-    sprigAPI?: object;
+    rrwebRecord?: (typeof _rrweb_record)["record"];
+    sprigAPI?: { openUrl: (url: string) => void };
+    SprigLoggerCallback?: (message: string) => void;
   }
 
   type WindowSprig = sprigConfig.WindowSprig;
   type SprigAttributes = Record<string, boolean | number | string>;
   type SprigListener = Listener<unknown[]>;
-  type SprigMetadata = Record<string, unknown>;
+  type SprigMetadata = {
+    url?: string;
+    trackPageView?: boolean;
+    optimizelyExperiments?: object;
+    launchDarklyFlags?: object;
+    eventProperties?: SprigProperties;
+  };
   type SprigProperties = Record<string, unknown>;
   type SprigAPIActions = sprigConfig.SprigAPIActions;
   type TrackPayload = sprigConfig.TrackPayload;
@@ -2862,28 +2050,36 @@ declare class SprigAPI {
      * Include external events emitted from Sprig
      */
     UPDATES: {
+        FEEDBACK_BUTTON_LOADED: SprigEvent;
         SDK_READY: SprigEvent;
         SURVEY_APPEARED: SprigEvent;
         SURVEY_CLOSED: SprigEvent;
         SURVEY_DIMENSIONS: SprigEvent;
         SURVEY_FADING_OUT: SprigEvent;
         SURVEY_HEIGHT: SprigEvent;
+        SURVEY_WIDTH: SprigEvent;
         SURVEY_PRESENTED: SprigEvent;
         SURVEY_LIFE_CYCLE: SprigEvent;
         SURVEY_WILL_CLOSE: SprigEvent;
         SURVEY_WILL_PRESENT: SprigEvent;
         QUESTION_ANSWERED: SprigEvent;
-        CLOSE_SURVEY_ON_OVERLAY_CLICK: SprigEvent;
+        REPLAY_CAPTURE: SprigEvent;
+        CLOSE_SURVEY_ON_OVERLAY_CLICK: SprigEvent; /**
+         * Tracks a page view with the provided URL and additional event properties.
+         */
         VISITOR_ID_UPDATED: SprigEvent;
         DATA: {
             DISMISS_REASONS: {
                 API: DismissReason;
                 CLOSED: DismissReason;
+                /**
+                 * Apply a css string representing the customized styles
+                 */
                 COMPLETE: DismissReason;
                 PAGE_CHANGE: DismissReason;
                 OVERRIDE: DismissReason;
             };
-            SURVEY_ID: SprigEventData;
+            SURVEY_ID: string;
         };
     };
     /**
@@ -2905,7 +2101,7 @@ declare class SprigAPI {
     /**
      * Set an arbitrary attribute on the visitor
      */
-    setAttribute(attribute: string, value: string): void;
+    setAttribute(attribute: string, value: string | number | boolean): void;
     /**
      * Set attributes on visitor
      */
@@ -2980,6 +2176,14 @@ declare class SprigAPI {
      * Clears Sprig from window
      */
     teardown(): void;
+    /**
+     * Pause replay recording
+     */
+    pauseReplayRecording(): void;
+    /**
+     * Resume replay recording
+     */
+    resumeReplayRecording(): void;
 }
 type NpmConfig = {
     envId?: string;
@@ -2996,4 +2200,4 @@ declare const sprig: {
 };
 type WindowSprig$1 = typeof window.Sprig;
 
-export { DismissReason, SprigAPI, SprigEvent, WindowSprig$1 as WindowSprig, sprig };
+export { DismissReason, SprigAPI, SprigEvent, type WindowSprig$1 as WindowSprig, sprig };