@sprig-technologies/sprig-bundled 1.0.1 → 1.1.0

package/dist/index.d.ts

@@ -0,0 +1,3062 @@
+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 {
+    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;
+}
+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 class ClassList {
+    private onChange;
+    classes: string[];
+    constructor(classText?: string, onChange?: ((newClassText: string) => void) | undefined);
+    add: (...classNames: string[]) => void;
+    remove: (...classNames: string[]) => void;
+}
+type CSSStyleDeclaration = Record<string, string> & {
+    setProperty: (name: string, value: string | null, priority?: string | null) => void;
+    removeProperty: (name: string) => string;
+};
+
+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;
+    };
+} & 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 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;
+    };
+} & 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;
+    };
+} & 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 class RRStyleElement extends RRElement {
+    rules: (styleSheetRuleData | styleDeclarationData)[];
+}
+declare class RRIFrameElement extends RRElement {
+    contentDocument: RRDocument;
+    constructor(upperTagName: string, mirror: Mirror);
+}
+interface RRElementTagNameMap {
+    audio: RRMediaElement;
+    canvas: RRCanvasElement;
+    iframe: RRIFrameElement;
+    style: RRStyleElement;
+    video: RRMediaElement;
+}
+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 SingleOrArray<T> = T[] | T;
+interface EventObject {
+    type: string;
+}
+declare type InitEvent = {
+    type: 'xstate.init';
+};
+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;
+    };
+    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];
+    };
+}
+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 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 namespace record {
+    var addCustomEvent: <T>(tag: string, payload: T) => void;
+    var freezePage: () => void;
+    var takeFullSnapshot: (isCheckout?: boolean | undefined) => void;
+    var mirror: Mirror$1;
+}
+
+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;
+
+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,
+  };
+}
+
+interface XhrResponse {
+  body: Object | string;
+  statusCode: number;
+  method: string;
+  headers: XhrHeaders;
+  url: string;
+  rawRequest: XMLHttpRequest;
+}
+
+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;
+    maxChunkSize?: number;
+};
+declare class ChunkedStreamIterable implements AsyncIterable<Blob> {
+    protected readableStream: ReadableStream<Uint8Array | Blob>;
+    protected _chunkSize: number | undefined;
+    protected defaultChunkSize: number;
+    readonly minChunkSize: number;
+    readonly maxChunkSize: number;
+    constructor(readableStream: ReadableStream<Uint8Array | Blob>, options?: ChunkedStreamIterableOptions);
+    get chunkSize(): number;
+    set chunkSize(value: number);
+    get chunkByteSize(): number;
+    [Symbol.asyncIterator](): AsyncIterator<Blob>;
+}
+declare type EventName = 'attempt' | 'attemptFailure' | 'chunkSuccess' | 'error' | 'offline' | 'online' | 'progress' | 'success';
+declare type AllowedMethods = 'PUT' | 'POST' | 'PATCH';
+interface UpChunkOptions {
+    endpoint: string | ((file?: File) => Promise<string>);
+    file: File;
+    method?: AllowedMethods;
+    headers?: XhrHeaders | (() => XhrHeaders) | (() => Promise<XhrHeaders>);
+    maxFileSize?: number;
+    chunkSize?: number;
+    attempts?: number;
+    delayBeforeAttempt?: number;
+    retryCodes?: number[];
+    dynamicChunkSize?: boolean;
+    maxChunkSize?: number;
+    minChunkSize?: number;
+}
+declare class UpChunk {
+    static createUpload(options: UpChunkOptions): UpChunk;
+    endpoint: string | ((file?: File) => Promise<string>);
+    file: File;
+    headers: XhrHeaders | (() => XhrHeaders) | (() => Promise<XhrHeaders>);
+    method: AllowedMethods;
+    attempts: number;
+    delayBeforeAttempt: number;
+    retryCodes: number[];
+    dynamicChunkSize: boolean;
+    protected chunkedStreamIterable: ChunkedStreamIterable;
+    protected chunkedStreamIterator: AsyncIterator<Blob, any, undefined>;
+    protected pendingChunk?: Blob;
+    private chunkCount;
+    private maxFileBytes;
+    private endpointValue;
+    private totalChunks;
+    private attemptCount;
+    private offline;
+    private _paused;
+    private success;
+    private currentXhr?;
+    private lastChunkStart;
+    private nextChunkRangeStart;
+    private eventTarget;
+    constructor(options: UpChunkOptions);
+    protected get maxChunkSize(): number;
+    protected get minChunkSize(): number;
+    get chunkSize(): number;
+    set chunkSize(value: number);
+    get chunkByteSize(): number;
+    get totalChunkSize(): number;
+    /**
+     * Subscribe to an event
+     */
+    on(eventName: EventName, fn: (event: CustomEvent) => void): void;
+    /**
+     * Subscribe to an event once
+     */
+    once(eventName: EventName, fn: (event: CustomEvent) => void): void;
+    /**
+     * Unsubscribe to an event
+     */
+    off(eventName: EventName, fn: (event: CustomEvent) => void): void;
+    get paused(): boolean;
+    abort(): void;
+    pause(): void;
+    resume(): void;
+    /**
+     * Dispatch an event
+     */
+    private dispatch;
+    /**
+     * Validate options and throw errors if expectations are violated.
+     */
+    private validateOptions;
+    /**
+     * Endpoint can either be a URL or a function that returns a promise that resolves to a string.
+     */
+    private getEndpoint;
+    private xhrPromise;
+    /**
+     * Send chunk of the file with appropriate headers
+     */
+    protected sendChunk(chunk: Blob): Promise<XhrResponse>;
+    protected sendChunkWithRetries(chunk: Blob): Promise<boolean>;
+    /**
+     * Manage the whole upload by calling getChunk & sendChunk
+     * handle errors & retries and dispatch events
+     */
+    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 enum NOTIFICATION_TYPES {
+    ACTIVATE = "ACTIVATE:experiment, user_id,attributes, variation, event",
+    DECISION = "DECISION:type, userId, attributes, decisionInfo",
+    LOG_EVENT = "LOG_EVENT:logEvent",
+    OPTIMIZELY_CONFIG_UPDATE = "OPTIMIZELY_CONFIG_UPDATE",
+    TRACK = "TRACK:event_key, user_id, attributes, event_tags, event"
+}
+
+declare type UserAttributes = {
+    [name: string]: any;
+};
+declare type EventTags = {
+    [key: string]: string | number | null;
+};
+interface ListenerPayload {
+    userId: string;
+    attributes?: UserAttributes;
+}
+declare type NotificationListener<T extends ListenerPayload> = (notificationData: T) => void;
+interface NotificationCenter {
+    addNotificationListener<T extends ListenerPayload>(notificationType: string, callback: NotificationListener<T>): number;
+    removeNotificationListener(listenerId: number): boolean;
+    clearAllNotificationListeners(): void;
+    clearNotificationListeners(notificationType: NOTIFICATION_TYPES): void;
+}
+declare enum OptimizelyDecideOption {
+    DISABLE_DECISION_EVENT = "DISABLE_DECISION_EVENT",
+    ENABLED_FLAGS_ONLY = "ENABLED_FLAGS_ONLY",
+    IGNORE_USER_PROFILE_SERVICE = "IGNORE_USER_PROFILE_SERVICE",
+    INCLUDE_REASONS = "INCLUDE_REASONS",
+    EXCLUDE_VARIABLES = "EXCLUDE_VARIABLES"
+}
+/**
+ * Optimizely Config Entities
+ */
+interface OptimizelyExperiment {
+    id: string;
+    key: string;
+    audiences: string;
+    variationsMap: {
+        [variationKey: string]: OptimizelyVariation;
+    };
+}
+interface OptimizelyVariable {
+    id: string;
+    key: string;
+    type: string;
+    value: string;
+}
+interface Client {
+    notificationCenter: NotificationCenter;
+    createUserContext(userId: string, attributes?: UserAttributes): OptimizelyUserContext | null;
+    activate(experimentKey: string, userId: string, attributes?: UserAttributes): string | null;
+    track(eventKey: string, userId: string, attributes?: UserAttributes, eventTags?: EventTags): void;
+    getVariation(experimentKey: string, userId: string, attributes?: UserAttributes): string | null;
+    setForcedVariation(experimentKey: string, userId: string, variationKey: string | null): boolean;
+    getForcedVariation(experimentKey: string, userId: string): string | null;
+    isFeatureEnabled(featureKey: string, userId: string, attributes?: UserAttributes): boolean;
+    getEnabledFeatures(userId: string, attributes?: UserAttributes): string[];
+    getFeatureVariable(featureKey: string, variableKey: string, userId: string, attributes?: UserAttributes): unknown;
+    getFeatureVariableBoolean(featureKey: string, variableKey: string, userId: string, attributes?: UserAttributes): boolean | null;
+    getFeatureVariableDouble(featureKey: string, variableKey: string, userId: string, attributes?: UserAttributes): number | null;
+    getFeatureVariableInteger(featureKey: string, variableKey: string, userId: string, attributes?: UserAttributes): number | null;
+    getFeatureVariableString(featureKey: string, variableKey: string, userId: string, attributes?: UserAttributes): string | null;
+    getFeatureVariableJSON(featureKey: string, variableKey: string, userId: string, attributes?: UserAttributes): unknown;
+    getAllFeatureVariables(featureKey: string, userId: string, attributes?: UserAttributes): {
+        [variableKey: string]: unknown;
+    } | null;
+    getOptimizelyConfig(): OptimizelyConfig | null;
+    onReady(options?: {
+        timeout?: number;
+    }): Promise<{
+        success: boolean;
+        reason?: string;
+    }>;
+    close(): Promise<{
+        success: boolean;
+        reason?: string;
+    }>;
+}
+declare type OptimizelyExperimentsMap = {
+    [experimentKey: string]: OptimizelyExperiment;
+};
+declare type OptimizelyVariablesMap = {
+    [variableKey: string]: OptimizelyVariable;
+};
+declare type OptimizelyFeaturesMap = {
+    [featureKey: string]: OptimizelyFeature;
+};
+declare type OptimizelyAttribute = {
+    id: string;
+    key: string;
+};
+declare type OptimizelyAudience = {
+    id: string;
+    name: string;
+    conditions: string;
+};
+declare type OptimizelyEvent = {
+    id: string;
+    key: string;
+    experimentsIds: string[];
+};
+interface OptimizelyFeature {
+    id: string;
+    key: string;
+    experimentRules: OptimizelyExperiment[];
+    deliveryRules: OptimizelyExperiment[];
+    variablesMap: OptimizelyVariablesMap;
+    /**
+     * @deprecated Use experimentRules and deliveryRules
+     */
+    experimentsMap: OptimizelyExperimentsMap;
+}
+interface OptimizelyVariation {
+    id: string;
+    key: string;
+    featureEnabled?: boolean;
+    variablesMap: OptimizelyVariablesMap;
+}
+interface OptimizelyConfig {
+    environmentKey: string;
+    sdkKey: string;
+    revision: string;
+    /**
+     * This experimentsMap is for experiments of legacy projects only.
+     * For flag projects, experiment keys are not guaranteed to be unique
+     * across multiple flags, so this map may not include all experiments
+     * when keys conflict.
+     */
+    experimentsMap: OptimizelyExperimentsMap;
+    featuresMap: OptimizelyFeaturesMap;
+    attributes: OptimizelyAttribute[];
+    audiences: OptimizelyAudience[];
+    events: OptimizelyEvent[];
+    getDatafile(): string;
+}
+interface OptimizelyUserContext {
+    getUserId(): string;
+    getAttributes(): UserAttributes;
+    setAttribute(key: string, value: unknown): void;
+    decide(key: string, options?: OptimizelyDecideOption[]): OptimizelyDecision;
+    decideForKeys(keys: string[], options?: OptimizelyDecideOption[]): {
+        [key: string]: OptimizelyDecision;
+    };
+    decideAll(options?: OptimizelyDecideOption[]): {
+        [key: string]: OptimizelyDecision;
+    };
+    trackEvent(eventName: string, eventTags?: EventTags): void;
+    setForcedDecision(context: OptimizelyDecisionContext, decision: OptimizelyForcedDecision): boolean;
+    getForcedDecision(context: OptimizelyDecisionContext): OptimizelyForcedDecision | null;
+    removeForcedDecision(context: OptimizelyDecisionContext): boolean;
+    removeAllForcedDecisions(): boolean;
+}
+interface OptimizelyDecision {
+    variationKey: string | null;
+    enabled: boolean;
+    variables: {
+        [variableKey: string]: unknown;
+    };
+    ruleKey: string | null;
+    flagKey: string;
+    userContext: OptimizelyUserContext;
+    reasons: string[];
+}
+interface OptimizelyDecisionContext {
+    flagKey: string;
+    ruleKey?: string;
+}
+interface OptimizelyForcedDecision {
+    variationKey: string;
+}
+
+declare type EventMap = {
+    [eventName: string]: Array<unknown>;
+};
+declare type InternalEventNames = 'newListener' | 'removeListener';
+declare type InternalListener<Events extends EventMap> = Listener<[
+    eventName: keyof Events,
+    listener: Listener<Array<unknown>>
+]>;
+declare type Listener<Data extends Array<unknown>> = (...data: Data) => void;
+/**
+ * Node.js-compatible implementation of `EventEmitter`.
+ *
+ * @example
+ * const emitter = new Emitter<{ hello: [string] }>()
+ * emitter.on('hello', (name) => console.log(name))
+ * emitter.emit('hello', 'John')
+ */
+declare class Emitter<Events extends EventMap> {
+    private events;
+    private maxListeners;
+    private hasWarnedAboutPotentialMemoryLeak;
+    static defaultMaxListeners: number;
+    static listenerCount<Events extends EventMap>(emitter: Emitter<EventMap>, eventName: keyof Events): number;
+    constructor();
+    private _emitInternalEvent;
+    private _getListeners;
+    private _removeListener;
+    private _wrapOnceListener;
+    setMaxListeners(maxListeners: number): this;
+    /**
+     * Returns the current max listener value for the `Emitter` which is
+     * either set by `emitter.setMaxListeners(n)` or defaults to
+     * `Emitter.defaultMaxListeners`.
+     */
+    getMaxListeners(): number;
+    /**
+     * Returns an array listing the events for which the emitter has registered listeners.
+     * The values in the array will be strings or Symbols.
+     */
+    eventNames(): Array<keyof Events>;
+    /**
+     * Synchronously calls each of the listeners registered for the event named `eventName`,
+     * in the order they were registered, passing the supplied arguments to each.
+     * Returns `true` if the event has listeners, `false` otherwise.
+     *
+     * @example
+     * const emitter = new Emitter<{ hello: [string] }>()
+     * emitter.emit('hello', 'John')
+     */
+    emit<EventName extends keyof Events>(eventName: EventName, ...data: Events[EventName]): boolean;
+    addListener(eventName: InternalEventNames, listener: InternalListener<Events>): this;
+    addListener<EventName extends keyof Events>(eventName: EventName, listener: Listener<Events[EventName]>): this;
+    on(eventName: InternalEventNames, listener: InternalListener<Events>): this;
+    on<EventName extends keyof Events>(eventName: EventName, listener: Listener<Events[EventName]>): this;
+    once(eventName: InternalEventNames, listener: InternalListener<Events>): this;
+    once<EventName extends keyof Events>(eventName: EventName, listener: Listener<Events[EventName]>): this;
+    prependListener(eventName: InternalEventNames, listener: InternalListener<Events>): this;
+    prependListener<EventName extends keyof Events>(eventName: EventName, listener: Listener<Events[EventName]>): this;
+    prependOnceListener(eventName: InternalEventNames, listener: InternalListener<Events>): this;
+    prependOnceListener<EventName extends keyof Events>(eventName: EventName, listener: Listener<Events[EventName]>): this;
+    removeListener(eventName: InternalEventNames, listener: InternalListener<Events>): this;
+    removeListener<EventName extends keyof Events>(eventName: EventName, listener: Listener<Events[EventName]>): this;
+    off(eventName: InternalEventNames, listener: InternalListener<Events>): this;
+    off<EventName extends keyof Events>(eventName: EventName, listener: Listener<Events[EventName]>): this;
+    removeAllListeners(eventName?: InternalEventNames): this;
+    removeAllListeners<EventName extends keyof Events>(eventName?: EventName): this;
+    listeners(eventName: InternalEventNames): Array<Listener<any>>;
+    listeners<EventName extends keyof Events>(eventName: EventName): Array<Listener<Events[EventName]>>;
+    listenerCount(eventName: InternalEventNames): number;
+    listenerCount<EventName extends keyof Events>(eventName: EventName): number;
+    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 {
+    ReplayCapture = "replay.capture",
+    SDKReady = "sdk.ready",
+    SurveyAppeared = "survey.appeared",
+    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 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;
+    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: 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"
+}
+interface PassthroughData {
+    questionId: number;
+    surveyId: number;
+    visitorId: string | null;
+    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 enum CardType {
+    ConsentLegal = "consentlegal",
+    Likert = "likert",
+    Matrix = "matrix",
+    MultipleChoice = "multiplechoice",
+    MultipleSelect = "multipleselect",
+    NPS = "nps",
+    Open = "open",
+    RecordedTask = "recordedtask",
+    TextUrlPrompt = "texturlprompt",
+    Thanks = "thanks",
+    Uploading = "uploading",
+    VideoVoice = "videovoice"
+}
+type ConceptUrl = string | null;
+interface BaseCard {
+    name: number;
+    surveyId: number;
+    updatedAt: string;
+    value?: unknown;
+}
+declare const enum Comparator {
+    Answered = "answered",
+    Contains = "contains",
+    DoesNotContain = "notcontains",
+    DoesNotInclude = "list_dni",
+    Equal = "eq",
+    GivenUp = "given_up",
+    GreaterThan = "gt",
+    GreaterThanOrEqual = "gte",
+    LessThan = "lt",
+    LessThanOrEqual = "lte",
+    ListAll = "list_all",
+    ListAtLeastOne = "list_alo",
+    ListExact = "list_exact",
+    NotEqual = "neq",
+    Partial = "partial",
+    Skipped = "skipped"
+}
+type DefaultComparator = Comparator.Answered | Comparator.Skipped;
+type RoutingOption<C extends Comparator = DefaultComparator> = OldRoutingOption<C> | GroupRoutingOption;
+type OldRoutingOption<C extends Comparator = DefaultComparator> = {
+    comparator: C;
+    target: number;
+    /** @example '', 'option_2', ['option_1'] */
+    value: number | string | string[];
+};
+type GroupRoutingOption = {
+    group: (RoutingGroupOption | BooleanOperator)[];
+    target: number;
+};
+type RoutingGroupOption = {
+    comparator: Comparator;
+    questionIndex: number;
+    value: number | string | string[] | {
+        skipped: true;
+    } | null | undefined;
+};
+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"
+}
+interface TextUrlPromptCard extends BaseCard {
+    props: {
+        message: string;
+        options: [];
+        properties: {
+            body: string;
+            buttonText?: string;
+            skipButtonText?: string;
+            buttonUrl?: string;
+            conceptUrl: ConceptUrl;
+            promptActionType: PromptActionType;
+            required: boolean;
+            richTextBody: RichTextBody;
+        };
+        routingOptions: RoutingOptions;
+    };
+    type: CardType.TextUrlPrompt;
+}
+declare const enum AvPermission {
+    Camera = "camera",
+    Microphone = "microphone",
+    Screen = "screen"
+}
+interface ConsentLegalCard extends BaseCard {
+    props: {
+        message: string;
+        options: [];
+        properties: {
+            body: string;
+            captionText: string;
+            collectName: boolean;
+            conceptUrl: ConceptUrl;
+            consentDocument?: {
+                originalFilename: string;
+                url: string;
+            };
+            consentText: string;
+            nameLabelText: string;
+            required: boolean;
+            richTextBody: RichTextBody;
+            skipButtonText: string;
+            submitButtonText: string;
+        };
+        routingOptions: RoutingOptions;
+    };
+    type: CardType.ConsentLegal;
+}
+interface BaseTaskPage {
+    buttonText: string;
+    headline: string;
+}
+declare const enum RecordedTaskPageType {
+    AvPermission = "av_permission",
+    ScreenPermission = "screen_permission",
+    StartTask = "start_task",
+    CompleteTask = "complete_task"
+}
+interface PermissionTaskPage extends BaseTaskPage {
+    captionText: string;
+    headline: string;
+    permissionDeniedBody: string;
+    permissionDeniedHeadline: string;
+    permissionDescriptors: AvPermission[];
+    permissionGrantedCaptionText?: string;
+    permissionGrantedHeadline?: string;
+    skipButtonText?: string;
+    svg: string;
+    tryAgainButtonText: string;
+    type: RecordedTaskPageType.AvPermission;
+}
+interface ScreenTaskPage extends BaseTaskPage {
+    captionText: string;
+    permissionDeniedCaptionText: string;
+    permissionDeniedHeadline: string;
+    selectTabText: string;
+    skipButtonText: string;
+    type: RecordedTaskPageType.ScreenPermission;
+}
+interface StartTaskPage extends BaseTaskPage {
+    captionText?: string;
+    skipButtonText: string;
+    taskDetail: string;
+    type: RecordedTaskPageType.StartTask;
+}
+interface CompleteTaskPage extends BaseTaskPage {
+    captionText?: string;
+    skipButtonText: string;
+    taskDetail: string;
+    type: RecordedTaskPageType.CompleteTask;
+}
+type RecordedTaskPage = PermissionTaskPage | ScreenTaskPage | StartTaskPage | CompleteTaskPage;
+interface RecordedTaskCardProperties {
+    captionText: string;
+    conceptUrl: ConceptUrl;
+    pages: RecordedTaskPage[];
+    permissions: AvPermission[];
+    required: boolean;
+    taskDetail: string;
+}
+interface RecordedTaskCard extends BaseCard {
+    props: {
+        message: string;
+        options: [];
+        properties: RecordedTaskCardProperties;
+        routingOptions: RoutingOptions<Comparator.GivenUp>;
+    };
+    type: CardType.RecordedTask;
+}
+interface Labels {
+    left: string;
+    right: string;
+}
+interface RatingIcon {
+    idx?: number;
+    svg: string;
+}
+declare enum ScaleLabelType {
+    Number = "number",
+    Smiley = "smiley",
+    Star = "star"
+}
+interface LikertCard extends BaseCard {
+    props: {
+        labels: Labels;
+        message: string;
+        options: [];
+        properties: {
+            captionText: string;
+            buttonText?: string;
+            conceptUrl: ConceptUrl;
+            labels: Labels;
+            range: string;
+            ratingIcons: RatingIcon[];
+            scaleLabelType: ScaleLabelType;
+            required: boolean;
+        };
+        routingOptions: RoutingOptions<Comparator.Equal | Comparator.GivenUp | Comparator.GreaterThan | Comparator.GreaterThanOrEqual | Comparator.LessThan | Comparator.LessThanOrEqual | Comparator.NotEqual>;
+    };
+    type: CardType.Likert;
+}
+interface OpenTextCard extends BaseCard {
+    props: {
+        message: string;
+        options: [];
+        properties: {
+            body: string;
+            buttonText?: string;
+            captionText?: string;
+            conceptUrl: ConceptUrl;
+            openTextPlaceholder?: string;
+            required: boolean;
+            richTextBody: RichTextBody;
+            skipButtonText?: string;
+        };
+        routingOptions: RoutingOptions<Comparator.Contains | Comparator.DoesNotContain>;
+    };
+    type: CardType.Open;
+}
+interface MultipleChoiceOption {
+    createdAt: string;
+    deletedAt: null;
+    id: number;
+    label: string;
+    optionProperties: null | {
+        allowsTextEntry: boolean;
+    };
+    order: number;
+    productId: number;
+    surveyId: number;
+    surveyQuestionId: number;
+    updatedAt: string;
+    value: string;
+}
+interface CommonMultipleChoiceProps {
+    message: string;
+    options: MultipleChoiceOption[];
+    properties: {
+        buttonText?: string;
+        captionText: string;
+        conceptUrl: ConceptUrl;
+        randomize: "none" | "keeplast" | "all";
+        required: boolean;
+    };
+}
+interface MultiChoiceCard<C extends Comparator = DefaultComparator> extends BaseCard {
+    props: CommonMultipleChoiceProps & {
+        routingOptions: RoutingOptions<C>;
+    };
+}
+interface MultipleChoiceSingleSelectCard extends MultiChoiceCard<Comparator.Equal | Comparator.NotEqual | Comparator.ListAtLeastOne | Comparator.DoesNotInclude> {
+    type: CardType.MultipleChoice;
+}
+interface MultipleChoiceMultiSelectCard extends MultiChoiceCard<Comparator.ListAll | Comparator.ListAtLeastOne | Comparator.ListExact | Comparator.DoesNotInclude> {
+    type: CardType.MultipleSelect;
+}
+interface MatrixCard extends BaseCard {
+    props: {
+        options: MultipleChoiceOption[];
+        message: string;
+        routingOptions: RoutingOptions<Comparator.Skipped | Comparator.Partial | Comparator.Answered>;
+        properties: {
+            buttonText?: string;
+            captionText: string;
+            conceptUrl: ConceptUrl;
+            matrixColumn: {
+                label: string;
+                value: string;
+            }[];
+            randomize: "none" | "all";
+            required: boolean;
+        };
+    };
+    type: CardType.Matrix;
+}
+interface NPSCard extends BaseCard {
+    props: {
+        labels: {
+            left: string;
+            right: string;
+        };
+        message: string;
+        options: [];
+        properties: {
+            buttonText?: string;
+            captionText: string;
+            conceptUrl: null;
+            labels: {
+                left: string;
+                right: string;
+            };
+            required: boolean;
+        };
+        routingOptions: RoutingOptions<Comparator.Equal | Comparator.GreaterThan | Comparator.GreaterThanOrEqual | Comparator.LessThan | Comparator.LessThanOrEqual | Comparator.NotEqual>;
+    };
+    type: CardType.NPS;
+}
+interface VideoVoiceCard extends BaseCard {
+    props: {
+        message: string;
+        options: [];
+        properties: {
+            buttonText: string;
+            captionText: string;
+            conceptUrl: null;
+            mediaType: "video" | "audio";
+            required: boolean;
+            skipButtonText: string;
+            uploadId: string;
+            videoUrl: string;
+        };
+        routingOptions: RoutingOptions;
+    };
+    type: CardType.VideoVoice;
+}
+type Card = TextUrlPromptCard | ConsentLegalCard | RecordedTaskCard | LikertCard | OpenTextCard | MatrixCard | MultipleChoiceSingleSelectCard | MultipleChoiceMultiSelectCard | NPSCard | VideoVoiceCard;
+
+interface RecordedTaskResponseType {
+    questionId: number;
+    type: CardType;
+    value: RecordedTaskResponseValueType;
+}
+
+interface MobileReplayConfig {
+    maxMobileReplayDurationSeconds?: number;
+    mobileReplaySettings?: {
+        hideAllFormContents: boolean;
+        hidePasswordsOnly: boolean;
+        hideAllImages: boolean;
+    };
+}
+type SprigEventMap = {
+    [InternalEventName.CurrentQuestion]: [
+        {
+            [InternalEventData.QuestionId]: number;
+            [InternalEventData.Props]: unknown;
+        }
+    ];
+    [InternalEventName.RecordedTaskPermissionScreen]: [];
+    [InternalEventName.RecordedTaskStart]: [];
+    [InternalEventName.SurveyComplete]: [];
+    [InternalEventName.VerifyViewVersion]: [
+        {
+            [InternalEventData.ViewVersion]: string;
+        }
+    ];
+    [SprigEvent.CloseSurveyOnOverlayClick]: [];
+    [SprigEvent.SDKReady]: [MobileReplayConfig];
+    [SprigEvent.SurveyAppeared]: [
+        {
+            name: string;
+            [SprigEventData.SurveyId]: number;
+        }
+    ];
+    [SprigEvent.SurveyDimensions]: [
+        {
+            contentFrameHeight: number;
+            contentFrameWidth: number;
+            name: string;
+        }
+    ];
+    [SprigEvent.SurveyClosed]: [
+        {
+            initiator?: string;
+            name: string;
+        }
+    ];
+    [SprigEvent.SurveyFadingOut]: [];
+    [SprigEvent.SurveyHeight]: [
+        {
+            name: string;
+            contentFrameHeight: number;
+        }
+    ];
+    [SprigEvent.SurveyWidth]: [
+        {
+            name: string;
+            contentFrameWidth: number;
+        }
+    ];
+    [SprigEvent.SurveyLifeCycle]: [{
+        state: string;
+    }];
+    [SprigEvent.SurveyPresented]: [
+        {
+            name: string;
+            [SprigEventData.SurveyId]: number;
+        }
+    ];
+    [SprigEvent.SurveyWillClose]: [
+        {
+            initiator: DismissReason;
+            name?: string;
+        }
+    ];
+    [SprigEvent.SurveyWillPresent]: [
+        {
+            name: string;
+            [SprigEventData.SurveyId]: number;
+        }
+    ];
+    [SprigEvent.VisitorIDUpdated]: [{
+        visitorId: string | null;
+    }];
+    [SprigEvent.QuestionAnswered]: [
+        {
+            answeredAt?: number;
+            questionIndex?: number;
+            value: unknown;
+        }
+    ];
+    [SprigEvent.ReplayCapture]: [
+        {
+            responseGroupUid: string;
+            hasQuestions: boolean;
+            uploadId: string;
+            seconds: number;
+            replayType: ReplayDurationType;
+            generateVideoUploadUrlPayload: object;
+            surveyId: number;
+        }
+    ];
+    [SprigRecordingEvent.AvPermission]: [
+        {
+            [SprigRecordingEventData.StreamReadyCallback]: (avStream: MediaStream | null, captureStream?: MediaStream | null) => void;
+            [SprigRecordingEventData.PermissionDescriptors]: AvPermission[];
+        }
+    ];
+    [SprigRecordingEvent.BeginRecording]: [
+        {
+            [SprigRecordingEventData.RecordingMediaTypes]: MediaType[];
+            [SprigRecordingEventData.StartRecordingCallback]: (mediaRecordingUids: UUID[]) => void;
+        }
+    ];
+    [SprigRecordingEvent.FinishTask]: [
+        {
+            [SprigRecordingEventData.BeginCallback]: (mediaRecordingUid: UUID) => void;
+            [SprigRecordingEventData.CurrentIndex]: number;
+            [SprigRecordingEventData.PassthroughData]: PassthroughData;
+            [SprigRecordingEventData.ProgressCallback]: (mediaRecordingUid: UUID, data: {
+                detail: number;
+            }) => void;
+            [SprigRecordingEventData.TaskCompleteCallback]: (taskDurationMillisecond: number) => void;
+            [SprigRecordingEventData.TaskResponse]: RecordedTaskResponseType;
+            [SprigRecordingEventData.UploadCallback]: (mediaRecordingUid: UUID | null, successOrError: true | unknown) => void;
+        }
+    ];
+    [SprigRecordingEvent.PermissionStatus]: [
+        {
+            [SprigRecordingEventData.PermissionStatusCallback]: (avStream: MediaStream | undefined, hasVideoPermission: boolean, hasScreenPermission: boolean, captureStream: MediaStream | undefined) => void;
+        }
+    ];
+    [SprigRecordingEvent.ScreenPermission]: [
+        {
+            [SprigRecordingEventData.ScreenPermissionRequested]?: (data: boolean) => void;
+            [SprigRecordingEventData.StreamReadyCallback]: (avStream: MediaStream | null, captureStream: MediaStream | null) => void;
+        }
+    ];
+    [SprigRecordingEvent.StartTask]: [];
+};
+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"
+}
+interface Answer {
+    questionId: number;
+    value: unknown;
+}
+interface Config extends MobileReplayConfig {
+    allResponses: unknown[];
+    answers?: Answer[];
+    apiURL: string;
+    /** @example "#000000" */
+    border: string;
+    cards: Card[];
+    configureExitOnOverlayClick: (cb: () => void) => void;
+    context: {
+        outcome: string;
+        product: {
+            name: string;
+        };
+        visitor: {
+            outcome: string;
+        };
+    };
+    customMetadata?: Record<string, unknown>;
+    customStyles: string;
+    dismissOnPageChange: boolean;
+    forceBrandedLogo?: boolean;
+    endCard?: {
+        headline: string;
+        subheader?: string;
+    };
+    /** @example "SJcVfq-7QQ" */
+    envId: string;
+    environmentId?: string;
+    exitOnOverlayClick?: boolean;
+    exitOnOverlayClickMobile?: boolean;
+    eventEmitFn: SprigEventEmitter["emit"];
+    fontFamily?: string;
+    fontFamilyURL: undefined;
+    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;
+        /** @example "SJcVfq-7QQ" */
+        [HttpHeader.EnvironmentID]?: string;
+        [HttpHeader.InstallationMethod]: InstallationMethod;
+        [HttpHeader.PartnerAnonymousId]?: string;
+        [HttpHeader.PreviewMode]?: string;
+        /** @example "2.18.0" */
+        "x-ul-sdk-version": string;
+        /** For web-bundled sdk */
+        "x-ul-bundled-sdk-version"?: string;
+        [HttpHeader.UserID]?: string;
+        [HttpHeader.VisitorID]?: UUID;
+    };
+    installationMethod?: InstallationMethod;
+    interactiveEvents: InteractiveEvent[];
+    interactiveEventsHandler?: (e: MouseEvent) => void;
+    isPreview?: boolean;
+    launchDarklyEnabled?: boolean;
+    locale: string;
+    marketingUrl?: string;
+    maxAttrNameLength: number;
+    maxAttrValueLength: number;
+    maxEmailLength: number;
+    maxEventLength: number;
+    maxReplayDurationSeconds?: number;
+    maxUserIdLength: number;
+    mobileSDKVersion: undefined;
+    mode?: string;
+    mute?: boolean;
+    optimizelyEnabled?: boolean;
+    overlayStyle: "light";
+    overlayStyleMobile: "none";
+    pageUrlEvents: PageUrlEvent[];
+    path?: string;
+    platform?: Platform;
+    previewKey?: string | null;
+    previewLanguage?: string;
+    replayNonce?: string;
+    replaySettings?: object;
+    requireUserIdForTracking: boolean;
+    responseGroupUid: UUID;
+    showStripes: boolean;
+    showSurveyBrand: boolean;
+    slugName: null;
+    startingQuestionIdx?: number | null;
+    styleNonce?: string;
+    surveyId: number;
+    tabTitle: string;
+    ulEvents: typeof SprigEvent;
+    UpChunk: Window["UpChunk"];
+    useDesktopPrototype?: boolean;
+    useMobileStyling: boolean;
+    userId: UUID | null;
+    visitorId: UUID | null;
+    viewDocument: Document;
+    viewWindow: Window;
+    visitorAttributes: {
+        email?: string;
+        externalUserId?: string;
+    };
+}
+
+declare enum ReplayDurationType {
+    After = "after",
+    Before = "before",
+    BeforeAndAfter = "beforeAndAfter"
+}
+declare enum ReplayEventType {
+    Click = "Sprig_Click",
+    Event = "Sprig_TrackEvent",
+    PageView = "Sprig_PageView",
+    SurveyShown = "Sprig_ShowSurvey",
+    SurveySubmitted = "Sprig_SubmitSurvey",
+    Noop = "Sprig_Noop"
+}
+type EventDigest = {
+    timestamp: number;
+    type: ReplayEventType.Click;
+} | {
+    timestamp: number;
+    name: string;
+    type: ReplayEventType.Event;
+} | {
+    timestamp: number;
+    type: ReplayEventType.PageView;
+    url: string;
+} | {
+    timestamp: number;
+    surveyId: string;
+    type: ReplayEventType.SurveyShown;
+} | {
+    timestamp: number;
+    surveyId: string;
+    type: ReplayEventType.SurveySubmitted;
+};
+
+declare namespace optimizely {
+  interface Optimizely {
+    get?: (key: "state") => {
+      getExperimentStates: (options: {
+        filter?: unknown;
+        isActive?: boolean;
+      }) => Record<string, OptimizelyExperimentState>;
+    };
+  }
+
+  // Ref: https://docs.developers.optimizely.com/web/docs/state#return-value-2
+  interface OptimizelyExperimentState {
+    /** Audiences the visitor was in when the experiment was activated.
+     * @example { "id": "6672770135", "name": "Chrome users" }
+     */
+    audiences: { id: number; name: string }[];
+    /** The name of the experiment
+     * @example OptimizelyExperimentState
+     * */
+    experimentName: string;
+    /** The ID of the experiment
+     * @example OptimizelyExperimentState
+     * */
+    id: string;
+    /** Indicates if the experiment is currently active */
+    isActive: boolean;
+    /** Indicates if the visitor is in the holdback (i.e., is excluded due traffic allocation) */
+    isInExperimentHoldback: boolean;
+    /** The name of the object. Required */
+    name: string;
+    /** An object with the name and the ID of the variation the visitor is bucketed in, or null if the visitor was not bucketed
+     * @example { "id": "6626731852", "name": "Variation #1" }
+     */
+    variation: { id: number; name: string } | null;
+    /** Indicates if the visitor was redirected due to this experiment */
+    visitorRedirected: boolean;
+  }
+}
+
+declare namespace sprigConfig {
+  type IdentifyResult = Promise<
+    | {
+        success: boolean;
+        message?: string;
+        surveyState?: SurveyState;
+        surveyId?: number;
+        responseGroupUid?: string;
+      }
+    | undefined
+  >;
+
+  interface TrackPayload {
+    anonymousId?: string;
+    metadata?: SprigMetadata;
+    eventName?: string;
+    properties?: SprigProperties;
+    userId?: string;
+    showSurveyCallback?: (surveyId?: number) => Promise<boolean>;
+  }
+
+  interface SprigAPIActions {
+    // internal apis
+    _completeSessionReplay: (payload: {
+      surveyId: number;
+      responseGroupUuid: string;
+      eventDigest?: EventDigest[];
+    }) => Promise<void>;
+    _generateVideoUploadUrl: (body: {
+      mediaRecordingUid?: string;
+      mediaType?: MediaType;
+      questionId?: number;
+      responseGroupUid?: string;
+      surveyId?: number;
+      updatedAt?: string;
+      visitorId?: string | null;
+      isReplay?: boolean;
+    }) => Promise<string | null>;
+    _previewSurvey: (surveyTemplateId: UUID) => void;
+    _reviewSurvey: (surveyId: number) => void;
+
+    // external apis
+    addListener: (event: SprigEvent, listener: SprigListener) => Promise<void>;
+    addSurveyListener: (listener: SprigListener) => Promise<void>;
+    applyStyles: (styleString: string) => void;
+    dismissActiveSurvey: (reason?: DismissReason) => void;
+    displaySurvey: (surveyId: number) => IdentifyResult;
+    identifyAndSetAttributes: (payload: {
+      anonymousId?: string;
+      attributes?: SprigAttributes;
+      userId?: string;
+    }) => IdentifyResult;
+    identifyAndTrack: (payload: TrackPayload) => IdentifyResult;
+    importLaunchDarklyData: (data: Record<string, number | undefined>) => void;
+    integrateOptimizely: (
+      strData: string | { experiments: Experiment[] },
+      isOverride?: boolean
+    ) => void;
+    integrateOptimizelyClient: (client: Client) => void;
+    logoutUser: () => void;
+    mute: () => void;
+    previewSurvey: (surveyTemplateId: UUID) => void;
+    removeAllListeners: () => Promise<void>;
+    removeAttributes: (attributes: SprigAttributes) => IdentifyResult;
+    removeListener: (
+      event: SprigEvent,
+      listener: SprigListener
+    ) => Promise<void>;
+    removeSurveyListener: (listener: SprigListener) => Promise<void>;
+    reviewSurvey: (surveyId: number) => void;
+    setAttribute: (attribute: string, value: string | number) => IdentifyResult;
+    setAttributes: (attributes?: SprigAttributes) => IdentifyResult;
+    setPartnerAnonymousId: (
+      partnerAnonymousId: string
+    ) => Promise<{ success: boolean; message?: string }>;
+    setVisitorAttribute: (
+      attribute: string,
+      value: string | number
+    ) => IdentifyResult;
+    setWindowDimensions: (
+      width: number | string,
+      height: number | string
+    ) => void;
+    setEmail: (email: string) => IdentifyResult;
+    setPreviewKey: (previewKey: string) => void;
+    setUserId: (userId: string) => IdentifyResult;
+    setVisitorEmail: (email: string) => IdentifyResult;
+    setVisitorToken: () => void;
+    teardown: () => void;
+    track: (
+      eventName: string,
+      properties?: TrackPayload["properties"],
+      metadata?: SprigMetadata,
+      showSurveyCallback?: (surveyId?: number) => Promise<boolean>
+    ) => IdentifyResult;
+    trackPageView: (
+      url: string,
+      properties?: SprigProperties,
+      showSurveyCallback?: (surveyId?: number) => Promise<boolean>
+    ) => void;
+    unmute: () => void;
+  }
+
+  type SprigCommand = keyof SprigAPIActions;
+  type SprigCommands = <C extends SprigCommand>(
+    command: C,
+    ...params: Parameters<SprigAPIActions[C]>
+  ) => ReturnType<SprigAPIActions[C]>;
+
+  type WindowSprig = Config &
+    SprigAPIActions &
+    SprigCommands & {
+      _API_URL: string;
+      _config: Config;
+      _gtm: unknown; // TODO: determine if boolean?
+      _queue: SprigQueue;
+      _segment: unknown; // TODO: determine if boolean?
+      appId: string;
+      container?: HTMLElement | null;
+      config: Config;
+      debugMode?: boolean;
+      delayingSurvey: boolean;
+      email?: string | null;
+      envId: string;
+      error?: Error;
+      frameId: string;
+      loaded: boolean;
+      locale?: string;
+      maxHeight?: number | string;
+      maxInflightReplayRequests?: number;
+      mobileHeadersJSON?: string;
+      nonce?: string;
+      partnerAnonymousId: string | null;
+      replayNonce?: string;
+      reportError: (name: string, err: Error, extraInfo?: object) => void;
+      sampleRate?: number;
+      token: string | null;
+      UPDATES: typeof EVENTS;
+      viewSDKURL?: string;
+      windowDimensions?: {
+        height: number;
+        width: number;
+      };
+    };
+}
+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;
+    Intercom: { ul_wasVisible?: boolean } & ((
+      method: string,
+      data: unknown
+    ) => void);
+    optimizely?: optimizely.Optimizely;
+    optimizelyDatafile?: object;
+    previewMode?: unknown;
+    UpChunk: {
+      createUpload: (
+        ...args: ArgumentTypes<createUpload>
+      ) => PublicOf<ReturnType<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;
+  }
+
+  type WindowSprig = sprigConfig.WindowSprig;
+  type SprigAttributes = Record<string, boolean | number | string>;
+  type SprigListener = Listener<unknown[]>;
+  type SprigMetadata = Record<string, unknown>;
+  type SprigProperties = Record<string, unknown>;
+  type SprigAPIActions = sprigConfig.SprigAPIActions;
+  type TrackPayload = sprigConfig.TrackPayload;
+
+  // common types
+  /** @example "123e4567-e89b-12d3-a456-426614174000" */
+  type UUID = string;
+}
+
+declare class SprigAPI {
+    /**
+     * Include external events emitted from Sprig
+     */
+    UPDATES: {
+        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;
+        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: SprigEventData;
+        };
+    };
+    /**
+     * Triggers displaying specified survey. Does submit answers!
+     */
+    displaySurvey(surveyId: number): void;
+    /**
+     * Pauses api interactions
+     */
+    mute(): void;
+    /**
+     * Restart api interactions
+     */
+    unmute(): void;
+    /**
+     * Manually dismiss an opened survey
+     */
+    dismissActiveSurvey(): void;
+    /**
+     * Set an arbitrary attribute on the visitor
+     */
+    setAttribute(attribute: string, value: string): void;
+    /**
+     * Set attributes on visitor
+     */
+    setAttributes(attributes: SprigAttributes): void;
+    /**
+     * Set identifiers and attributes on visitor
+     */
+    identifyAndSetAttributes(payload: {
+        anonymousID?: string;
+        attributes: SprigAttributes;
+        userID?: string;
+    }): void;
+    /**
+     * Remove attributes on visitor
+     */
+    removeAttributes(attributes: SprigAttributes): void;
+    /**
+     * Add a listener for an event defined in ulEvents
+     */
+    addListener(event: SprigEvent, listener: SprigListener): void;
+    /**
+     * Remove a listener for an event defined in ulEvents
+     */
+    removeListener(event: SprigEvent, listener: SprigListener): void;
+    /**
+     * Remove all listeners set on Sprig
+     */
+    removeAllListeners(): void;
+    /**
+     * Attach an email address to visitor
+     */
+    setEmail(email: string): void;
+    /**
+     * Attach a user id to the visitor
+     */
+    setUserId(userId: string): void;
+    /**
+     * Set a partner anonymous id for future requests.
+     */
+    setPartnerAnonymousId(partnerAnonymousId: string): void;
+    /**
+     * Track an event to show survey if eligible
+     * @param eventName name of event to track
+     */
+    track(eventName: string, properties?: Record<string, unknown>, metadata?: SprigMetadata): void;
+    /**
+     * Optionally set userId and/or anonymousId, track an event to show survey if eligible
+     */
+    identifyAndTrack(payload: {
+        anonymousId?: string;
+        eventName: string;
+        metadata?: SprigMetadata;
+        userId?: string;
+    }): void;
+    /**
+     * Tracks a page view with the provided URL and additional event properties.
+     */
+    trackPageView(url: string, props?: SprigProperties, showSurveyCallback?: (surveyId?: number) => Promise<boolean>): void;
+    /**
+     * Apply a css string representing the customized styles
+     */
+    applyStyles(styleString: string): void;
+    /**
+      Set viewport dimensions, in int pixels. necessary if Sprig is installed in an iframe/component defaulting to 0 width and height.
+    */
+    setWindowDimensions(width: number | string, height: number | string): void;
+    /**
+     * Logs out current visitor and associated ids
+     */
+    logoutUser(): void;
+    /**
+     * Clears Sprig from window
+     */
+    teardown(): void;
+}
+type NpmConfig = {
+    envId?: string;
+    environmentId?: string;
+    path?: string;
+} & Partial<WindowSprig$1>;
+declare const sprig: {
+    /**
+     * Sets up the sprig api and load the sprig sdk on document load
+     * @param config
+     * @returns an instance of the sprig api
+     */
+    configure: (config: NpmConfig) => sprigConfig.WindowSprig;
+};
+type WindowSprig$1 = typeof window.Sprig;
+
+export { DismissReason, SprigAPI, SprigEvent, WindowSprig$1 as WindowSprig, sprig };