@sprig-technologies/sprig-browser 2.21.2 → 2.21.4

package/dist/index.d.ts

@@ -1,3 +1,1049 @@
-export * from './sprig-browser/index'
-import _default from './sprig-browser/index'
-export default _default
+import { StrictEventEmitter } from 'strict-event-emitter';
+
+declare enum DismissReason {
+    Closed = "close.click",
+    Complete = "survey.completed",
+    PageChange = "page.change",
+    API = "api",
+    Override = "override"
+}
+declare enum SprigEvent {
+    SDKReady = "sdk.ready",
+    SurveyAppeared = "survey.appeared",
+    SurveyClosed = "survey.closed",
+    SurveyDimensions = "survey.dimensions",
+    SurveyFadingOut = "survey.fadingOut",
+    SurveyHeight = "survey.height",
+    SurveyPresented = "survey.presented",
+    SurveyLifeCycle = "survey.lifeCycle",
+    SurveyWillClose = "survey.willClose",
+    SurveyWillPresent = "survey.will.present",
+    CloseSurveyOnOverlayClick = "close.survey.overlayClick",
+    VisitorIDUpdated = "visitor.id.updated"
+}
+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;
+    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 {
+    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;
+}
+
+declare const enum CardType {
+    ConsentLegal = "consentlegal",
+    Likert = "likert",
+    MultipleChoice = "multiplechoice",
+    MultipleSelect = "multipleselect",
+    NPS = "nps",
+    Open = "open",
+    RecordedTask = "recordedtask",
+    TextUrlPrompt = "texturlprompt",
+    Thanks = "thanks",
+    Uploading = "uploading",
+    VideoVoice = "videovoice"
+}
+declare type ConceptUrl = string | null;
+interface BaseCard {
+    name: number;
+    surveyId: number;
+    updatedAt: string;
+    value?: unknown;
+}
+declare const enum Comparator {
+    Answered = "answered",
+    Equal = "eq",
+    NotEqual = "neq",
+    Skipped = "skipped",
+    LessThan = "lt",
+    LessThanOrEqual = "lte",
+    GivenUp = "given_up",
+    GreaterThan = "gt",
+    GreaterThanOrEqual = "gte",
+    ListAll = "list_all",
+    ListAtLeastOne = "list_alo",
+    ListExact = "list_exact"
+}
+declare type DefaultComparator = Comparator.Answered | Comparator.Skipped;
+interface RoutingOption<C extends Comparator = DefaultComparator> {
+    comparator: C;
+    target: number;
+    /** @example '', 'option_2', ['option_1'] */
+    value: number | string | string[];
+}
+declare type RoutingOptions<C extends Comparator = DefaultComparator> = RoutingOption<C | DefaultComparator>[] | null;
+/** @example <p>Body</p> */
+declare 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;
+    taskDetail: string;
+    type: RecordedTaskPageType.StartTask;
+}
+interface CompleteTaskPage extends BaseTaskPage {
+    captionText?: string;
+    skipButtonText: string;
+    taskDetail: string;
+    type: RecordedTaskPageType.CompleteTask;
+}
+declare 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;
+    };
+    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> {
+    type: CardType.MultipleChoice;
+}
+interface MultipleChoiceMultiSelectCard extends MultiChoiceCard<Comparator.ListAll | Comparator.ListAtLeastOne | Comparator.ListExact> {
+    type: CardType.MultipleSelect;
+}
+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;
+}
+declare type Card = TextUrlPromptCard | ConsentLegalCard | RecordedTaskCard | LikertCard | OpenTextCard | MultipleChoiceSingleSelectCard | MultipleChoiceMultiSelectCard | NPSCard | VideoVoiceCard;
+
+interface RecordedTaskResponseValueType {
+    mediaRecordingUids?: string[] | null;
+    taskDurationMillisecond?: number;
+    taskStatus: TaskStatus;
+}
+
+interface RecordedTaskResponseType {
+    questionId: number;
+    type: CardType;
+    value: RecordedTaskResponseValueType;
+}
+
+interface SprigEventMap {
+    [InternalEventName.CurrentQuestion]: (data: {
+        [InternalEventData.QuestionId]: number;
+        [InternalEventData.Props]: unknown;
+    }) => void;
+    [InternalEventName.RecordedTaskPermissionScreen]: () => void;
+    [InternalEventName.RecordedTaskStart]: () => void;
+    [InternalEventName.SurveyComplete]: () => void;
+    [InternalEventName.VerifyViewVersion]: (data: {
+        [InternalEventData.ViewVersion]: string;
+    }) => void;
+    [SprigEvent.CloseSurveyOnOverlayClick]: () => void;
+    [SprigEvent.SDKReady]: () => void;
+    [SprigEvent.SurveyAppeared]: () => void;
+    [SprigEvent.SurveyDimensions]: (data: {
+        contentFrameHeight: number;
+        contentFrameWidth: number;
+        name: string;
+    }) => void;
+    [SprigEvent.SurveyClosed]: (data: {
+        initiator?: unknown;
+        name: string;
+    }) => void;
+    [SprigEvent.SurveyFadingOut]: () => void;
+    [SprigEvent.SurveyHeight]: (data: {
+        name: string;
+        contentFrameHeight: number;
+    }) => void;
+    [SprigEvent.SurveyLifeCycle]: (data: {
+        state: string;
+    }) => void;
+    [SprigEvent.SurveyPresented]: (data: {
+        name: string;
+    }) => void;
+    [SprigEvent.SurveyWillClose]: (data: {
+        initiator: DismissReason;
+        name?: string;
+    }) => void;
+    [SprigEvent.SurveyWillPresent]: (data: {
+        name: string;
+        "survey.id": number;
+    }) => void;
+    [SprigEvent.VisitorIDUpdated]: (data: {
+        visitorId: string | null;
+    }) => void;
+    [SprigRecordingEvent.AvPermission]: (data: {
+        [SprigRecordingEventData.StreamCanceledCallback]: () => void;
+        [SprigRecordingEventData.StreamReadyCallback]: (avStream: MediaStream | null, captureStream?: MediaStream | null) => void;
+        [SprigRecordingEventData.PermissionDescriptors]: AvPermission[];
+    }) => void;
+    [SprigRecordingEvent.BeginRecording]: (data: {
+        [SprigRecordingEventData.RecordingMediaTypes]: MediaType[];
+        [SprigRecordingEventData.StartRecordingCallback]: (mediaRecordingUids: UUID[]) => void;
+    }) => void;
+    [SprigRecordingEvent.FinishTask]: (data: {
+        [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;
+    }) => void;
+    [SprigRecordingEvent.PermissionStatus]: (data: {
+        [SprigRecordingEventData.PermissionStatusCallback]: (avStream: MediaStream | undefined, hasVideoPermission: boolean, hasScreenPermission: boolean) => void;
+    }) => void;
+    [SprigRecordingEvent.ScreenPermission]: (data: {
+        [SprigRecordingEventData.StreamCanceledCallback]: () => void;
+        [SprigRecordingEventData.StreamReadyCallback]: (avStream: MediaStream | null, captureStream: MediaStream | null) => void;
+    }) => void;
+    [SprigRecordingEvent.StartTask]: () => void;
+}
+declare type SprigEventEmitter = StrictEventEmitter<SprigEventMap>;
+
+declare 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",
+    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 {
+    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;
+    endCard?: {
+        headline: string;
+        subheader?: string;
+    };
+    /** @example "SJcVfq-7QQ" */
+    envId: string;
+    environmentId?: string;
+    eventEmitFn: SprigEventEmitter["emit"];
+    fontFamily?: string;
+    fontFamilyURL: undefined;
+    frame: HTMLIFrameElement & {
+        eventEmitter?: SprigEventEmitter;
+        setHeight?: (height: 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;
+        [HttpHeader.UserID]?: string;
+        [HttpHeader.VisitorID]?: UUID;
+    };
+    installationMethod?: InstallationMethod;
+    interactiveEvents: InteractiveEvent[];
+    interactiveEventsHandler?: (e: MouseEvent) => void;
+    isPreview?: boolean;
+    locale: string;
+    marketingUrl?: string;
+    maxAttrNameLength: number;
+    maxAttrValueLength: number;
+    maxEmailLength: number;
+    maxEventLength: number;
+    maxUserIdLength: number;
+    mobileSDKVersion: undefined;
+    mode?: string;
+    mute?: boolean;
+    optimizelyEnabled: boolean;
+    overlayStyle: "light";
+    overlayStyleMobile: "none";
+    pageUrlEvents: PageUrlEvent[];
+    path?: string;
+    platform?: Platform;
+    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 SurveyState {
+    Ready = "ready",
+    NoSurvey = "no survey"
+}
+
+declare 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 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 upchunk {
+  type AllowedMethods = "PUT" | "POST" | "PATCH";
+
+  //Adapted from here: https://github.com/muxinc/upchunk/blob/master/src/upchunk.ts
+  interface UpChunkOptions {
+    endpoint: string | ((file?: File) => Promise<string>);
+    file: File;
+    method?: AllowedMethods;
+    headers?: Headers;
+    maxFileSize?: number;
+    chunkSize?: number;
+    attempts?: number;
+    delayBeforeAttempt?: number;
+    retryCodes?: number[];
+    dynamicChunkSize?: boolean;
+    maxChunkSize?: number;
+    minChunkSize?: number;
+  }
+
+  type UpChunkEventName =
+    | "attempt"
+    | "attemptFailure"
+    | "chunkSuccess"
+    | "error"
+    | "offline"
+    | "online"
+    | "progress"
+    | "success";
+
+  interface UpChunk {
+    startTime: number;
+    on: (eventName: UpChunkEventName, fn: (event: CustomEvent) => void) => void;
+  }
+  interface UpChunkModule {
+    createUpload: (options: UpChunkOptions) => UpChunk;
+  }
+}
+
+declare namespace sprigConfig {
+  type IdentifyResult = Promise<
+    { success: boolean; message?: string } | undefined
+  >;
+
+  interface TrackPayload {
+    anonymousId?: string;
+    metadata?: SprigMetadata;
+    eventName?: string;
+    properties?: SprigProperties;
+    userId?: string;
+  }
+
+  interface SprigAPIActions {
+    _previewSurvey: (surveyTemplateId: UUID) => void;
+    _reviewSurvey: (surveyId: number) => void;
+    addListener: (event: SprigEvent, listener: SprigListener) => Promise<void>;
+    addSurveyListener: (listener: SprigListener) => Promise<void>;
+    applyStyles: (styleString: string) => void;
+    displaySurvey: (surveyId: number) => Promise<{
+      success: boolean;
+      message?: string;
+      surveyState: SurveyState;
+    }>;
+    dismissActiveSurvey: (reason?: DismissReason) => void;
+    identifyAndSetAttributes: (payload: {
+      anonymousId?: string;
+      attributes?: SprigAttributes;
+      userId?: string;
+    }) => IdentifyResult;
+    identifyAndTrack: (payload: TrackPayload) => IdentifyResult;
+    integrateOptimizely: (strData: string) => void;
+    logoutUser: () => void;
+    mute: () => unknown;
+    removeAttributes: (attributes: SprigAttributes) => IdentifyResult;
+    previewSurvey: (surveyTemplateId: UUID) => void;
+    removeAllListeners: () => Promise<void>;
+    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;
+    setUserId: (userId: string) => IdentifyResult;
+    setVisitorEmail: (email: string) => IdentifyResult;
+    setVisitorToken: () => void;
+    teardown: () => void;
+    track: (
+      eventName: string,
+      properties?: TrackPayload["properties"],
+      metadata?: SprigMetadata
+    ) => IdentifyResult;
+    unmute: (surveyId: number) => void;
+  }
+
+  type WindowSprig = Config &
+    SprigAPIActions & {
+      _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;
+      localStorageAvailable: boolean;
+      maxHeight?: number | string;
+      mobileHeadersJSON?: string;
+      nonce?: string;
+      partnerAnonymousId: string | null;
+      reportError: (name: string, err: Error) => void;
+      sampleRate?: unknown; // TODO: determine type
+      token: string | null;
+      UPDATES: typeof EVENTS;
+      viewSDKURL?: string;
+      windowDimensions?: {
+        height: number;
+        width: number;
+      };
+    } & ((name: "_previewSurvey", surveyTemplateId: string) => void) &
+    ((name: "_reviewSurvey", surveyId: number) => void) &
+    ((name: "addListener", event: string, listener: SprigListener) => void) &
+    ((name: "applyStyles", styles: string) => void) &
+    ((name: "dismissActiveSurvey", reason?: DismissReason) => void) &
+    ((name: "displaySurvey", surveyId: number) => void) &
+    ((
+      name: "identifyAndSetAttributes",
+      payload: {
+        anonymousID?: string;
+        attributes: SprigAttributes;
+        userID?: string;
+      }
+    ) => void) &
+    ((
+      name: "identifyAndTrack",
+      payload: {
+        anonymousId?: string;
+        eventName: string;
+        metadata?: SprigMetadata;
+        userId?: string;
+      }
+    ) => void) &
+    ((name: "logoutUser") => void) &
+    ((name: "mute") => void) &
+    ((name: "previewSurvey", surveyTemplateId: string) => void) &
+    ((name: "removeAllListeners") => void) &
+    ((name: "removeAttributes", attributes: SprigAttributes) => void) &
+    ((name: "removeListener", event: string, listener: SprigListener) => void) &
+    ((name: "reviewSurvey", surveyId: number) => void) &
+    ((name: "setAttribute", attribute: string, value: string) => void) &
+    ((name: "setAttributes", attributes: SprigAttributes) => void) &
+    ((name: "setPartnerAnonymousId", partnerAnonymousId: string) => void) &
+    ((name: "setUserId", userId: string) => void) &
+    ((
+      name: "setWindowDimensions",
+      width: number | string,
+      height: number | string
+    ) => void) &
+    ((name: "teardown") => void) &
+    ((
+      name: "track",
+      eventName: string,
+      properties?: SprigProperties,
+      metadata?: SprigMetadata
+    ) => void) &
+    ((name: "unmute") => void);
+}
+
+declare global {
+  interface Window {
+    __cfg: Config;
+    attachEvent?: typeof window.addEventListener;
+    Intercom: Intercom_.IntercomStatic & { ul_wasVisible?: boolean };
+    optimizely?: optimizely.Optimizely;
+    previewMode?: unknown;
+    UpChunk: upchunk.UpChunkModule;
+    _Sprig?: sprigConfig.WindowSprig;
+    Sprig: sprigConfig.WindowSprig;
+    UserLeap: sprigConfig.WindowSprig;
+  }
+
+  type WindowSprig = sprigConfig.WindowSprig;
+  type SprigAttributes = Record<string, boolean | number | string>;
+  type SprigListener = (data: unknown) => void;
+  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;
+        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!
+     * @returns
+     */
+    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: string, listener: SprigListener): void;
+    /**
+     * Remove a listener for an event defined in ulEvents
+     */
+    removeListener(event: string, 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;
+    /**
+     * 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;
+}
+declare 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;
+};
+declare type WindowSprig$1 = typeof window.Sprig;
+
+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;
+};
+
+export { DismissReason, SprigAPI, WindowSprig$1 as WindowSprig, _default as default, sprig };