@appcues/web-sdk 7.22.2 → 7.24.0

package/build/sagas/action-sagas.d.ts

@@ -0,0 +1,20 @@
+export function runAction({ payload: action }: {
+    payload: any;
+}): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any> | import("redux-saga/effects").RaceEffect, void, unknown>;
+export function resumeAction({ payload: { action, status } }: {
+    payload: {
+        action: any;
+        status: any;
+    };
+}): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any>, void, string>;
+export function checkForNavigationFirst(url: any, cb: any): Generator<import("redux-saga/effects").CallEffect, void, unknown>;
+export function runChecklistAction({ payload: { action, checklistId, itemId, actionIndex }, }: {
+    payload: {
+        action: any;
+        checklistId: any;
+        itemId: any;
+        actionIndex: any;
+    };
+}): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any> | import("redux-saga/effects").RaceEffect, void, unknown>;
+export default function saga(): Generator<import("redux-saga/effects").ForkEffect[], void, unknown>;
+//# sourceMappingURL=action-sagas.d.ts.map

package/build/sagas/action-sagas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-sagas.d.ts","sourceRoot":"","sources":["../../src/scripts/sagas/action-sagas.js"],"names":[],"mappings":"AAyBA;;0MAsEC;AAED;;;;;+JAmFC;AAED,8HAWC;AAED;;;;;;;0MA0FC;AAED,oGAUC"}

package/build/sagas/annotations-sagas.d.ts

@@ -0,0 +1,55 @@
+export function hideAndRemoveActiveAnnotations({ payload: annotationIds }: {
+    payload: any;
+}): Generator<import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any>, void, unknown>;
+export function storeErrors(errors: any): Generator<import("redux-saga/effects").CallEffect, void, unknown>;
+/**
+ * Helper saga that checks the position detail objects for errors and sends
+ * off step_child_error events when there are.
+ *
+ * @param {Object} positions Mapping of annotation ID to error.
+ */
+export function reportAnnotationErrors(errors: any, stepId: any, eventChannel: any): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any>, void, unknown>;
+export function clearErrors(errors: any): Generator<import("redux-saga/effects").CallEffect, void, unknown>;
+/**
+ * Helper saga that checks if we have non-error annotation position details with
+ * an `errorReported` property equal to true. If so, it considers this a
+ * recovered annotation and sends a `step_child_recovered` event.
+ *
+ * @param {Object} positions Mapping of annotation ID to position details object.
+ */
+export function reportAnnotationRecoveries(positions: Object): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any>, void, unknown>;
+export function calculatePositions(): Generator<any, void, any>;
+/**
+ * Helper saga for updating the status of 'annotation' content. We only want to
+ * dispatch the SET_ANNOTATIONS_READY action when the current status isn't
+ * READY or SHOWING.
+ */
+export function updateAnnotationsStatusReady(): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").PutEffect<any>, void, unknown>;
+export function clearExpiredErrors(): Generator<import("redux-saga/effects").CallEffect, void, unknown>;
+export function scrollToAnnotation(annotationId: any): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect | import("redux-saga/effects").TakeEffect, void, any>;
+/**
+ * This should be called when a CLEANUP_STEP action comes in. It will perform
+ * any cleanup that should occur for "annotation" content types when they're
+ * being closed.
+ *
+ * @param {object} action  The CLEANUP_STEP action. The `payload` of the
+ *                         action is the content/step object that cleanup should
+ *                         be performed for.
+ */
+export function cleanup({ payload: step }: object): Generator<import("redux-saga/effects").PutEffect<any>, void, unknown>;
+export function loadStoredErrors(): Generator<import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any>, void, unknown>;
+export function setScrollingFlag({ payload }: {
+    payload: any;
+}): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<{
+    type: string;
+    payload: any;
+}>, void, any>;
+export default function saga(): Generator<import("redux-saga/effects").ForkEffect[], void, unknown>;
+export const _testExports: {
+    getStoredAnnotationsErrors: typeof getStoredAnnotationsErrors;
+    performScroll: typeof performScroll;
+} | null;
+declare function getStoredAnnotationsErrors(): Generator<import("redux-saga/effects").CallEffect, any, unknown>;
+declare function performScroll(element: any, offsetFromBottomPercentage: any, parentEls: any, scrollableParentPositions: any): Generator<import("redux-saga/effects").GenericRaceEffect<import("redux-saga/effects").CallEffect | import("redux-saga/effects").CallEffect[]>, any, unknown>;
+export {};
+//# sourceMappingURL=annotations-sagas.d.ts.map

package/build/sagas/annotations-sagas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotations-sagas.d.ts","sourceRoot":"","sources":["../../src/scripts/sagas/annotations-sagas.js"],"names":[],"mappings":"AAgMA;;oHAIC;AAED,4GASC;AAED;;;;;GAKG;AACH,iPAqCC;AAED,4GAcC;AAED;;;;;;GAMG;AACH,sDAFW,MAAM,+JAsChB;AAED,gEA4HC;AAED;;;;GAIG;AACH,kKAiBC;AAED,wGAoBC;AAED,2MA6DC;AAED;;;;;;;;GAQG;AACH,2CAJW,MAAM,yEAYhB;AAED,oJAKC;AAED;;;;;eAqBC;AAED,oGA2BC;AAQD;;;SAMW;AAvkBX,gHASC;AAmFD,4RAyCC"}

package/build/sagas/checklist-sagas.d.ts

@@ -0,0 +1,18 @@
+export function fetchContentStyle(contentStyleId: any): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any>, void, unknown>;
+export function prepareChecklist(checklist: any): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any> | import("redux-saga/effects").TakeEffect, void, unknown>;
+export function runChecklist({ payload: checklist }: {
+    payload: any;
+}): Generator<import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any>, void, unknown>;
+export function showChecklistFirstTime({ payload: checklist }: {
+    payload: any;
+}): Generator<import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any>, void, unknown>;
+export function sendChecklistShownEvent(action: any): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").PutEffect<any>, void, unknown>;
+export function dismissChecklist(action: any): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").PutEffect<any>, void, unknown>;
+export function clearShow(): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").PutEffect<any>, void, {
+    userId: any;
+}>;
+export function runChecklistItem(action: any): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any> | import("redux-saga/effects").TakeEffect, void, any>;
+export function hideChecklists(): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").AllEffect, void, unknown>;
+export function unhideChecklists(): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").PutEffect<any> | import("redux-saga/effects").AllEffect, void, unknown>;
+export default function saga(): Generator<import("redux-saga/effects").ForkEffect[], void, unknown>;
+//# sourceMappingURL=checklist-sagas.d.ts.map

package/build/sagas/checklist-sagas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checklist-sagas.d.ts","sourceRoot":"","sources":["../../src/scripts/sagas/checklist-sagas.js"],"names":[],"mappings":"AAgCA,oNAcC;AAED,wPAoBC;AAED;;oHA8BC;AAED;;oHASC;AAED,wKAMC;AAED,iKAeC;AAED;;GAKC;AAED,iPA4DC;AAED,+IASC;AAED,+LAuBC;AAED,oGAmCC"}

package/build/sagas/collision-mode-sagas.d.ts

@@ -0,0 +1,9 @@
+export function resolveCollisionModeRaceCondition(): Generator<import("redux-saga/effects").CallEffect | import("redux-saga/effects").TakeEffect | import("redux-saga/effects").RaceEffect, void, unknown>;
+export function toggleChecklist({ payload: { checklistId, forceClose } }: {
+    payload: {
+        checklistId: any;
+        forceClose: any;
+    };
+}): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any>, void, unknown>;
+export default function saga(): Generator<import("redux-saga/effects").ForkEffect[], void, unknown>;
+//# sourceMappingURL=collision-mode-sagas.d.ts.map

package/build/sagas/collision-mode-sagas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collision-mode-sagas.d.ts","sourceRoot":"","sources":["../../src/scripts/sagas/collision-mode-sagas.js"],"names":[],"mappings":"AA+FA,2MAiBC;AAED;;;;;gKAiBC;AA2GD,oGAYC"}

package/build/sagas/common-sagas.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Validates a list of steps' HTML, dispatching WILL_SHOW_CONTENT error actions
+ * for each that fails. Returns true or false, indicating whether all content
+ * was valid or not.
+ *
+ * @param {Array} steps List of step children to validate.
+ *
+ * @yield {boolean} Indicates whether all content is valid or not.
+ */
+export function validateContents(steps: any[]): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect, boolean, any>;
+export function setNextContentIdCookie({ payload: { nextContentId, campaignId, tacticId }, }: {
+    payload: {
+        nextContentId: any;
+        campaignId?: null | undefined;
+        tacticId?: null | undefined;
+    };
+}): Generator<import("redux-saga/effects").CallEffect, void, unknown>;
+//# sourceMappingURL=common-sagas.d.ts.map

package/build/sagas/common-sagas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common-sagas.d.ts","sourceRoot":"","sources":["../../src/scripts/sagas/common-sagas.js"],"names":[],"mappings":"AAyDA;;;;;;;;GAQG;AACH,6JAsCC;AAED;;;;;;sEAqBC"}

package/build/sagas/conditions-sagas.d.ts

@@ -0,0 +1,72 @@
+/**
+ * A condition saga that will wait for one of the specified `selectors` to become
+ * available in the current view.
+ *
+ * @param {Array} selectors List of CSS selectors to look for.
+ */
+export function waitForOneElement(selectors: any[]): Generator<import("redux-saga/effects").ForkEffect | import("redux-saga/effects").CallEffect, {
+    result: any;
+    task: null;
+    failures: null;
+}, {
+    result: any;
+    failures: any;
+}>;
+export function waitForEvent(event: any, selector: any, cond: any): Generator<import("redux-saga/effects").ForkEffect | import("redux-saga/effects").CallEffect | import("redux-saga/effects").CancelEffect | import("redux-saga/effects").RaceEffect, {
+    result: boolean;
+}, any>;
+/**
+ * This saga will evaluate the specified condition.
+ *
+ * @param {object} condition An object with a `type` and `params` that define
+ *                           a set of conditions to be met.
+ *
+ * @return {object} A "condition result" object. This object has two fields:
+ *                    - `result`: A boolean indicating whether or not we
+ *                        could immediately verify the condition was met.
+ *                    - `task`: A redux-saga Task object describing a child
+ *                        process that is asynchronously waiting for the
+ *                        condition to be met. This task should resolve with a
+ *                        true value once the condition is met, or false if the
+ *                        condition can never be met. This is null if the
+ *                        `result` is true.
+ */
+export function checkCondition(condition: object): object;
+/**
+ * Helper saga for evaluating a condition and calling the passed function or
+ * generator after the condition is met.
+ *
+ * @param {object}   cond  A condition object.
+ * @param {Function} fn    The function or generator to run.
+ */
+export function runAfterConditionMet(cond: object, fn: Function, ...args: any[]): Generator<import("redux-saga/effects").JoinEffect | import("redux-saga/effects").ForkEffect | import("redux-saga/effects").CallEffect | import("redux-saga/effects").CancelEffect | import("redux-saga/effects").CancelledEffect, void, {
+    result: any;
+    task: any;
+}>;
+export const _testExports: {
+    checkForElements: typeof checkForElements;
+    periodicallyCheckForElements: typeof periodicallyCheckForElements;
+    startEventListener: typeof startEventListener;
+    waitForListener: typeof waitForListener;
+} | null;
+declare function checkForElements(selectors: any): Generator<any, {
+    result: boolean;
+    failures: any;
+} | {
+    result: boolean;
+    failures?: undefined;
+}, unknown>;
+declare function periodicallyCheckForElements(selectors: any): Generator<import("redux-saga/effects").CallEffect, {
+    result: boolean;
+}, unknown>;
+declare function startEventListener(el: any, event: any, cond?: null): Generator<import("redux-saga/effects").CallEffect | import("redux-saga/effects").CancelledEffect, any, any>;
+/**
+ * Creates a race between a listener of a click or a keydown event.
+ *
+ * @param {object} condition An object with a `type` and `params` that define
+ *                           a set of conditions to be met.
+ * @returns the first task (listener) that finished.
+ */
+declare function waitForListener(condition: object): Generator<import("redux-saga/effects").GenericRaceEffect<any>, any, unknown>;
+export {};
+//# sourceMappingURL=conditions-sagas.d.ts.map

package/build/sagas/conditions-sagas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditions-sagas.d.ts","sourceRoot":"","sources":["../../src/scripts/sagas/conditions-sagas.js"],"names":[],"mappings":"AAoEA;;;;;GAKG;AACH;;;;;;;GAeC;AAED;;QA0CC;AAuBD;;;;;;;;;;;;;;;GAeG;AACH,0CAbW,MAAM,GAGL,MAAM,CAwBjB;AAED;;;;;;GAMG;AACH,2CAHW,MAAM;;;GAsBhB;AAQD;;;;;SAQW;AAlNX;;;;;;YAWC;AAGD;;YAOC;AAED,mLAmBC;AAyED;;;;;;GAMG;AAEH,4CALW,MAAM,gFAgBhB"}

package/build/sagas/debugger-sagas.d.ts

@@ -0,0 +1,7 @@
+export function pollURL(): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any>, void, unknown>;
+export function updateTrackedPage(action: any): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any>, void, unknown>;
+export function trackContentError(action: any): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").PutEffect<any>, void, any>;
+export function trackChildError(action: any): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").PutEffect<any>, void, unknown>;
+export function runDebugger(): Generator<Object, void, unknown>;
+export default function saga(): Generator<import("redux-saga/effects").ForkEffect, void, unknown>;
+//# sourceMappingURL=debugger-sagas.d.ts.map

package/build/sagas/debugger-sagas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debugger-sagas.d.ts","sourceRoot":"","sources":["../../src/scripts/sagas/debugger-sagas.js"],"names":[],"mappings":"AAuBA,uLAaC;AAED,4MAkBC;AAED,8JAUC;AAED,gKAkBC;AAED,gEAmDC;AAED,kGAEC"}

package/build/sagas/experiences-sagas.d.ts

@@ -0,0 +1,5 @@
+export function getAppcuesInstance(): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").PutEffect<any> | import("redux-saga/effects").TakeEffect, any, unknown>;
+export function stopOverlayExperiences(): Generator<import("redux-saga/effects").CallEffect | import("redux-saga/effects").AllEffect, void, unknown>;
+export default function saga(): Generator<import("redux-saga/effects").ForkEffect[], void, unknown>;
+export const OVERLAY_EXPERIENCE_TYPES: Set<string>;
+//# sourceMappingURL=experiences-sagas.d.ts.map

package/build/sagas/experiences-sagas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"experiences-sagas.d.ts","sourceRoot":"","sources":["../../src/scripts/sagas/experiences-sagas.js"],"names":[],"mappings":"AAuDA,iMA4BC;AA6HD,qJAWC;AAwFD,oGAoCC;AA5ID,mDAGG"}

package/build/sagas/experiments-sagas.d.ts

@@ -0,0 +1,14 @@
+export function getExperimentWithId(id: any, type: any): Generator<import("redux-saga/effects").SelectEffect, any, unknown>;
+export function isControlExperiment(id: any, type: any): Generator<import("redux-saga/effects").CallEffect, boolean, unknown>;
+export function experimentStarted({ payload: { id, type } }: {
+    payload: {
+        id: any;
+        type: any;
+    };
+}): Generator<import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any>, void, unknown>;
+export default function saga(): Generator<import("redux-saga/effects").ForkEffect[], void, unknown>;
+export namespace ExperimentType {
+    let EXPERIENCES: string;
+    let FLOWS: string;
+}
+//# sourceMappingURL=experiments-sagas.d.ts.map

package/build/sagas/experiments-sagas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"experiments-sagas.d.ts","sourceRoot":"","sources":["../../src/scripts/sagas/experiments-sagas.js"],"names":[],"mappings":"AAaA,4HAGC;AAED,8HAGC;AAGD;;;;;oHAYC;AAED,oGAIC"}

package/build/sagas/flow-sagas.d.ts

@@ -0,0 +1,64 @@
+export function waitForPendingEventsToClear(flowId: any): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").TakeEffect, void, unknown>;
+/**
+ * This saga will start the process of trying to show a flow. If the flow's
+ * starting conditions are synchronously met, then it starts the flow
+ * immediately and returns true. If the starting conditions aren't met
+ * synchronously, then it will return false and will wait for the conditions to
+ * be met or for another flow to meet it's starting conditions. If a
+ * CANCEL_ATTEMPTS action is dispatched then the saga that is waiting for the
+ * conditions to be met will be cancelled.
+ *
+ * @param {object}  flow        The object representing the flow to attempt.
+ * @param {string}  stepId      An optional stepId to begin with. We default to
+ *                              starting with the first step.
+ * @param {string}  url         The URL at which this flow is valid.
+ * @param {boolean} cancellable If CANCEL_ATTEMPTS actions should cancel this
+ *                              attempt. Defaults to true.
+ *
+ * @return {boolean} True if attempt succeeds synchronously; false otherwise.
+ */
+export function attemptFlow(flow: object, stepId: string, url: string, requestId: any, cancellable?: boolean): boolean;
+export function resumeFlow(flow: any, stepId: any, url: any, status: any): Generator<import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any>, void, unknown>;
+export function runFlow(rootAction: any): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any> | import("redux-saga/effects").TakeEffect | import("redux-saga/effects").RaceEffect, void, {
+    payload: any;
+}>;
+export function readFlowState(): Generator<import("redux-saga/effects").CallEffect, any, string>;
+export function writeFlowState(state: any): Generator<import("redux-saga/effects").CallEffect, void, unknown>;
+/**
+ * A helper saga for dealing with step errors by dispatching a SHOWING_CONTENT
+ * error action and also reporting a STEP_ERRORED lifecycle event to the proper
+ * event channel.
+ *
+ * @param {Error} error The error to report.
+ * @param {String} details  Any specific details to include with the error.
+ */
+export function handleStepError(error: Error, details: string): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").PutEffect<any>, void, unknown>;
+export function runStep(rootAction: any): Generator<import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any>, void, string>;
+export function removeStep(flow: any, step: any): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any>, void, unknown>;
+export default function saga(): Generator<import("redux-saga/effects").ForkEffect[], void, unknown>;
+export const _testExports: {
+    waitForFlowToBeReady: typeof waitForFlowToBeReady;
+    asyncRace: typeof asyncRace;
+    sendEvent: typeof sendEvent;
+    closeEventChannel: typeof closeEventChannel;
+    waitForPendingEventsToClear: typeof waitForPendingEventsToClear;
+    startEventChannel: typeof startEventChannel;
+    stopEventChannelAfterFlowCancellation: typeof stopEventChannelAfterFlowCancellation;
+} | null;
+declare function waitForFlowToBeReady(conditionTask: any, eventChannel: any, flowId: any, stepId: any, url: any, campaignId: any, tacticId: any): Generator<import("redux-saga/effects").JoinEffect | import("redux-saga/effects").PutEffect<any> | import("redux-saga/effects").CancelEffect | import("redux-saga/effects").CancelledEffect | import("redux-saga/effects").ChannelPutEffect<END>, void, unknown>;
+import { asyncRace } from 'sagas/saga-utils';
+/**
+ * A saga for sending flow lifecycle events in a consistent manner. This is
+ * triggered by a SEND_LIFECYCLE_EVENT action.
+ */
+declare function sendEvent({ payload }: {
+    payload: any;
+}): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").ChannelPutEffect<any>, void, any>;
+declare function closeEventChannel({ payload: chan }: {
+    payload: any;
+}): Generator<import("redux-saga/effects").CallEffect, void, unknown>;
+declare function startEventChannel(flow: any, requestId: any): Generator<import("redux-saga/effects").ForkEffect | import("redux-saga/effects").CallEffect, any, unknown>;
+declare function stopEventChannelAfterFlowCancellation(flowId: any, task: any): Generator<import("redux-saga/effects").TakeEffect | import("redux-saga/effects").CancelEffect, void, unknown>;
+import { END } from 'redux-saga';
+export {};
+//# sourceMappingURL=flow-sagas.d.ts.map

package/build/sagas/flow-sagas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-sagas.d.ts","sourceRoot":"","sources":["../../src/scripts/sagas/flow-sagas.js"],"names":[],"mappings":"AA4LA,wKAMC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,kCATW,MAAM,UACN,MAAM,OAEN,MAAM,gCACN,OAAO,GAGN,OAAO,CAmHlB;AAED,2LAeC;AAED;;GA2EC;AAGD,iGAMC;AAED,8GAOC;AAED;;;;;;;GAOG;AACH,uCAHW,KAAK,sIAef;AAED,yJA+CC;AAED,8MAoBC;AAgCD,oGAOC;AAQD;;;;;;;;SAWW;AAjbX,kZA2BC;0BAvKM,kBAAkB;AAqgBzB;;;GAGG;AACH;;yHAMC;AAgBD;;sEAEC;AAvdD,0KAgBC;AAzBD,8LAOC;oBA7EqC,YAAY"}

package/build/sagas/handle-flow-lifecycle-events.d.ts

@@ -0,0 +1,12 @@
+export default function handleFlowLifecycleEvents(flow: any, eventChannel: any, requestId: any): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").ForkEffect | import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any> | import("redux-saga/effects").TakeEffect | import("redux-saga/effects").ChannelPutEffect<{
+    type: any;
+    params: any;
+} | import("redux-saga").END>, void, any>;
+export const _testExports: {
+    dispatchSendLifecycleEvent: typeof dispatchSendLifecycleEvent;
+    runUIConditions: typeof runUIConditions;
+} | null;
+declare function dispatchSendLifecycleEvent(...lifecycleEvents: any[]): Generator<import("redux-saga/effects").PutEffect<any>, void, unknown>;
+declare function runUIConditions(flow: any, step: any, child: any): Generator<import("redux-saga/effects").TakeEffect | import("redux-saga/effects").RaceEffect, void, unknown>;
+export {};
+//# sourceMappingURL=handle-flow-lifecycle-events.d.ts.map

package/build/sagas/handle-flow-lifecycle-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle-flow-lifecycle-events.d.ts","sourceRoot":"","sources":["../../src/scripts/sagas/handle-flow-lifecycle-events.js"],"names":[],"mappings":"AAmJA;;;0CAscC;AAQD;;;SAMW;AA5gBX,8IAIC;AAED,gLAyCC"}

package/build/sagas/handle-messages.d.ts

@@ -0,0 +1,3 @@
+export function handleChecklistMessage(message: any): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any> | import("redux-saga/effects").TakeEffect, void, unknown>;
+export default function saga(): Generator<import("redux-saga/effects").ForkEffect, void, unknown>;
+//# sourceMappingURL=handle-messages.d.ts.map

package/build/sagas/handle-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle-messages.d.ts","sourceRoot":"","sources":["../../src/scripts/sagas/handle-messages.js"],"names":[],"mappings":"AA6CA,4PAkOC;AAED,kGAkNC"}

package/build/sagas/hotspots-sagas.d.ts

@@ -0,0 +1,30 @@
+export function startHotspots(): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any>, void, unknown>;
+export function handlePositionUpdates({ payload: positions }: {
+    payload: any;
+}): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any>, void, unknown>;
+/**
+ * Saga for advancing to the next tooltip, or ending the sequence if there's no
+ * next tooltip. Kicked off by an ADVANCE_STEP_CHILD action that has a
+ * `contentType` matching ContentType.SEQUENTIAL_HOTSPOTS.
+ *
+ * @param {Object} action        An ADVANCE_STEP_CHILD action.
+ */
+export function advanceTooltip(action: Object): Generator<import("redux-saga/effects").ForkEffect | import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any>, void, string>;
+export function openStepChild({ stepId, currentStepChildId, nextStepChildId, }: {
+    stepId: any;
+    currentStepChildId: any;
+    nextStepChildId: any;
+}): Generator<import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any>, void, unknown>;
+export function runPrevTooltip(action: any): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect, void, unknown>;
+export function runGoToStep(action: any): Generator<any, void, unknown>;
+export default function saga(): Generator<import("redux-saga/effects").ForkEffect[], void, unknown>;
+export const _testExports: {
+    waitForLast: typeof waitForLast;
+    clearActionDrivenStateValue: typeof clearActionDrivenStateValue;
+} | null;
+declare function waitForLast({ payload }: {
+    payload: any;
+}): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").PutEffect<any> | import("redux-saga/effects").RaceEffect, void, unknown>;
+declare function clearActionDrivenStateValue(): Generator<import("redux-saga/effects").CallEffect, void, string>;
+export {};
+//# sourceMappingURL=hotspots-sagas.d.ts.map

package/build/sagas/hotspots-sagas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hotspots-sagas.d.ts","sourceRoot":"","sources":["../../src/scripts/sagas/hotspots-sagas.js"],"names":[],"mappings":"AA4DA,6LA2BC;AAED;;gKA2DC;AA4CD;;;;;;GAMG;AACH,uCAFW,MAAM,4JAuEhB;AAED;;;;oHAqCC;AAED,2JAwBC;AAED,wEA2BC;AAED,oGAqBC;AAQD;;;SAMW;AAhPX;;gKA+BC;AAxCD,iHAOC"}

package/build/sagas/knowledge-base-sagas.d.ts

@@ -0,0 +1,2 @@
+export default function saga(): Generator<Object[], void, unknown>;
+//# sourceMappingURL=knowledge-base-sagas.d.ts.map

package/build/sagas/knowledge-base-sagas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-base-sagas.d.ts","sourceRoot":"","sources":["../../src/scripts/sagas/knowledge-base-sagas.js"],"names":[],"mappings":"AA+FA,mEAcC"}

package/build/sagas/modal-sagas.d.ts

@@ -0,0 +1,3 @@
+export function startModal(): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect | import("redux-saga/effects").PutEffect<any>, void, unknown>;
+export default function saga(): Generator<import("redux-saga/effects").ForkEffect, void, unknown>;
+//# sourceMappingURL=modal-sagas.d.ts.map

package/build/sagas/modal-sagas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modal-sagas.d.ts","sourceRoot":"","sources":["../../src/scripts/sagas/modal-sagas.js"],"names":[],"mappings":"AASA,0LAaC;AAED,kGAEC"}

package/build/sagas/open-builder-sagas.d.ts

@@ -0,0 +1,5 @@
+export function handleOpenBuilderEvent({ payload }: {
+    payload: any;
+}): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").PutEffect<any>, void, unknown>;
+export default function saga(): Generator<import("redux-saga/effects").ForkEffect[], void, unknown>;
+//# sourceMappingURL=open-builder-sagas.d.ts.map

package/build/sagas/open-builder-sagas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open-builder-sagas.d.ts","sourceRoot":"","sources":["../../src/scripts/sagas/open-builder-sagas.js"],"names":[],"mappings":"AAMA;;sHAOC;AAED,oGAQC"}

package/build/sagas/saga-utils.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Wraps a redux-saga `spawn` side effect, such that any uncaught errors in the
+ * saga get reported by our `state.reporter` function.
+ *
+ * Usage is just like spawn or fork:
+ *     `yield spawnWrapped(saga, 'test');`
+ *
+ * @param  {GeneratorFunction} saga The saga/generator function.
+ * @param  {...[Any]} args Arbitrary number of argument to pass into the saga.
+ *
+ * @return {Object} A redux-saga `call` side effect that wraps the `spawn` of
+ *                  the specified saga.
+ */
+export function spawnWrapped(saga: GeneratorFunction, ...args: [Any][]): Object;
+export function getStepScopedTaskName(taskName: any, stepId: any): string;
+/**
+ * Takes every action with the specified `pattern` and `spawn`s a wrapped
+ * version of the specified saga, such that any uncaught errors in the saga get
+ * reported by our `state.reporter` function. Also stores the task descriptor
+ * under the specified `taskName` for later cancellation via a `STOP_TASKS`
+ * action.
+ *
+ * Usage is similar to takeEvery:
+ *     `yield fork(takeEveryWrappedCancellable, 'PATTERN', saga, 'TASK_NAME', 'test');`
+ *
+ * @param  {String} pattern The pattern to `take` on.
+ * @param  {GeneratorFunction} saga The saga to trigger.
+ * @param  {String} taskName The key under which to store the task descriptor.
+ *                           See the `TaskNames` object in the constants module.
+ * @param  {...[Any]} args Arbitrary number of arguments to pass into the saga.
+ */
+export function takeEveryWrappedCancellable(pattern: string, saga: GeneratorFunction, taskName: string, ...args: [Any][]): Generator<Object, void, unknown>;
+/**
+ * Takes every action with the specified `pattern` and `spawn`s a wrapped
+ * version of the specified saga, such that any uncaught errors in the saga get
+ * reported by our `state.reporter` function.
+ *
+ * Usage is just like takeEvery:
+ *     `yield fork(takeEveryWrapped, 'PATTERN', saga, 'test');`
+ *
+ * @param  {String} pattern The pattern to `take` on.
+ * @param  {GeneratorFunction} saga The saga to trigger.
+ * @param  {...[Any]} args Arbitrary number of arguments to pass into the saga.
+ */
+export function takeEveryWrapped(pattern: string, saga: GeneratorFunction, ...args: [Any][]): Generator<Object, void, unknown>;
+/**
+ * Takes the latest action with the specified `pattern` and `spawn`s a wrapped
+ * version of the specified saga, such that any uncaught errors in the saga get
+ * reported by our `state.reporter` function. Cancels an previously started
+ * `saga` task. Also stores the task descriptor under the specified `taskName`
+ * for later cancellation via a `STOP_TASKS` action.
+ *
+ * Usage is similar to takeLatest:
+ *     `yield fork(takeLatestWrappedCancellable, 'PATTERN', saga, 'TASK_NAME', 'test');`
+ *
+ * @param  {String} pattern The pattern to `take` on.
+ * @param  {GeneratorFunction} saga The saga to trigger.
+ * @param  {String} taskName The key under which to store the task descriptor.
+ *                           See the `TaskNames` object in the constants module.
+ * @param  {...[Any]} args Arbitrary number of arguments to pass into the saga.
+ */
+export function takeLatestWrappedCancellable(pattern: string, saga: GeneratorFunction, taskName: string, ...args: [Any][]): Generator<Object, void, any>;
+/**
+ * Takes the latest action with the specified `pattern` and `spawn`s a wrapped
+ * version of the specified saga, such that any uncaught errors in the saga get
+ * reported by our `state.reporter` function. Cancels a previously started
+ * `saga` task.
+ *
+ * Usage is just like takeLatest:
+ *     `yield fork(takeLatestWrapped, 'PATTERN', saga, 'test');`
+ *
+ * @param  {String} pattern The pattern to `take` on.
+ * @param  {GeneratorFunction} saga The saga to trigger.
+ * @param  {...[Any]} args Arbitrary number of arguments to pass into the saga.
+ */
+export function takeLatestWrapped(pattern: string, saga: GeneratorFunction, ...args: [Any][]): Generator<Object, void, any>;
+export function asyncRace(effects: any): Generator<import("redux-saga/effects").RaceEffect, void, unknown>;
+/**
+ * True if any OVERLAY-context content is currently displayed.
+ * Checks both v1 content (Redux `currentContent`) and v2 experiences
+ * (tracked by the Open Builder instance, outside Redux).
+ */
+export function isOverlayShowing(): Generator<import("redux-saga/effects").SelectEffect, any, unknown>;
+//# sourceMappingURL=saga-utils.d.ts.map

package/build/sagas/saga-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"saga-utils.d.ts","sourceRoot":"","sources":["../../src/scripts/sagas/saga-utils.js"],"names":[],"mappings":"AAmDA;;;;;;;;;;;;GAYG;AACH,mCANY,iBAAiB,WACd,CAAC,GAAG,CAAC,EAAA,GAER,MAAM,CAKjB;AAaD,0EAEC;AAED;;;;;;;;;;;;;;;GAeG;AACH,mEALY,iBAAiB,6BAGd,CAAC,GAAG,CAAC,EAAA,oCAanB;AAED;;;;;;;;;;;GAWG;AACH,wDAHY,iBAAiB,WACd,CAAC,GAAG,CAAC,EAAA,oCAInB;AAED;;;;;;;;;;;;;;;GAeG;AACH,oEALY,iBAAiB,6BAGd,CAAC,GAAG,CAAC,EAAA,gCAqBnB;AAED;;;;;;;;;;;;GAYG;AACH,yDAHY,iBAAiB,WACd,CAAC,GAAG,CAAC,EAAA,gCAInB;AAED,2GAEC;AAED;;;;GAIG;AACH,uGAiBC"}