declare type attributes = {
    [key: string]: string | number | true | null;
};

declare type cdataNode = {
    type: NodeType.CDATA;
    textContent: '';
};

declare type commentNode = {
    type: NodeType.Comment;
    textContent: string;
};

declare type DataURLOptions = Partial<{
    type: string;
    quality: number;
}>;

declare type documentNode = {
    type: NodeType.Document;
    childNodes: serializedNodeWithId[];
    compatMode?: string;
};

declare type documentTypeNode = {
    type: NodeType.DocumentType;
    name: string;
    publicId: string;
    systemId: string;
};

declare type elementNode = {
    type: NodeType.Element;
    tagName: string;
    attributes: attributes;
    childNodes: serializedNodeWithId[];
    isSVG?: true;
    needBlock?: boolean;
    isCustom?: true;
};

declare interface IMirror<TNode> {
    getId(n: TNode | undefined | null): number;
    getNode(id: number): TNode | null;
    getIds(): number[];
    getMeta(n: TNode): serializedNodeWithId | null;
    removeNodeFromMap(n: TNode): void;
    has(id: number): boolean;
    hasNode(node: TNode): boolean;
    add(n: TNode, meta: serializedNodeWithId): void;
    replace(id: number, n: TNode): void;
    reset(): void;
}

declare type MaskInputFn = (text: string, element: HTMLElement) => string;

declare type MaskInputOptions = Partial<{
    color: boolean;
    date: boolean;
    'datetime-local': boolean;
    email: boolean;
    month: boolean;
    number: boolean;
    range: boolean;
    search: boolean;
    tel: boolean;
    text: boolean;
    time: boolean;
    url: boolean;
    week: boolean;
    textarea: boolean;
    select: boolean;
    password: boolean;
}>;

declare type MaskTextFn = (text: string, element: HTMLElement | null) => string;

declare class Mirror implements IMirror<Node> {
    private idNodeMap;
    private nodeMetaMap;
    getId(n: Node | undefined | null): number;
    getNode(id: number): Node | null;
    getIds(): number[];
    getMeta(n: Node): serializedNodeWithId | null;
    removeNodeFromMap(n: Node): void;
    has(id: number): boolean;
    hasNode(node: Node): boolean;
    add(n: Node, meta: serializedNodeWithId): void;
    replace(id: number, n: Node): void;
    reset(): void;
}

declare enum NodeType {
    Document = 0,
    DocumentType = 1,
    Element = 2,
    Text = 3,
    CDATA = 4,
    Comment = 5
}

declare type serializedNode = (documentNode | documentTypeNode | elementNode | textNode | cdataNode | commentNode) & {
    rootId?: number;
    isShadowHost?: boolean;
    isShadow?: boolean;
};

declare type serializedNodeWithId = serializedNode & {
    id: number;
};

declare type SlimDOMOptions = Partial<{
    script: boolean;
    comment: boolean;
    headFavicon: boolean;
    headWhitespace: boolean;
    headMetaDescKeywords: boolean;
    headMetaSocial: boolean;
    headMetaRobots: boolean;
    headMetaHttpEquiv: boolean;
    headMetaAuthorship: boolean;
    headMetaVerification: boolean;
    headTitleMutations: boolean;
}>;

declare type textNode = {
    type: NodeType.Text;
    textContent: string;
    isStyle?: true;
};

declare type addedNodeMutation = {
    parentId: number;
    previousId?: number | null;
    nextId: number | null;
    node: serializedNodeWithId;
};

declare type adoptedStyleSheetData = {
    source: IncrementalSource.AdoptedStyleSheet;
} & adoptedStyleSheetParam;

declare type adoptedStyleSheetParam = {
    id: number;
    styles?: {
        styleId: number;
        rules: styleSheetAddRule[];
    }[];
    styleIds: number[];
};

declare type attributeMutation = {
    id: number;
    attributes: {
        [key: string]: string | styleOMValue | null;
    };
};

declare type blockClass = string | RegExp;

declare enum CanvasContext {
    '2D' = 0,
    WebGL = 1,
    WebGL2 = 2
}

declare type canvasMutationCallback = (p: canvasMutationParam) => void;

declare type canvasMutationCommand = {
    property: string;
    args: Array<unknown>;
    setter?: true;
};

declare type canvasMutationData = {
    source: IncrementalSource.CanvasMutation;
} & canvasMutationParam;

declare type canvasMutationParam = {
    id: number;
    type: CanvasContext;
    commands: canvasMutationCommand[];
} | ({
    id: number;
    type: CanvasContext;
} & canvasMutationCommand);

declare type customElementCallback = (c: customElementParam) => void;

declare type customElementData = {
    source: IncrementalSource.CustomElement;
} & customElementParam;

declare type customElementParam = {
    define?: {
        name: string;
    };
};

declare type customEvent<T = unknown> = {
    type: EventType.Custom;
    data: {
        tag: string;
        payload: T;
    };
};

declare type domContentLoadedEvent = {
    type: EventType.DomContentLoaded;
    data: unknown;
};

declare enum EventType {
    DomContentLoaded = 0,
    Load = 1,
    FullSnapshot = 2,
    IncrementalSnapshot = 3,
    Meta = 4,
    Custom = 5,
    Plugin = 6
}

declare type eventWithoutTime = domContentLoadedEvent | loadedEvent | fullSnapshotEvent | incrementalSnapshotEvent | metaEvent | customEvent | pluginEvent;

declare type eventWithTime = eventWithoutTime & {
    timestamp: number;
    delay?: number;
};

declare type fontCallback = (p: fontParam) => void;

declare type fontData = {
    source: IncrementalSource.Font;
} & fontParam;

declare type fontParam = {
    family: string;
    fontSource: string;
    buffer: boolean;
    descriptors?: FontFaceDescriptors;
};

declare type fullSnapshotEvent = {
    type: EventType.FullSnapshot;
    data: {
        node: serializedNodeWithId;
        initialOffset: {
            top: number;
            left: number;
        };
    };
};

declare type hooksParam = {
    mutation?: mutationCallBack;
    mousemove?: mousemoveCallBack;
    mouseInteraction?: mouseInteractionCallBack;
    scroll?: scrollCallback;
    viewportResize?: viewportResizeCallback;
    input?: inputCallback;
    mediaInteaction?: mediaInteractionCallback;
    styleSheetRule?: styleSheetRuleCallback;
    styleDeclaration?: styleDeclarationCallback;
    canvasMutation?: canvasMutationCallback;
    font?: fontCallback;
    selection?: selectionCallback;
    customElement?: customElementCallback;
};

declare interface ICrossOriginIframeMirror {
    getId(iframe: HTMLIFrameElement, remoteId: number, parentToRemoteMap?: Map<number, number>, remoteToParentMap?: Map<number, number>): number;
    getIds(iframe: HTMLIFrameElement, remoteId: number[]): number[];
    getRemoteId(iframe: HTMLIFrameElement, parentId: number, map?: Map<number, number>): number;
    getRemoteIds(iframe: HTMLIFrameElement, parentId: number[]): number[];
    reset(iframe?: HTMLIFrameElement): void;
}

declare type incrementalData = mutationData | mousemoveData | mouseInteractionData | scrollData | viewportResizeData | inputData | mediaInteractionData | styleSheetRuleData | canvasMutationData | fontData | selectionData | styleDeclarationData | adoptedStyleSheetData | customElementData;

declare type incrementalSnapshotEvent = {
    type: EventType.IncrementalSnapshot;
    data: incrementalData;
};

declare enum IncrementalSource {
    Mutation = 0,
    MouseMove = 1,
    MouseInteraction = 2,
    Scroll = 3,
    ViewportResize = 4,
    Input = 5,
    TouchMove = 6,
    MediaInteraction = 7,
    StyleSheetRule = 8,
    CanvasMutation = 9,
    Font = 10,
    Log = 11,
    Drag = 12,
    StyleDeclaration = 13,
    Selection = 14,
    AdoptedStyleSheet = 15,
    CustomElement = 16
}

declare type inputCallback = (v: inputValue & {
    id: number;
}) => void;

declare type inputData = {
    source: IncrementalSource.Input;
    id: number;
} & inputValue;

declare type inputValue = {
    text: string;
    isChecked: boolean;
    userTriggered?: boolean;
};

declare type IWindow = Window & typeof globalThis;

declare type KeepIframeSrcFn = (src: string) => boolean;

declare type listenerHandler = () => void;

declare type loadedEvent = {
    type: EventType.Load;
    data: unknown;
};

declare type maskTextClass = string | RegExp;

declare type mediaInteractionCallback = (p: mediaInteractionParam) => void;

declare type mediaInteractionData = {
    source: IncrementalSource.MediaInteraction;
} & mediaInteractionParam;

declare type mediaInteractionParam = {
    type: MediaInteractions;
    id: number;
    currentTime?: number;
    volume?: number;
    muted?: boolean;
    loop?: boolean;
    playbackRate?: number;
};

declare enum MediaInteractions {
    Play = 0,
    Pause = 1,
    Seeked = 2,
    VolumeChange = 3,
    RateChange = 4
}

declare type metaEvent = {
    type: EventType.Meta;
    data: {
        href: string;
        width: number;
        height: number;
    };
};

declare type mouseInteractionCallBack = (d: mouseInteractionParam) => void;

declare type mouseInteractionData = {
    source: IncrementalSource.MouseInteraction;
} & mouseInteractionParam;

declare type mouseInteractionParam = {
    type: MouseInteractions;
    id: number;
    x?: number;
    y?: number;
    pointerType?: PointerTypes;
};

declare enum MouseInteractions {
    MouseUp = 0,
    MouseDown = 1,
    Click = 2,
    ContextMenu = 3,
    DblClick = 4,
    Focus = 5,
    Blur = 6,
    TouchStart = 7,
    TouchMove_Departed = 8,
    TouchEnd = 9,
    TouchCancel = 10
}

declare type mousemoveCallBack = (p: mousePosition[], source: IncrementalSource.MouseMove | IncrementalSource.TouchMove | IncrementalSource.Drag) => void;

declare type mousemoveData = {
    source: IncrementalSource.MouseMove | IncrementalSource.TouchMove | IncrementalSource.Drag;
    positions: mousePosition[];
};

declare type mousePosition = {
    x: number;
    y: number;
    id: number;
    timeOffset: number;
};

declare type mutationCallBack = (m: mutationCallbackParam) => void;

declare type mutationCallbackParam = {
    texts: textMutation[];
    attributes: attributeMutation[];
    removes: removedNodeMutation[];
    adds: addedNodeMutation[];
    isAttachIframe?: true;
};

declare type mutationData = {
    source: IncrementalSource.Mutation;
} & mutationCallbackParam;

declare type PackFn = (event: eventWithTime) => string;

declare type pluginEvent<T = unknown> = {
    type: EventType.Plugin;
    data: {
        plugin: string;
        payload: T;
    };
};

declare enum PointerTypes {
    Mouse = 0,
    Pen = 1,
    Touch = 2
}

declare type RecordPlugin<TOptions = unknown> = {
    name: string;
    observer?: (cb: (...args: Array<unknown>) => void, win: IWindow, options: TOptions) => listenerHandler;
    eventProcessor?: <TExtend>(event: eventWithTime) => eventWithTime & TExtend;
    getMirror?: (mirrors: {
        nodeMirror: Mirror;
        crossOriginIframeMirror: ICrossOriginIframeMirror;
        crossOriginIframeStyleMirror: ICrossOriginIframeMirror;
    }) => void;
    options: TOptions;
};

declare type removedNodeMutation = {
    parentId: number;
    id: number;
    isShadow?: boolean;
};

declare type SamplingStrategy = Partial<{
    mousemove: boolean | number;
    mousemoveCallback: number;
    mouseInteraction: boolean | Record<string, boolean | undefined>;
    scroll: number;
    media: number;
    input: 'all' | 'last';
    canvas: 'all' | number;
}>;

declare type scrollCallback = (p: scrollPosition) => void;

declare type scrollData = {
    source: IncrementalSource.Scroll;
} & scrollPosition;

declare type scrollPosition = {
    id: number;
    x: number;
    y: number;
};

declare type selectionCallback = (p: selectionParam) => void;

declare type selectionData = {
    source: IncrementalSource.Selection;
} & selectionParam;

declare type selectionParam = {
    ranges: Array<SelectionRange>;
};

declare type SelectionRange = {
    start: number;
    startOffset: number;
    end: number;
    endOffset: number;
};

declare type styleDeclarationCallback = (s: styleDeclarationParam) => void;

declare type styleDeclarationData = {
    source: IncrementalSource.StyleDeclaration;
} & styleDeclarationParam;

declare type styleDeclarationParam = {
    id?: number;
    styleId?: number;
    index: number[];
    set?: {
        property: string;
        value: string | null;
        priority: string | undefined;
    };
    remove?: {
        property: string;
    };
};

declare type styleOMValue = {
    [key: string]: styleValueWithPriority | string | false;
};

declare type styleSheetAddRule = {
    rule: string;
    index?: number | number[];
};

declare type styleSheetDeleteRule = {
    index: number | number[];
};

declare type styleSheetRuleCallback = (s: styleSheetRuleParam) => void;

declare type styleSheetRuleData = {
    source: IncrementalSource.StyleSheetRule;
} & styleSheetRuleParam;

declare type styleSheetRuleParam = {
    id?: number;
    styleId?: number;
    removes?: styleSheetDeleteRule[];
    adds?: styleSheetAddRule[];
    replace?: string;
    replaceSync?: string;
};

declare type styleValueWithPriority = [string, string];

declare type textMutation = {
    id: number;
    value: string | null;
};

declare type viewportResizeCallback = (d: viewportResizeDimension) => void;

declare type viewportResizeData = {
    source: IncrementalSource.ViewportResize;
} & viewportResizeDimension;

declare type viewportResizeDimension = {
    width: number;
    height: number;
};



declare global {
    interface Window {
        FontFace: typeof FontFace;
    }
}

declare type ErrorHandler = (error: unknown) => void | boolean;


declare type recordOptions<T> = {
    emit?: (e: T, isCheckout?: boolean) => void;
    checkoutEveryNth?: number;
    checkoutEveryNms?: number;
    blockClass?: blockClass;
    blockSelector?: string;
    ignoreClass?: string;
    ignoreSelector?: string;
    maskTextClass?: maskTextClass;
    maskTextSelector?: string;
    maskAllInputs?: boolean;
    maskInputOptions?: MaskInputOptions;
    maskInputFn?: MaskInputFn;
    maskTextFn?: MaskTextFn;
    slimDOMOptions?: SlimDOMOptions | 'all' | true;
    ignoreCSSAttributes?: Set<string>;
    inlineStylesheet?: boolean;
    hooks?: hooksParam;
    packFn?: PackFn;
    sampling?: SamplingStrategy;
    dataURLOptions?: DataURLOptions;
    recordDOM?: boolean;
    recordCanvas?: boolean;
    recordCrossOriginIframes?: boolean;
    recordAfter?: 'DOMContentLoaded' | 'load';
    userTriggeredOnInput?: boolean;
    collectFonts?: boolean;
    inlineImages?: boolean;
    plugins?: RecordPlugin[];
    mousemoveWait?: number;
    keepIframeSrcFn?: KeepIframeSrcFn;
    errorHandler?: ErrorHandler;
};

declare function record<T = eventWithTime>(options?: recordOptions<T>): listenerHandler | undefined;

declare namespace record {
    var addCustomEvent: <T>(tag: string, payload: T) => void;
    var freezePage: () => void;
    var takeFullSnapshot: (isCheckout?: boolean | undefined) => void;
    var mirror: Mirror;
}


declare namespace record {
    var addCustomEvent: <T>(tag: string, payload: T) => void;
    var freezePage: () => void;
    var takeFullSnapshot: (isCheckout?: boolean | undefined) => void;
    var mirror: Mirror;
}


declare global {
    interface Window {
        FontFace: typeof FontFace;
        Array: typeof Array;
    }
}

declare const _rrweb_record_record: typeof record;
declare namespace _rrweb_record {
  export { _rrweb_record_record as record };
}

interface XhrResponse {
  body: Object | string;
  statusCode: number;
  method: string;
  headers: XhrHeaders;
  url: string;
  rawRequest: XMLHttpRequest;
}

interface XhrHeaders {
  [key: string]: string;
}

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: typeof UpChunk.createUpload;

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

type MediaType = "video" | "audio" | "screen";
type TaskStatus = "abandoned" | "given.up" | "completed";
interface PassthroughData {
    questionId: number;
    surveyId: number;
    visitorId: string | null;
    responseGroupUid: UUID;
}

type MultiChoiceSecondaryValueType = Record<string, {
    userText: string;
}> | null;
declare const enum MaxDiffChoice {
    RIGHT = "right",
    LEFT = "left"
}
type MaxDiffValueType = {
    id: number;
    option: string;
    selected: MaxDiffChoice | null;
};
type MaxDiffResponseType = Array<Array<MaxDiffValueType>>;
type ConjointConceptValue = {
    levels: {
        featureId: number;
        levelId: number;
    }[];
    selected: boolean;
} | {
    none: true;
    selected: boolean;
};
type ConjointTaskResponseType = ConjointConceptValue[];
type ConjointResponseType = ConjointTaskResponseType[];
interface RecordedTaskResponseValueType {
    mediaRecordingUids?: string[] | null;
    taskDurationMillisecond?: number;
    taskStatus: TaskStatus;
}
type TextUrlPromptResponse = undefined | {
    skipped?: true;
};
type ConsentLegalResponse = {
    submitted: true;
} | null;
type RecordedTaskResponse = {
    mediaRecordingUids: string[];
    taskDurationMillisecond: number;
    taskStatus: TaskStatus;
};
type LikertResponse = number | null;
type OpenTextResponse = string;
type AiDynamicFollowUpResponse = string;
type MultiChoiceResponse = string | undefined;
type MultiSelectResponse = string[];
type MatrixResponse = {
    [rowId: number]: string | null;
};
type NpsResponse = number | null;
type RankOrderResponse = {
    [optionId: string]: number | null;
};
type VideoVoiceResponse = {
    mediaRecordingUid: string;
};
type CardResponse = TextUrlPromptResponse | ConsentLegalResponse | RecordedTaskResponse | LikertResponse | OpenTextResponse | AiDynamicFollowUpResponse | MultiChoiceResponse | MultiSelectResponse | MatrixResponse | NpsResponse | RankOrderResponse | MaxDiffResponseType | ConjointResponseType | VideoVoiceResponse;

declare const BOOLEAN_OPERATOR: {
    readonly And: 1;
    readonly Or: 2;
};
type BooleanOperator = (typeof BOOLEAN_OPERATOR)[keyof typeof BOOLEAN_OPERATOR];

type CardType = "aidynamicfollowup" | "aidynamicstandalone" | "consentlegal" | "likert" | "matrix" | "maxdiff" | "conjoint" | "multiplechoice" | "multipleselect" | "nps" | "open" | "rankorder" | "recordedtask" | "texturlprompt" | "thanks" | "uploading" | "videovoice";
type ConceptUrl = string | null;
type GroupType = "page";
interface BaseCard {
    name: number;
    surveyId: number;
    updatedAt: string;
    value?: unknown;
    type: CardType;
    groupId?: number | null;
    secondaryValue?: MultiChoiceSecondaryValueType | null;
    groupType?: GroupType;
    childId?: number | null;
    parentId?: number | null;
}
type Comparator = "answered" | "contains" | "notcontains" | "list_dni" | "eq" | "given_up" | "gt" | "gte" | "lt" | "lte" | "list_all" | "list_alo" | "list_exact" | "neq" | "partial" | "skipped";
type Randomize = "none" | "all";
type DefaultComparator = Extract<Comparator, "answered" | "skipped">;
type RoutingOption<C extends Comparator = DefaultComparator> = OldRoutingOption<C> | GroupRoutingOption;
type OldRoutingOption<C extends Comparator = DefaultComparator> = {
    comparator: C;
    target: number;
    /** @example '', 'option_2', ['option_1'] */
    value: number | string | string[];
};
/**
 * One element in array-shaped routing `value` payloads (e.g. `list_alo`, `list_exact`),
 * where the wire may include placeholders.
 */
type RoutingListValueEntry = string | undefined | null;
/** Values compared in routing / display rules */
type RoutingValue = number | string | RoutingListValueEntry[];
type RoutingGroupOption = {
    comparator: Comparator;
    displayLabel?: string;
    /** Omitted on malformed or discovery-only payloads; evaluator treats missing as non-matching. */
    questionIndex?: number | string;
    value: RoutingValue | {
        skipped: true;
    } | null | undefined;
};
/**
 * One slot in a complex `group`: a condition, AND/OR (1 | 2 on the wire), or a nested sub-expression.
 * Nested arrays evaluate recursively and become a single boolean operand in the parent list.
 */
type RoutingGroupSegment = RoutingGroupOption | BooleanOperator | RoutingGroupSegment[];
type GroupRoutingOption = {
    group: RoutingGroupSegment[];
    target: number;
};
type RoutingOptions<C extends Comparator = DefaultComparator> = RoutingOption<C | DefaultComparator>[] | null;
/** @example <p>Body</p> */
type RichTextBody = string;
declare enum PromptActionTypeEnum {
    CONTINUE = "CONTINUE",
    EXTERNAL = "EXTERNAL",
    NO_BUTTON = "NO_BUTTON"
}
type PromptActionType = keyof typeof PromptActionTypeEnum;
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;
            questionHtml?: string;
            image?: QuestionImage;
        };
        displayLogic: RoutingOptions;
        routingOptions: RoutingOptions;
    };
    type: "texturlprompt";
}
type AvPermission = "camera" | "microphone" | "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;
            questionHtml?: string;
            image?: QuestionImage;
        };
        displayLogic: RoutingOptions;
        routingOptions: RoutingOptions;
    };
    type: "consentlegal";
}
interface BaseTaskPage {
    buttonText: string;
    headline: string;
    type: RecordedTaskPageType;
}
type RecordedTaskPageType = "av_permission" | "screen_permission" | "start_task" | "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: "av_permission";
}
interface ScreenTaskPage extends BaseTaskPage {
    captionText: string;
    permissionDeniedCaptionText: string;
    permissionDeniedHeadline: string;
    selectTabText: string;
    skipButtonText: string;
    type: "screen_permission";
}
interface StartTaskPage extends BaseTaskPage {
    captionText?: string;
    skipButtonText: string;
    taskDetail: string;
    type: "start_task";
}
interface CompleteTaskPage extends BaseTaskPage {
    captionText?: string;
    skipButtonText: string;
    taskDetail: string;
    type: "complete_task";
}
type RecordedTaskPage = PermissionTaskPage | ScreenTaskPage | StartTaskPage | CompleteTaskPage;
interface RecordedTaskCardProperties {
    captionText: string;
    conceptUrl: ConceptUrl;
    pages: RecordedTaskPage[];
    permissions: AvPermission[];
    required: boolean;
    taskDetail: string;
    image?: QuestionImage;
}
interface RecordedTaskCard extends BaseCard {
    props: {
        message: string;
        options: [];
        properties: RecordedTaskCardProperties;
        displayLogic: RoutingOptions;
        routingOptions: RoutingOptions<"given_up">;
    };
    type: "recordedtask";
}
interface Labels {
    left: string;
    right: string;
}
interface RatingIcon {
    idx?: number;
    svg: string;
}
type ScaleLabelType = "number" | "smiley" | "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;
            image?: QuestionImage;
        };
        displayLogic: RoutingOptions;
        routingOptions: RoutingOptions<"eq" | "given_up" | "gt" | "gte" | "lt" | "lte" | "neq">;
    };
    type: "likert";
}
interface OpenTextCard extends BaseCard {
    props: {
        message: string;
        options: [];
        properties: {
            body: string;
            buttonText?: string;
            captionText?: string;
            conceptUrl: ConceptUrl;
            footerHtml?: string;
            openTextPlaceholder?: string;
            required: boolean;
            richTextBody: RichTextBody;
            skipButtonText?: string;
            image?: QuestionImage;
        };
        displayLogic: RoutingOptions;
        routingOptions: RoutingOptions<"contains" | "notcontains">;
    };
    type: "open";
}
/**
 * DynamicQuestionCard loading:
 *   - `inFlight` — DQ network request inflight
 *   - `success` - successful DQ network request
 *   - `undefined` - network call not yet triggered
 *   - `failure` - unsuccessful DQ network call
 */
declare enum DynamicQuestionLoadingStates {
    failure = "failure",
    success = "success",
    inFlight = "inFlight"
}
interface DynamicQuestionCard extends BaseCard {
    props: OpenTextCard["props"] & {
        loading?: DynamicQuestionLoadingStates;
    };
    type: "aidynamicfollowup" | "aidynamicstandalone";
}
interface MultipleChoiceOption {
    createdAt: string;
    deletedAt: null;
    id: number;
    label: string;
    optionProperties: null | {
        allowsTextEntry?: boolean;
        noneOfTheAbove?: boolean;
        isPinned?: boolean;
        otherOptionPlaceholder?: string;
    };
    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;
        isDropdown?: boolean;
        /**
         * Placeholder text on the dropdown button when no items are selected
         */
        dropdownPlaceholderText?: string;
        /**
         * Text when multiple items are selected, such as "2 items selected" / "3 items selected"
         */
        dropdownMultiselectedText?: string;
        randomize: Randomize;
        required: boolean;
        minSelect?: number;
        maxSelect?: number;
        maxSelectMode?: MaxSelectModes;
        image?: QuestionImage;
    };
}
declare enum MaxSelectModes {
    Unlimited = "Unlimited",
    Maximum = "Maximum",
    Range = "Range"
}
interface MultiChoiceCard<C extends Comparator = DefaultComparator> extends BaseCard {
    props: CommonMultipleChoiceProps & {
        displayLogic: RoutingOptions;
        routingOptions: RoutingOptions<C>;
    };
}
interface MultipleChoiceSingleSelectCard extends MultiChoiceCard<"eq" | "neq" | "list_alo" | "list_dni"> {
    type: "multiplechoice";
}
interface MultipleChoiceMultiSelectCard extends MultiChoiceCard<"list_all" | "list_alo" | "list_exact" | "list_dni"> {
    type: "multipleselect";
}
interface MatrixCard extends BaseCard {
    props: {
        options: MultipleChoiceOption[];
        message: string;
        routingOptions: RoutingOptions<"skipped" | "partial" | "answered">;
        displayLogic: RoutingOptions;
        properties: {
            buttonText?: string;
            captionText: string;
            conceptUrl: ConceptUrl;
            displayMatrixAsAccordion?: boolean;
            matrixColumn: {
                label: string;
                value: string;
            }[];
            randomize: Randomize;
            required: boolean;
            image?: QuestionImage;
        };
    };
    type: "matrix";
}
interface NPSCard extends BaseCard {
    props: {
        labels: Labels;
        message: string;
        options: [];
        properties: {
            buttonText?: string;
            captionText: string;
            conceptUrl: null;
            labels: Labels;
            required: boolean;
            image?: QuestionImage;
        };
        displayLogic: RoutingOptions;
        routingOptions: RoutingOptions<"eq" | "gt" | "gte" | "lt" | "lte" | "neq">;
    };
    type: "nps";
}
interface RankOrderOption {
    createdAt: string;
    deletedAt: null;
    id: number;
    label: string;
    order: number;
    productId: number;
    surveyId: number;
    surveyQuestionId: number;
    updatedAt: string;
    value: string;
}
interface RankOrderType extends BaseCard {
    props: {
        labels: Labels;
        message: string;
        options: RankOrderOption[];
        properties: {
            captionText: string;
            buttonText?: string;
            conceptUrl: ConceptUrl;
            labels: Labels;
            required: boolean;
            randomize: Randomize;
            image?: QuestionImage;
        };
        displayLogic: RoutingOptions;
        routingOptions: RoutingOptions<"eq" | "gt" | "gte" | "lt" | "lte" | "neq">;
    };
    type: "rankorder";
}
type MaxDiffOption = {
    id: number;
    label: string;
};
type ConjointOption = {
    id: number;
    label: string;
    value: string;
    order: number;
};
type ConjointCardConcept = {
    levels: {
        featureId: number;
        levelId: number;
    }[];
} | {
    none: true;
};
type ConjointCardTask = ConjointCardConcept[];
interface ConjointType extends BaseCard {
    props: {
        message: string;
        options: ConjointOption[];
        task: ConjointCardTask;
        displayLogic: RoutingOptions;
        routingOptions: RoutingOptions<"skipped" | "answered">;
        properties: {
            buttonText?: string;
            captionText?: string;
            noneOptionLabel?: string;
            required: boolean;
            conceptUrl: ConceptUrl;
            design: {
                mode: "recommended" | "custom";
                tasksPerRespondent: number;
                conceptsPerSet: number;
                includeNoneOption: boolean;
                randomizeFeatureOrder: boolean;
            };
            conjoint: {
                featureOptionIds: number[];
                levelOptionIdsByFeature: Record<string, number[]>;
            };
        };
    };
    type: "conjoint";
}
interface MaxDiffType extends BaseCard {
    props: {
        labels: {
            left: string | null;
            right: string | null;
        };
        message: string;
        options: MaxDiffOption[];
        displayLogic: RoutingOptions;
        routingOptions: RoutingOptions<"skipped" | "answered">;
        properties: {
            ratingIcons?: {
                idx?: number;
                svg: string;
            }[];
            mode: "recommended" | "custom";
            labels: {
                left: string | null;
                right: string | null;
            };
            options: string[];
            required: boolean;
            answerStyle: "radio" | "smiley";
            captionText: string;
            itemsPerSet: number;
            setsPerUser: number;
            numberOfItems: number;
            numberOfTimesToShowItem: number;
            buttonText?: string;
            image?: QuestionImage;
        };
    };
    type: "maxdiff";
}
interface VideoVoiceCard extends BaseCard {
    props: {
        message: string;
        options: [];
        properties: {
            buttonText: string;
            captionText: string;
            conceptUrl: null;
            hideRecordedPrompt?: boolean;
            mediaType: "video" | "audio";
            required: boolean;
            skipButtonText: string;
            uploadId: string;
            videoUrl: string;
        };
        routingOptions: RoutingOptions;
        displayLogic: RoutingOptions;
    };
    type: "videovoice";
}
type Card = TextUrlPromptCard | ConsentLegalCard | DynamicQuestionCard | RecordedTaskCard | LikertCard | OpenTextCard | MatrixCard | MaxDiffType | ConjointType | MultipleChoiceSingleSelectCard | MultipleChoiceMultiSelectCard | NPSCard | RankOrderType | VideoVoiceCard;
interface QuestionImage {
    altText: string;
    src: string;
    srcSet: string;
    width: number;
    height: number;
}

type InteractiveMatchType = "exactly" | "legacy";
type PageUrlMatchType = "contains" | "exactly" | "legacy" | "notContains" | "regex" | "startsWith";
interface InteractiveEvent {
    id: number;
    matchType: InteractiveMatchType;
    name: string;
    pattern: string;
    properties: {
        innerText: string;
        selector?: string;
        type?: "click";
    };
}
interface PageUrlEvent {
    id: number;
    matchType: PageUrlMatchType;
    pattern: string;
}

declare enum DismissReason {
    Closed = "close.click",// user clicked the close button
    Complete = "survey.completed",// user answered all questions
    FeedbackClosed = "feedback.closed",// user either clicked on feedback button or close button
    PageChange = "page.change",// productConfig.dismissOnPageChange == true and we detected a page change (excludes hash/query param changes)
    API = "api",// JS called Sprig('dismissActiveSurvey')
    Override = "override"
}
type StudyType = "feedbackButton" | "inProductSurvey" | "longFormSurvey";
declare enum SprigEvent {
    ReplayCapture = "replay.capture",
    ReplayPaused = "replay.paused",
    ReplayResumed = "replay.resumed",
    FeedbackButtonLoaded = "feedback.button.loaded",
    SDKReady = "sdk.ready",
    SurveyAppeared = "survey.appeared",
    SurveyCloseRequested = "survey.closeRequested",//This event signals to mobile the survey overlay can close
    SurveyClosed = "survey.closed",
    SurveyDimensions = "survey.dimensions",
    SurveyFadingOut = "survey.fadingOut",
    SurveyHeight = "survey.height",
    SurveyPresented = "survey.presented",
    SurveyLifeCycle = "survey.lifeCycle",
    SurveyWidth = "survey.width",
    SurveyWillClose = "survey.willClose",
    SurveyWillPresent = "survey.will.present",
    CloseSurveyOnOverlayClick = "close.survey.overlayClick",
    VisitorIDUpdated = "visitor.id.updated",
    QuestionAnswered = "question.answered"
}
declare const EVENTS: {
    FEEDBACK_BUTTON_LOADED: SprigEvent;
    SDK_READY: SprigEvent;
    SURVEY_APPEARED: SprigEvent;
    SURVEY_CLOSED: SprigEvent;
    SURVEY_DIMENSIONS: SprigEvent;
    SURVEY_FADING_OUT: SprigEvent;
    SURVEY_HEIGHT: SprigEvent;
    SURVEY_WIDTH: SprigEvent;
    SURVEY_PRESENTED: SprigEvent;
    SURVEY_LIFE_CYCLE: SprigEvent;
    SURVEY_WILL_CLOSE: SprigEvent;
    SURVEY_WILL_PRESENT: SprigEvent;
    QUESTION_ANSWERED: SprigEvent;
    REPLAY_CAPTURE: SprigEvent;
    CLOSE_SURVEY_ON_OVERLAY_CLICK: SprigEvent;
    VISITOR_ID_UPDATED: SprigEvent;
    DATA: {
        DISMISS_REASONS: {
            API: DismissReason;
            CLOSED: DismissReason;
            COMPLETE: DismissReason;
            PAGE_CHANGE: DismissReason;
            OVERRIDE: DismissReason;
        };
        SURVEY_ID: string;
    };
};

type Metric = "sdk_event_queue_latency_seconds" | "sdk_replay_add_event_batch_seconds" | "sdk_replay_cleanup_seconds" | "sdk_replay_compression_seconds" | "sdk_replay_get_events_between_seconds" | "sdk_replay_snapshot_seconds" | "sdk_mutations_nodes_added" | "sdk_mutations_nodes_removed" | "sdk_mutations_attributes_changed" | "sdk_mutations_character_data" | "sdk_dom_nodes_count" | "sdk_page_html_characters";
type ThresholdType = "max" | "min";
interface MetricThreshold {
    metric: Metric;
    type: ThresholdType;
    value: number;
}

interface RecordedTaskResponseType {
    questionId: number;
    type: CardType;
    value: RecordedTaskResponseValueType;
}

type SurveyState = "ready" | "no survey" | "previous survey ready";
type ReplayDurationType = "after" | "before" | "beforeAndAfter";

interface MobileReplayConfig {
    mobileMetricsReportingEnabled?: boolean;
    metricsReportingInterval?: number;
    metricsThresholds?: MetricThreshold[];
    maxMobileReplayDurationSeconds?: number;
    mobileReplaySettings?: {
        hideAllFormContents: boolean;
        hidePasswordsOnly: boolean;
        hideAllImages: boolean;
    };
}
type SprigEventMap = {
    "survey.question": [
        {
            qid: number;
            props: unknown;
        }
    ];
    "recorded.task.permission.screen": [];
    "recorded.task.start": [];
    "survey.complete": [number];
    "verify.view.version": [
        {
            "view.version": string;
        }
    ];
    [SprigEvent.CloseSurveyOnOverlayClick]: [];
    [SprigEvent.FeedbackButtonLoaded]: [
        {
            name: string;
            "survey.id"?: number;
        }
    ];
    [SprigEvent.SDKReady]: [MobileReplayConfig];
    [SprigEvent.SurveyAppeared]: [
        {
            name: string;
            "survey.id": number;
        }
    ];
    [SprigEvent.SurveyDimensions]: [
        {
            contentFrameHeight: number;
            contentFrameWidth: number;
            name: string;
            "survey.id": number;
        }
    ];
    [SprigEvent.SurveyClosed]: [
        {
            initiator?: string;
            name: string;
            studyType?: StudyType;
            "survey.id": number;
        }
    ];
    [SprigEvent.SurveyFadingOut]: [];
    [SprigEvent.SurveyHeight]: [
        {
            name: string;
            contentFrameHeight: number;
            "survey.id": number;
        }
    ];
    [SprigEvent.SurveyWidth]: [
        {
            name: string;
            contentFrameWidth: number;
            "survey.id": number;
        }
    ];
    [SprigEvent.SurveyLifeCycle]: [{
        state: string;
    }];
    [SprigEvent.SurveyPresented]: [
        {
            name: string;
            "survey.id": number;
        }
    ];
    [SprigEvent.SurveyCloseRequested]: [
        {
            initiator: DismissReason;
            name?: string;
            studyType?: StudyType;
            "survey.id": number;
        }
    ];
    [SprigEvent.SurveyWillClose]: [
        {
            initiator: DismissReason;
            name?: string;
            studyType?: StudyType;
            "survey.id": number;
        }
    ];
    [SprigEvent.SurveyWillPresent]: [
        {
            name: string;
            "survey.id": number;
            layout: StudyLayout;
        }
    ];
    [SprigEvent.VisitorIDUpdated]: [{
        visitorId: string | null;
    }];
    [SprigEvent.QuestionAnswered]: [
        {
            answeredAt?: number;
            questionIndex?: number;
            value: unknown;
            "survey.id": number;
        }
    ];
    [SprigEvent.ReplayCapture]: [
        {
            responseGroupUid: string;
            hasQuestions: boolean;
            uploadId: string;
            seconds: number;
            replayType: ReplayDurationType;
            generateVideoUploadUrlPayload: {
                isReplay: boolean;
                mediaRecordingUid: string;
                mediaType: MediaType;
                questionId: number;
                responseGroupUid: string;
                surveyId: number;
                updatedAt: string;
                visitorId: string | null;
            };
            surveyId: number;
        }
    ];
    [SprigEvent.ReplayPaused]: [];
    [SprigEvent.ReplayResumed]: [];
    "av.permission": [
        {
            "stream.ready": (avStream: MediaStream | null, captureStream?: MediaStream | null) => void;
            "permission.descriptors": AvPermission[];
        }
    ];
    "begin.recording": [
        {
            "recording.media.types": MediaType[];
            "start.recording.callback": (mediaRecordingUids: UUID[]) => void;
        }
    ];
    "finish.task": [
        {
            "begin.callback": (mediaRecordingUid: UUID) => void;
            "current.index": number;
            "passthrough.data": PassthroughData;
            "progress.callback": (mediaRecordingUid: UUID, data: {
                detail: number;
            }) => void;
            "task.complete.callback": (taskDurationMillisecond: number) => void;
            "task.response": RecordedTaskResponseType;
            "upload.callback": (mediaRecordingUid: UUID | null, successOrError: true | unknown) => void;
        }
    ];
    "permission.status": [
        {
            "permission.status.callback": (avStream: MediaStream | undefined, hasVideoPermission: boolean, hasScreenPermission: boolean, captureStream: MediaStream | undefined) => void;
        }
    ];
    "screen.permission": [
        {
            "screen.permission.requested"?: (data: boolean) => void;
            "stream.ready.callback": (avStream: MediaStream | null, captureStream: MediaStream | null) => void;
        }
    ];
    "start.task": [];
};
declare const eventEmitter: Emitter<SprigEventMap>;
type SprigEventEmitter = typeof eventEmitter;

type StudyLayout = "default" | "conversational";
type FramePosition = "bottomLeft" | "bottomRight" | "center" | "topLeft" | "topRight";
type Platform = "email" | "link" | "web";
type InstallationMethod = "web-npm" | "web-npm-bundled" | "web-gtm" | "web-segment" | "android-segment" | "react-native-segment" | "ios-segment" | "web-snippet";
interface Answer {
    questionId: number;
    value: unknown;
}
type QuotaConstraint = {
    comparisonType: Comparator;
    constraintTypeId: number;
    questionUid: string;
    uuid: UUID;
    value: RoutingGroupOption["value"];
};
type QuotaConstraintGroupSegment = QuotaConstraint | number | QuotaConstraintGroupSegment[];
type Quota = {
    constraintGroup: QuotaConstraintGroupSegment[];
    id: number;
    name: string;
    quotaFilled: boolean;
};
type QuotaEndcardMessage = {
    headline?: string;
    subheader?: string;
};
type QuotaMessages = {
    disqualified?: QuotaEndcardMessage;
    filled?: QuotaEndcardMessage;
};
type FeedbackPlacement = "center-left" | "center-right" | "bottom-left" | "bottom-right";
type FeedbackDesktopDisplay = "center-modal" | "slider";
interface Avatars {
    agentAvatar: {
        "1x": string;
        "2x": string;
    };
    respondentAvatar: {
        "1x": string;
        "2x": string;
    };
}
interface AppProductConfig {
    framePosition?: FramePosition;
    desktopDisplay?: FeedbackDesktopDisplay;
    placement?: FeedbackPlacement;
    enableDarkmode?: boolean;
}
interface Config extends MobileReplayConfig {
    addResponseGroupMeta?: () => Promise<JSONObject>;
    allResponses: CardResponse[];
    allResponsesRaw: Record<string | number, string>;
    answers?: Answer[];
    apiURL: string;
    avatars: Avatars;
    /** @example "#000000" */
    border: string;
    cards: Card[];
    configureExitOnOverlayClick: (cb: () => void) => void;
    context: {
        outcome: string;
        product: {
            name: string;
        };
        visitor: {
            outcome: string;
        };
    };
    createDynamicStandaloneQuestion: (s: {
        questionId: number;
    }) => void;
    createDynamicFollowupQuestion: (s: {
        parentQuestionId: number;
        parentResponseConfig?: Config["allResponsesRaw"];
    }) => void;
    customMetadata?: Record<string, unknown>;
    customStyles?: string;
    dismissOnPageChange: boolean;
    enableCspTrustedTypes?: boolean;
    enableDarkmode?: boolean;
    forceBrandedLogo?: boolean;
    endCard?: {
        headline: string;
        subheader?: string;
    };
    /** @example "SJcVfq-7QQ" */
    envId: string;
    environmentId?: string;
    exitOnOverlayClick?: boolean;
    exitOnOverlayClickMobile?: boolean;
    experimentFlags?: Record<string, 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 | "ios" | "android" | "video_recorder";
        "sprig-modules"?: string;
        /** @example "SJcVfq-7QQ" */
        "x-ul-environment-id"?: string;
        "x-ul-installation-method": InstallationMethod;
        "x-ul-anonymous-id"?: string;
        "x-ul-error"?: string;
        "x-ul-preview-mode"?: string;
        /** @example "2.18.0" */
        "x-ul-sdk-version"?: string;
        /** For web-bundled sdk */
        "x-ul-package-version"?: string;
        "x-ul-user-id"?: string;
        "x-ul-visitor-id"?: string;
    };
    installationMethod?: InstallationMethod;
    interactiveEvents: InteractiveEvent[];
    interactiveEventsHandler?: (e: MouseEvent) => void;
    isConversationalUI?: boolean;
    isOnQuestionsTab?: boolean;
    launchDarklyEnabled?: boolean;
    layout: StudyLayout;
    locale: string;
    logBufferLimit?: number;
    marketingUrl?: string;
    maxAttrNameLength: number;
    maxAttrValueLength: number;
    maxEmailLength: number;
    maxEventLength: number;
    maxReplayDurationSeconds?: number;
    maxUserIdLength: number;
    mobileSDKVersion: undefined;
    mode?: string;
    mute?: boolean;
    optimizelyEnabled?: boolean;
    outstandingTransactionLimit?: number | null;
    overlayStyle: "light";
    overlayStyleMobile: "none";
    pageUrlEvents: PageUrlEvent[];
    path?: string;
    platform?: Platform;
    previewKey?: string | null;
    previewMode?: boolean;
    productConfig?: AppProductConfig;
    quotaMessages?: QuotaMessages;
    providerPersona?: string | null;
    quotas?: Quota[];
    replaySettings?: object;
    requireUserIdForTracking: boolean;
    responseGroupUid: UUID;
    showProviderPersona?: boolean;
    showStripes: boolean;
    showSurveyBrand: boolean;
    showSurveyLogo?: boolean;
    useBranding?: boolean;
    slugName: null;
    startingQuestionIdx?: number | null;
    styleNonce?: string;
    studyType?: StudyType;
    surveyVisitorAttributes: Record<string, unknown>;
    surveyId: number;
    tabTitle: string;
    trackPageViewUrl?: string;
    ulEvents: typeof SprigEvent;
    UpChunk: Window["UpChunk"];
    upchunkLibraryURL?: string;
    useDesktopPrototype?: boolean;
    useMobileStyling: boolean;
    userId: UUID | null;
    visitorId: UUID | null;
    viewDocument: Document;
    viewWindow: Window;
    visitorAttributes: {
        email?: string;
        externalUserId?: string;
    };
}
type JSONPrimitive = string | number | boolean | null;
type JSONValue = JSONPrimitive | JSONValue[] | {
    [key: string]: JSONValue;
};
type JSONObject = Record<string, JSONValue>;

interface Experiment {
    id: string;
    variation?: string;
}

type QueueItem = [string, ...unknown[]] | (() => void);
declare class SprigQueue {
    paused: boolean;
    queue: QueueItem[];
    ul: WindowSprig;
    constructor(ul: WindowSprig, queue: QueueItem[]);
    flush(queue: QueueItem[]): void;
    isPaused(): boolean;
    pause(): void;
    unpause(): void;
    push(action: QueueItem): void;
    perform(func: () => void): void | Promise<unknown>;
    /**
     * Removes all queued items
     */
    empty(): void;
}

type EventDigest = {
    timestamp: number;
    type: "Sprig_Click";
} | {
    timestamp: number;
    name: string;
    type: "Sprig_TrackEvent";
} | {
    timestamp: number;
    type: "Sprig_PageView";
    url: string;
} | {
    timestamp: number;
    surveyId: string;
    type: "Sprig_ShowSurvey";
} | {
    timestamp: number;
    surveyId: string;
    type: "Sprig_SubmitSurvey";
} | {
    timestamp: number;
    type: "Sprig_ReplayPaused";
} | {
    timestamp: number;
    type: "Sprig_ReplayResumed";
};

declare namespace sprigConfig {
  type IdentifyResult = Promise<
    | {
        error?: Error;
        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<boolean>;
    _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;
    _reportMetric: (name: Metric, value: number) => void;

    // external apis
    addListener: (event: SprigEvent, listener: SprigListener) => Promise<void>;
    addSurveyListener: (listener: SprigListener) => Promise<void>;
    applyFeedbackStyles: (styles: { button?: string; view?: string }) => void;
    applyStyles: (styleString: string) => void;
    dismissActiveSurvey: (reason?: DismissReason) => void;
    displaySurvey: (surveyId: number) => IdentifyResult;
    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 | boolean,
    ) => 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>,
      calledFromApi?: boolean,
    ) => void;
    trackHistory?: ({ event: string }) => void;
    unmute: () => void;
    pauseReplayRecording: () => void;
    resumeReplayRecording: () => 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 & {
        desktopDisplay?: string;
        previewLanguage?: string;
      };
      _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;
      feedbackCustomStyles?: string;
      forceDirectEmbed?: boolean;
      frameId: string;
      isMobileSDK?: boolean;
      loaded: boolean;
      locale?: string;
      maxHeight?: number | string;
      maxInflightReplayRequests?: number;
      outstandingTransactionLimit?: number | null;
      mobileHeadersJSON?: string;
      nonce?: string;
      partnerAnonymousId: string | null;
      pointerDownTarget?: EventTarget | null;
      replayLibraryURL?: string;
      reportError: (
        name: string,
        err: Error,
        extraInfo?: object,
        bodyInfo?: object,
      ) => void;
      sampleRate?: number;
      token: string | null;
      upchunkLibraryURL?: string;
      UPDATES: typeof EVENTS;
      viewSDKURL?: string;
      windowDimensions?: {
        height: number;
        width: number;
      };
    };
}

declare global {
  interface Window {
    __cfg: Config;
    __sprigReinitialize?: () => void;
    attachEvent?: typeof window.addEventListener;
    Backbone: {
      history: typeof window.history;
    };
    Intercom: { ul_wasVisible?: boolean } & ((
      method: string,
      data?: unknown,
    ) => void);
    optimizely?: optimizely.Optimizely;
    optimizelyDatafile?: object;
    previewMode?: unknown;
    UpChunk: {
      createUpload: typeof createUpload;
    };
    _Sprig?: sprigConfig.WindowSprig;
    Sprig: sprigConfig.WindowSprig;
    UserLeap: sprigConfig.WindowSprig;
    rrwebRecord?: (typeof _rrweb_record)["record"];
    sprigAPI?: { openUrl: (url: string) => void };
    SprigLoggerCallback?: (message: string) => void;
  }

  /* eslint-disable no-var */
  var __cfg: Config;
  var _sprigReinitialize: () => void;
  var attachEvent: typeof window.addEventListener | undefined;
  var Backbone: {
    history: typeof window.history;
  };
  var Intercom: { ul_wasVisible?: boolean } & ((
    method: string,
    data?: unknown,
  ) => void);
  var optimizely: optimizely.Optimizely;
  var optimizelyDatafile: object;
  var previewMode: unknown;
  var UpChunk: {
    createUpload: typeof createUpload;
  };
  var _Sprig: sprigConfig.WindowSprig | undefined;
  var Sprig: sprigConfig.WindowSprig;
  var UserLeap: sprigConfig.WindowSprig & {
    windowDimensions?: { height: number; width: number };
  };
  var rrwebRecord: (typeof _rrweb_record)["record"] | undefined;
  var sprigAPI: { openUrl: (url: string) => void } | undefined;
  var SprigLoggerCallback: (message: string) => void | undefined;
  /* eslint-enable no-var */

  type WindowSprig = sprigConfig.WindowSprig;
  type SprigAttributes = Record<string, boolean | number | string>;
  type SprigListener = Listener<unknown[]>;
  type SprigMetadata = {
    url?: string;
    trackPageView?: boolean;
    optimizelyExperiments?: object;
    launchDarklyFlags?: object;
    eventProperties?: SprigProperties;
  };
  type SprigProperties = Record<string, unknown>;
  type SprigAPIActions = sprigConfig.SprigAPIActions;
  type TrackPayload = sprigConfig.TrackPayload;

  // common types
  /** @example "123e4567-e89b-12d3-a456-426614174000" */
  type UUID = string;

  interface Document {
    write(...text: Array<string | TrustedHTML>): void;
  }

  interface Element {
    innerHTML: string | TrustedHTML;
  }
}

declare class SprigAPI {
    /**
     * Include external events emitted from Sprig
     */
    UPDATES: {
        FEEDBACK_BUTTON_LOADED: SprigEvent;
        SDK_READY: SprigEvent;
        SURVEY_APPEARED: SprigEvent;
        SURVEY_CLOSED: SprigEvent;
        SURVEY_DIMENSIONS: SprigEvent;
        SURVEY_FADING_OUT: SprigEvent;
        SURVEY_HEIGHT: SprigEvent;
        SURVEY_WIDTH: SprigEvent;
        SURVEY_PRESENTED: SprigEvent;
        SURVEY_LIFE_CYCLE: SprigEvent;
        SURVEY_WILL_CLOSE: SprigEvent;
        SURVEY_WILL_PRESENT: SprigEvent;
        QUESTION_ANSWERED: SprigEvent;
        REPLAY_CAPTURE: SprigEvent;
        CLOSE_SURVEY_ON_OVERLAY_CLICK: SprigEvent;
        VISITOR_ID_UPDATED: SprigEvent;
        DATA: {
            DISMISS_REASONS: {
                API: DismissReason;
                CLOSED: DismissReason;
                COMPLETE: DismissReason;
                PAGE_CHANGE: DismissReason;
                OVERRIDE: DismissReason;
            };
            SURVEY_ID: string;
        };
    };
    /**
     * 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 | number | boolean): 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 globalThis
     */
    teardown(): void;
    /**
     * Pause replay recording
     */
    pauseReplayRecording(): void;
    /**
     * Resume replay recording
     */
    resumeReplayRecording(): 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 globalThis.Sprig;

declare const Sprig: SprigAPI;
declare const _default: {
    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;
    };
    SprigAPI: typeof SprigAPI;
    configure: (config: NpmConfig) => sprigConfig.WindowSprig;
    Sprig: SprigAPI;
};

export { DismissReason, Sprig, SprigAPI, SprigEvent, type WindowSprig$1 as WindowSprig, _default as default, sprig };