@sprig-technologies/sprig-browser 2.19.7 → 2.20.0

package/dist/src/types/global.d.ts

@@ -0,0 +1,179 @@
+import { EVENTS } from "../constants/sprigEvents";
+import { Config } from "./config";
+
+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
+  export 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";
+
+  export interface UpChunk {
+    startTime: number;
+    on: (eventName: UpChunkEventName, fn: (event: CustomEvent) => void) => void;
+  }
+  export interface UpChunkModule {
+    createUpload: (options: UpChunkOptions) => UpChunk;
+  }
+}
+
+type WindowSprig = Config & {
+  _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;
+  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: "addListener", event: string, listener: SprigListener) => void) &
+  ((name: "applyStyles", styles: string) => void) &
+  ((name: "dismissActiveSurvey", reason?: string) => 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, height: number) => void) &
+  ((name: "teardown") => void) &
+  ((
+    name: "track",
+    eventName: string,
+    properties?: SprigProperties,
+    metadata?: SprigMetadata
+  ) => void) &
+  ((name: "unmute") => void);
+
+type IntercomProxy = typeof window.Intercom;
+type SprigProxy = WindowSprig;
+
+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?: WindowSprig;
+    Sprig: WindowSprig;
+    UserLeap: WindowSprig;
+  }
+
+  type WindowSprig = SprigProxy;
+  type SprigAttributes = Record<string, boolean | number | string>;
+  type SprigListener = (data: unknown) => void;
+  type SprigMetadata = Record<string, unknown>;
+  type SprigProperties = Record<string, unknown>;
+
+  // common types
+  /** @example "123e4567-e89b-12d3-a456-426614174000" */
+  type UUID = string;
+}

package/dist/src/view/app.d.ts

@@ -0,0 +1,3 @@
+import { JSXInternal } from "preact/src/jsx";
+declare const App: () => JSXInternal.Element;
+export default App;

package/dist/src/view/cards/consentLegalCard.d.ts

@@ -0,0 +1,6 @@
+import { JSXInternal } from "preact/src/jsx";
+import { ConsentLegalCard as ConsentLegalCardType } from "../../types/card";
+import { BaseCardProps } from "./types";
+declare type Props = ConsentLegalCardType["props"] & BaseCardProps;
+declare const ConsentLegalCard: ({ className, message, next, properties, questionId, type, }: Props) => JSXInternal.Element;
+export default ConsentLegalCard;

package/dist/src/view/cards/index.d.ts

@@ -0,0 +1,10 @@
+export { default as ConsentLegalCard } from "./consentLegalCard";
+export { default as LikertCard } from "./likertCard";
+export { MultipleChoiceSingleSelectCard, MultipleChoiceMultipleSelectCard, } from "./multipleChoice";
+export { default as NPSCard } from "./npsCard";
+export { default as OpenTextCard } from "./openTextCard";
+export { default as RecordedTask } from "./recordedTask";
+export { default as TextUrlPromptCard } from "./textUrlPromptCard";
+export { default as ThanksCard } from "./thanksCard";
+export { default as VideoVoiceCard } from "./videoVoiceCard";
+export { default as UploadingCard } from "./uploadingCard";

package/dist/src/view/cards/likertCard/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./likertCard";

package/dist/src/view/cards/likertCard/likertCard.d.ts

@@ -0,0 +1,6 @@
+import { JSXInternal } from "preact/src/jsx";
+import { LikertCard as LikertCardType } from "../../../types/card";
+import { BaseCardProps } from "../types";
+declare type Props = LikertCardType["props"] & BaseCardProps;
+declare const LikertCard: ({ className, labels, message, next, properties, questionId, type, }: Props) => JSXInternal.Element;
+export default LikertCard;

package/dist/src/view/cards/likertCard/likertOption.d.ts

@@ -0,0 +1,16 @@
+import { ScaleLabelType } from "../../../types/card";
+interface Props {
+    activeValue: number;
+    border: string;
+    icon: string;
+    isPressed: boolean;
+    onSubmit: () => void;
+    range: number;
+    scaleLabelType: ScaleLabelType;
+    setActiveValue: (value: number) => void;
+    setIsPressed: (value: boolean) => void;
+    useMobileStyling: boolean;
+    value: number;
+}
+declare const LikertOption: ({ activeValue, border, icon, isPressed, onSubmit, range, scaleLabelType, setActiveValue, setIsPressed, useMobileStyling, value, }: Props) => import("preact").JSX.Element;
+export default LikertOption;

package/dist/src/view/cards/multipleChoice/baseMultiChoiceCard.d.ts

@@ -0,0 +1,15 @@
+import { JSXInternal } from "preact/src/jsx";
+import { CommonMultipleChoiceProps } from "../../../types/card";
+import { BaseCardProps } from "../types";
+declare type MultiOptionProps = CommonMultipleChoiceProps & BaseCardProps & ExtraProps;
+export interface OptionSelectedMap {
+    [id: string]: {
+        isSelected: boolean;
+        userText?: string;
+    };
+}
+interface ExtraProps {
+    onSubmit: (state: OptionSelectedMap) => void;
+}
+export declare const BaseMultiChoiceCard: ({ className, message, onSubmit, options, properties, questionId, type, }: MultiOptionProps) => JSXInternal.Element;
+export {};

package/dist/src/view/cards/multipleChoice/index.d.ts

@@ -0,0 +1,2 @@
+export { default as MultipleChoiceSingleSelectCard } from "./singleSelectCard";
+export { default as MultipleChoiceMultipleSelectCard } from "./multiSelectCard";

package/dist/src/view/cards/multipleChoice/multiSelectCard.d.ts

@@ -0,0 +1,5 @@
+import { MultipleChoiceMultiSelectCard as MultiSelectCardProps } from "../../../types/card";
+import { BaseCardProps } from "../types";
+declare type MultiSelectProps = MultiSelectCardProps["props"] & BaseCardProps;
+declare const MultiSelectCard: (props: MultiSelectProps) => import("preact").JSX.Element;
+export default MultiSelectCard;

package/dist/src/view/cards/multipleChoice/singleSelectCard.d.ts

@@ -0,0 +1,5 @@
+import { MultipleChoiceSingleSelectCard as SingleSelectCardProps } from "../../../types/card";
+import { BaseCardProps } from "../types";
+declare type SingleSelectProps = SingleSelectCardProps["props"] & BaseCardProps;
+declare const SingleSelectCard: (props: SingleSelectProps) => import("preact").JSX.Element;
+export default SingleSelectCard;

package/dist/src/view/cards/npsCard.d.ts

@@ -0,0 +1,8 @@
+import { JSXInternal } from "preact/src/jsx";
+import { NPSCard as NpsCardType } from "../../types/card";
+import { BaseCardProps } from "./types";
+declare type Props = {
+    props: NpsCardType["props"];
+} & BaseCardProps;
+declare const NPSCard: ({ className, props: { labels, message, properties }, next, questionId, type, }: Props) => JSXInternal.Element;
+export default NPSCard;

package/dist/src/view/cards/openTextCard.d.ts

@@ -0,0 +1,6 @@
+import { JSXInternal } from "preact/src/jsx";
+import { OpenTextCard as OpenTextCardType } from "../../types/card";
+import { BaseCardProps } from "./types";
+declare type Props = OpenTextCardType["props"] & BaseCardProps;
+declare const OpenTextCard: ({ className, message, next, properties, questionId, type, }: Props) => JSXInternal.Element;
+export default OpenTextCard;

package/dist/src/view/cards/recordedTask/actions.d.ts

@@ -0,0 +1,21 @@
+import { TaskStatus } from "../../../constants/sprigRecordingEvents";
+import { PermissionTaskPage, RecordedTaskPage } from "../../../types/card";
+import { RecordedTaskResponseType } from "./store";
+export declare function requestAVPermissions({ currentPage, pages, }: {
+    currentPage: PermissionTaskPage;
+    pages: RecordedTaskPage[];
+}): void;
+export declare function initializeRecordTask({ pages, userId: visitorId, responseGroupUid, surveyId, questionId, next, }: {
+    questionId: number;
+    surveyId: number;
+    responseGroupUid: UUID;
+    userId: UUID | null;
+    next: (response: RecordedTaskResponseType) => void;
+    pages: RecordedTaskPage[];
+}): RecordedTaskPage;
+export declare function completeTask({ status }: {
+    status: TaskStatus;
+}): void;
+export declare function nextPage({ pages }: {
+    pages: RecordedTaskPage[];
+}): void;

package/dist/src/view/cards/recordedTask/card.d.ts

@@ -0,0 +1,5 @@
+import { RecordedTaskCard as RecordedTaskCardType } from "../../../types/card";
+import { BaseCardProps } from "../types";
+declare type Props = RecordedTaskCardType["props"] & BaseCardProps;
+declare const RecordedTaskCard: ({ className, properties, next, questionId, }: Props) => import("preact").JSX.Element;
+export default RecordedTaskCard;

package/dist/src/view/cards/recordedTask/components.d.ts

@@ -0,0 +1,37 @@
+import { JSXInternal } from "preact/src/jsx";
+import { CompleteTaskPage, PermissionTaskPage, RecordedTaskCardProperties, RecordedTaskPage, ScreenTaskPage, StartTaskPage } from "../../../types/card";
+export declare const Button: ({ backgroundColor, classNames, content, handleClick, }: {
+    backgroundColor?: string | undefined;
+    classNames?: string | undefined;
+    content: string;
+    handleClick: JSXInternal.MouseEventHandler<HTMLButtonElement>;
+}) => JSXInternal.Element;
+export declare const StartTaskPageContent: ({ content, pages, }: {
+    content: StartTaskPage;
+    pages: RecordedTaskPage[];
+}) => JSXInternal.Element;
+export declare const CompleteTaskPageContent: ({ content, properties, }: {
+    content: CompleteTaskPage;
+    properties: RecordedTaskCardProperties;
+}) => JSXInternal.Element;
+export declare const ScreenPermissionPageContent: ({ content, pages, required, }: {
+    content: ScreenTaskPage;
+    required: boolean;
+    pages: RecordedTaskPage[];
+}) => JSXInternal.Element;
+export declare const AVPermissionRequestPageContent: ({ content, }: {
+    content: PermissionTaskPage;
+}) => JSXInternal.Element;
+export declare const AVPermissionFailurePageContent: ({ content, pages, required, }: {
+    content: PermissionTaskPage;
+    required: boolean;
+    pages: RecordedTaskPage[];
+}) => JSXInternal.Element | null;
+export declare const AVPermissionGrantedPageContent: ({ content, pages, required, }: {
+    content: PermissionTaskPage;
+    required: boolean;
+    pages: RecordedTaskPage[];
+}) => JSXInternal.Element;
+export declare const PageContent: ({ properties, }: {
+    properties: RecordedTaskCardProperties;
+}) => JSXInternal.Element | null;

package/dist/src/view/cards/recordedTask/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const enum AvStreamStatus {
+    RequestNeeded = 1,
+    TryAgain = 2,
+    Ready = 3
+}

package/dist/src/view/cards/recordedTask/helpers.d.ts

@@ -0,0 +1,6 @@
+import { RecordedTaskPage, PermissionTaskPage, ScreenTaskPage } from "../../../types/card";
+import { AvStreamStatus } from "./constants";
+export declare const isPermissionTaskPage: (page: RecordedTaskPage) => page is PermissionTaskPage;
+export declare const isScreenTaskPage: (page: RecordedTaskPage) => page is ScreenTaskPage;
+export declare const avStreamHasRequiredPermissions: (avstream: MediaStream, page: RecordedTaskPage) => boolean;
+export declare const getAvStreamRequestStatus: (avstream: MediaStream | null | undefined, page: RecordedTaskPage) => AvStreamStatus;

package/dist/src/view/cards/recordedTask/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./card";

package/dist/src/view/cards/recordedTask/store.d.ts

@@ -0,0 +1,24 @@
+import { MediaType, PassthroughData } from "../../../constants/sprigRecordingEvents";
+import { CardType, RecordedTaskPage, RecordedTaskPageType } from "../../../types/card";
+import { RecordedTaskResponseValueType } from "../types";
+export interface RecordedTaskResponseType {
+    questionId: number;
+    type: CardType;
+    value: RecordedTaskResponseValueType;
+}
+export interface RecordedTaskState {
+    avStream: MediaStream | null | undefined;
+    currentPage: RecordedTaskPage | null;
+    mediaRecordingUids: UUID[] | null;
+    nextQuestion: (response: RecordedTaskResponseType) => void;
+    passthroughData?: PassthroughData;
+    recordingMediaTypes?: MediaType[];
+    screenPermissionRequested: boolean;
+    type?: RecordedTaskPageType;
+}
+export interface RecordedTaskActions {
+    reset: () => void;
+    updatePage: (newState: Partial<RecordedTaskState>) => void;
+}
+export declare type RecordedTaskStore = RecordedTaskState & RecordedTaskActions;
+export declare const useRecordedTaskStore: import("zustand").UseBoundStore<import("zustand").StoreApi<RecordedTaskStore>>;

package/dist/src/view/cards/textUrlPromptCard.d.ts

@@ -0,0 +1,6 @@
+import { JSXInternal } from "preact/src/jsx";
+import { TextUrlPromptCard as TextUrlPromptCardType } from "../../types/card";
+import { BaseCardProps } from "./types";
+declare type Props = TextUrlPromptCardType["props"] & BaseCardProps;
+declare const TextUrlPromptCard: ({ className, message, next, properties, questionId, type, }: Props) => JSXInternal.Element;
+export default TextUrlPromptCard;

package/dist/src/view/cards/thanksCard.d.ts

@@ -0,0 +1,5 @@
+import { ThanksCard as ThanksCardType } from "../../types/card";
+import { BaseCardProps } from "./types";
+declare type Props = ThanksCardType["props"] & BaseCardProps;
+declare const ThanksCard: ({ className, questionId }: Props) => import("preact").JSX.Element;
+export default ThanksCard;

package/dist/src/view/cards/types.d.ts

@@ -0,0 +1,34 @@
+import { JSXInternal } from "preact/src/jsx";
+import { TaskStatus } from "../../constants/sprigRecordingEvents";
+import { CardType } from "../../types/card";
+export declare type MultiSelectValueType = Record<string, boolean>;
+export declare type SingleSelectValueType = Record<string, string>;
+export declare type MultiChoiceSecondaryValueType = Record<string, {
+    userText: string;
+}> | null;
+export interface RecordedTaskResponseValueType {
+    mediaRecordingUids?: string[] | null;
+    taskDurationMillisecond?: number;
+    taskStatus: TaskStatus;
+}
+export declare type SelectedValue = RecordedTaskResponseValueType | MultiSelectValueType | SingleSelectValueType | {
+    mediaRecordingUid: UUID | null;
+} | {
+    submitted: boolean;
+    name?: string;
+} | {
+    skipped: boolean;
+} | string | string[] | number | null | undefined;
+export declare type NextFnType = (options: {
+    value: SelectedValue;
+    secondaryValue?: MultiChoiceSecondaryValueType;
+    questionId: number;
+    type: CardType;
+}) => void;
+export interface BaseCardProps {
+    className: string;
+    next: NextFnType;
+    questionId: number;
+    type: CardType;
+}
+export declare type TouchKeyEvents = Pick<JSXInternal.DOMAttributes<HTMLDivElement>, "onClick" | "onKeyPress" | "onMouseDown" | "onMouseLeave" | "onMouseOver" | "onMouseUp" | "onTouchCancel" | "onTouchMove" | "onTouchStart" | "onTouchEnd">;

package/dist/src/view/cards/uploadingCard.d.ts

@@ -0,0 +1,5 @@
+import { UploadingCard as UploadingCardType } from "../../types/card";
+import { BaseCardProps } from "./types";
+declare type Props = UploadingCardType["props"] & BaseCardProps;
+declare const UploadingCard: ({ className }: Props) => import("preact").JSX.Element;
+export default UploadingCard;

package/dist/src/view/cards/videoVoiceCard.d.ts

@@ -0,0 +1,6 @@
+import { JSXInternal } from "preact/src/jsx";
+import { VideoVoiceCard as VideoVoiceCardType } from "../../types/card";
+import { BaseCardProps } from "./types";
+declare type Props = VideoVoiceCardType["props"] & BaseCardProps;
+declare const VideoVoiceCard: ({ className, message, next, properties, questionId, type, }: Props) => JSXInternal.Element;
+export default VideoVoiceCard;

package/dist/src/view/components/header.d.ts

@@ -0,0 +1,8 @@
+interface Props {
+    message?: string;
+    properties?: {
+        captionText?: string;
+    };
+}
+declare const Header: ({ message, properties }: Props) => import("preact").JSX.Element;
+export default Header;

package/dist/src/view/components/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Header } from "./header";
+export { default as MobileEmbedView } from "./mobileEmbedView";
+export { default as Select } from "./select";

package/dist/src/view/components/mobileEmbedView.d.ts

@@ -0,0 +1,19 @@
+import { JSXInternal } from "preact/src/jsx";
+import { ConceptUrl } from "../../types/card";
+import { Platform } from "../../types/config";
+declare const MobileEmbedView: ({ defaultBody, embeddedType, handleClickEmbedButton, hasViewedEmbed, platform, properties, useDesktopPrototype, }: {
+    defaultBody: () => JSXInternal.Element;
+    embeddedType?: "prototype" | "pdf" | undefined;
+    handleClickEmbedButton: (name: string) => void;
+    hasViewedEmbed: boolean;
+    platform?: Platform | undefined;
+    properties?: {
+        conceptUrl: ConceptUrl;
+        consentDocument?: {
+            url: string;
+        } | undefined;
+        viewDocumentText?: string | undefined;
+    } | undefined;
+    useDesktopPrototype?: boolean | undefined;
+}) => JSXInternal.Element;
+export default MobileEmbedView;

package/dist/src/view/components/select.d.ts

@@ -0,0 +1,25 @@
+import { JSXInternal } from "preact/src/jsx";
+/**
+ * Select component
+ */
+declare const Select: ({ border, label, isSelected, value, text, id, isRadio, useMobileStyling, error, allowTextEntry, promptText, onUserInputChanged, }: {
+    border: string;
+    label: string;
+    isSelected: boolean;
+    value?: string | undefined;
+    text?: string | undefined;
+    index: number;
+    id?: string | undefined;
+    isRadio: boolean;
+    useMobileStyling: boolean;
+    error: boolean;
+    allowTextEntry: boolean;
+    promptText?: string | undefined;
+    onUserInputChanged: (args: {
+        id: string;
+        selected: boolean;
+        value?: string | undefined;
+        userText?: string | undefined;
+    }) => void;
+}) => JSXInternal.Element;
+export default Select;

package/dist/src/view/footer.d.ts

@@ -0,0 +1,2 @@
+declare const Footer: () => import("preact").JSX.Element;
+export default Footer;

package/dist/src/view/helpers/card.d.ts

@@ -0,0 +1,6 @@
+export declare const getButtonText: (properties?: {
+    buttonText?: string;
+}) => string;
+export declare const getSkipButtonText: (properties?: {
+    skipButtonText?: string;
+}) => string;

package/dist/src/view/helpers/getAttributedUrl.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Set visitor attributes and returns url with substitutions made
+ * @param rawUrl - url possibly containing tags like {{user_id}}
+ * @param visitorAttributes - attributes to substitute in the url
+ */
+export declare const getAttributedUrl: (rawUrl?: string | undefined, visitorAttributes?: Record<string, string>) => string | undefined;

package/dist/src/view/helpers/skipLogicHelpers.d.ts

@@ -0,0 +1,34 @@
+import { AppCard, CardType } from "../../types/card";
+import { AppConfig } from "../../types/config";
+import { SelectedValue } from "../cards/types";
+/**
+ * @param response response object submitted
+ * @param type type of the question
+ * @param routingValue value used to determine routing from skip logic
+ * @returns
+ */
+export declare const getHasValidAnswer: (response: {
+    value: unknown;
+}, type: CardType, routingValue: {
+    taskStatus: unknown;
+} | null | undefined) => boolean;
+/**
+ * @param cards - Array of all cards
+ * @param index - Current index in the cards
+ * @param selectedValue - Value that was selected which determines routing options
+ * @param hasEndCard - is the thanks card configured
+ * @returns optional next index value, if next index is null, survey ends immediately
+ */
+export declare const getNextCardIndex: ({ cards, index, hasEndCard, selectedValue, hasValidAnswer, uploadProgress, }: {
+    cards: AppCard[];
+    hasEndCard: boolean;
+    hasValidAnswer?: boolean | undefined;
+    index: number;
+    selectedValue: SelectedValue;
+    uploadProgress?: Record<string, {
+        isComplete: boolean;
+        isSubmitted: boolean;
+        progressPct: number;
+    }> | undefined;
+}) => number | null;
+export declare const getMaxRemainingCards: (cards: AppCard[], index: number) => number;

package/dist/src/view/hooks/index.d.ts

@@ -0,0 +1 @@
+export { useAutoSize } from "./useAutoSize";

package/dist/src/view/hooks/useAutoSize.d.ts

@@ -0,0 +1,2 @@
+import { Ref } from "preact/hooks";
+export declare const useAutoSize: (textAreaRef: Ref<HTMLTextAreaElement>, sizeUpdate: () => void) => () => void;

package/dist/src/view/logo.d.ts

@@ -0,0 +1,5 @@
+/**
+ * UserLeap logo component
+ */
+declare const Logo: () => import("preact").JSX.Element;
+export default Logo;

package/dist/src/view/recorder/recorder.d.ts

@@ -0,0 +1,2 @@
+declare const instance: any;
+export default instance;

package/dist/src/view/store.d.ts

@@ -0,0 +1,2 @@
+import { AppConfig } from "../types/config";
+export declare const useConfig: import("zustand").UseBoundStore<import("zustand").StoreApi<AppConfig>>;

package/dist/src/view/view.d.ts

@@ -0,0 +1,6 @@
+import { Config } from "../types/config";
+declare function configure(config: Config): void;
+declare const _default: {
+    configure: typeof configure;
+};
+export default _default;