@gooddata/sdk-ui-dashboard 11.56.0-alpha.4 → 11.56.0-alpha.5

package/NOTICE

@@ -9,7 +9,7 @@ The following 3rd-party software packages may be used by or distributed with goo
 
 Date generated: 2026-9-8
 
-Revision ID: a8781e798262a7ba5b0988d15649e995e7b321c8
+Revision ID: 88695cebb8f01a84a542250f23d705b05e93325b
 
 ================================================================================
 ================================================================================

package/esm/__version.d.ts

@@ -1,4 +1,4 @@
-export declare const LIB_VERSION = "11.56.0-alpha.4";
+export declare const LIB_VERSION = "11.56.0-alpha.5";
 export declare const LIB_DESCRIPTION = "GoodData SDK - Dashboard Component";
 export declare const LIB_NAME = "@gooddata/sdk-ui-dashboard";
 //# sourceMappingURL=__version.d.ts.map

package/esm/__version.js

@@ -1,5 +1,5 @@
 // (C) 2021 GoodData Corporation
 // DO NOT CHANGE THIS FILE, IT IS RE-GENERATED ON EVERY BUILD
-export const LIB_VERSION = "11.56.0-alpha.4";
+export const LIB_VERSION = "11.56.0-alpha.5";
 export const LIB_DESCRIPTION = "GoodData SDK - Dashboard Component";
 export const LIB_NAME = "@gooddata/sdk-ui-dashboard";

package/esm/presentation/automations/alerting/DefaultAlertingDialog/DefaultAlertingDialog.d.ts

@@ -9,8 +9,9 @@ import { type IDefaultAlertingDialogProps } from "../types.js";
  * rendered within an `AutomationsContextProvider`, an `AlertingDialogContextProvider` (for the
  * create/edit flow), and an `AlertingDialogStateProvider`. Inside a `Dashboard`, the alerting
  * connector supplies the first two providers above the `AlertingDialogComponent` slot, and mounts
- * `AlertingDialogStateProvider` around the resolved slot component once
- * `useAlertingDialogContext().isLoading` is false — so the default component, and any wholesale
+ * `AlertingDialogStateProvider` around the resolved slot component — its state model establishes
+ * itself once `useAlertingDialogContext().isLoading` is first false and stays mounted from then
+ * on — so the default component, and any wholesale
  * slot replacement, inherit all three contexts automatically and require no extra wiring.
  *
  * The providers are intentionally hoisted above the slot rather than built inside this component:

package/esm/presentation/automations/alerting/DefaultAlertingDialog/DefaultAlertingDialog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DefaultAlertingDialog.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/DefaultAlertingDialog/DefaultAlertingDialog.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AA2B1C,OAAO,EAAE,KAAK,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAM/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,2BAA2B,GAAG,YAAY,CActF"}
+{"version":3,"file":"DefaultAlertingDialog.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/DefaultAlertingDialog/DefaultAlertingDialog.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AA2B1C,OAAO,EAAE,KAAK,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAM/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,2BAA2B,GAAG,YAAY,CActF"}

package/esm/presentation/automations/alerting/DefaultAlertingDialog/DefaultAlertingDialog.js

@@ -30,8 +30,9 @@ import { DefaultAlertingDialogRecipients } from "./DefaultAlertingDialogRecipien
  * rendered within an `AutomationsContextProvider`, an `AlertingDialogContextProvider` (for the
  * create/edit flow), and an `AlertingDialogStateProvider`. Inside a `Dashboard`, the alerting
  * connector supplies the first two providers above the `AlertingDialogComponent` slot, and mounts
- * `AlertingDialogStateProvider` around the resolved slot component once
- * `useAlertingDialogContext().isLoading` is false — so the default component, and any wholesale
+ * `AlertingDialogStateProvider` around the resolved slot component — its state model establishes
+ * itself once `useAlertingDialogContext().isLoading` is first false and stays mounted from then
+ * on — so the default component, and any wholesale
  * slot replacement, inherit all three contexts automatically and require no extra wiring.
  *
  * The providers are intentionally hoisted above the slot rather than built inside this component:

package/esm/presentation/automations/alerting/blocks/AlertingDialogShell.d.ts

@@ -12,8 +12,9 @@ import { type IAlertingDialogShellProps } from "../types.js";
  * `AlertingDialogComponent` that keeps this chrome and arranges the blocks differently renders the shell
  * itself. The shell does not own the submit: call {@link useAlertSubmit} and pass its `submit` and
  * `isSaving`, so the footer button and any Enter handler in the body share one instance. Call that hook
- * only once `useAlertingDialogContext().isLoading` is false — the state hooks throw while the dialog
- * loads — and render the shell alone (any `onSubmit`, `isSaving: false`) until then, as the example does.
+ * only once `useAlertingDialogContext().isLoading` is first false — the state hooks throw until the
+ * dialog's data has first loaded (after that they stay available through a refresh) — and render the
+ * shell alone (any `onSubmit`, `isSaving: false`) until then, as the example does.
  *
  * Needs an ambient `IntlProvider`; inside a `Dashboard` the dashboard's provider covers it.
  *
@@ -21,7 +22,7 @@ import { type IAlertingDialogShellProps } from "../types.js";
  * ```tsx
  * function MyAlertingDialog(props: IAlertingDialogProps) {
  *     const { isLoading } = useAlertingDialogContext();
- *     // the state hooks throw while the dialog loads; the shell renders the loading skeleton
+ *     // the state hooks throw until the dialog's data has first loaded; the shell shows the skeleton
  *     if (isLoading) {
  *         return <AlertingDialogShell {...props} onSubmit={() => {}} isSaving={false} />;
  *     }

package/esm/presentation/automations/alerting/blocks/AlertingDialogShell.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AlertingDialogShell.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/blocks/AlertingDialogShell.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAA+B,MAAM,OAAO,CAAC;AAmCvE,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAM7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,yBAAyB,GAAG,YAAY,CAMlF"}
+{"version":3,"file":"AlertingDialogShell.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/blocks/AlertingDialogShell.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAA+B,MAAM,OAAO,CAAC;AAmCvE,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAM7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,yBAAyB,GAAG,YAAY,CAMlF"}

package/esm/presentation/automations/alerting/blocks/AlertingDialogShell.js

@@ -29,8 +29,9 @@ const overlayController = OverlayController.getInstance(DASHBOARD_DIALOG_OVERS_Z
  * `AlertingDialogComponent` that keeps this chrome and arranges the blocks differently renders the shell
  * itself. The shell does not own the submit: call {@link useAlertSubmit} and pass its `submit` and
  * `isSaving`, so the footer button and any Enter handler in the body share one instance. Call that hook
- * only once `useAlertingDialogContext().isLoading` is false — the state hooks throw while the dialog
- * loads — and render the shell alone (any `onSubmit`, `isSaving: false`) until then, as the example does.
+ * only once `useAlertingDialogContext().isLoading` is first false — the state hooks throw until the
+ * dialog's data has first loaded (after that they stay available through a refresh) — and render the
+ * shell alone (any `onSubmit`, `isSaving: false`) until then, as the example does.
  *
  * Needs an ambient `IntlProvider`; inside a `Dashboard` the dashboard's provider covers it.
  *
@@ -38,7 +39,7 @@ const overlayController = OverlayController.getInstance(DASHBOARD_DIALOG_OVERS_Z
  * ```tsx
  * function MyAlertingDialog(props: IAlertingDialogProps) {
  *     const { isLoading } = useAlertingDialogContext();
- *     // the state hooks throw while the dialog loads; the shell renders the loading skeleton
+ *     // the state hooks throw until the dialog's data has first loaded; the shell shows the skeleton
  *     if (isLoading) {
  *         return <AlertingDialogShell {...props} onSubmit={() => {}} isSaving={false} />;
  *     }

package/esm/presentation/automations/alerting/blocks/WhenAlertingDialogLoaded.d.ts

@@ -1,7 +1,8 @@
 import { type ReactNode } from "react";
 /**
- * Renders its children only once the alerting dialog's data has loaded — the state accessors throw
- * while `useAlertingDialogContext().isLoading` is true, because the state providers mount only then.
+ * Renders its children only while `useAlertingDialogContext().isLoading` is false. The state
+ * accessors throw until the dialog's data has first loaded; during a later refresh the state
+ * model stays mounted and keeps serving, but the blocks still hide behind the loading state.
  * Every connected alerting block goes through it.
  *
  * @internal

package/esm/presentation/automations/alerting/blocks/WhenAlertingDialogLoaded.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WhenAlertingDialogLoaded.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/blocks/WhenAlertingDialogLoaded.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAIvC;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,kDAG7E"}
+{"version":3,"file":"WhenAlertingDialogLoaded.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/blocks/WhenAlertingDialogLoaded.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAIvC;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,kDAG7E"}

package/esm/presentation/automations/alerting/blocks/WhenAlertingDialogLoaded.js

@@ -1,8 +1,9 @@
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 import { useAlertingDialogContext } from "../../contexts/AlertingDialogContext.js";
 /**
- * Renders its children only once the alerting dialog's data has loaded — the state accessors throw
- * while `useAlertingDialogContext().isLoading` is true, because the state providers mount only then.
+ * Renders its children only while `useAlertingDialogContext().isLoading` is false. The state
+ * accessors throw until the dialog's data has first loaded; during a later refresh the state
+ * model stays mounted and keeps serving, but the blocks still hide behind the loading state.
  * Every connected alerting block goes through it.
  *
  * @internal

package/esm/presentation/automations/alerting/state/AlertActionsContext.d.ts

@@ -3,10 +3,11 @@ export declare const AlertActionsContextProvider: import("react").Provider<IAler
 /**
  * Reads the alerting dialog's mutators.
  *
- * Throws outside the alerting dialog's state providers, which mount only once
- * `useAlertingDialogContext().isLoading` is false — a replacement for `AlertingDialogComponent`
- * must check that flag before calling this. On the alerting side that state is reached only by an
- * automations refresh while the dialog is open, so it will not appear in manual testing.
+ * Throws outside the alerting dialog's state providers, which mount the state model on the first
+ * render where `useAlertingDialogContext().isLoading` is false and keep it mounted from then on —
+ * a replacement for `AlertingDialogComponent` must check that flag before reading state while the
+ * dialog first loads. An automations refresh flips `isLoading` back without unmounting the model,
+ * so the draft survives and this accessor keeps serving through it.
  *
  * @alpha
  */

package/esm/presentation/automations/alerting/state/AlertActionsContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AlertActionsContext.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/state/AlertActionsContext.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAK5D,eAAO,MAAM,2BAA2B,iEAA+B,CAAC;AAExE;;;;;;;;;GASG;AACH,wBAAgB,eAAe,IAAI,yBAAyB,CAE3D"}
+{"version":3,"file":"AlertActionsContext.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/state/AlertActionsContext.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAK5D,eAAO,MAAM,2BAA2B,iEAA+B,CAAC;AAExE;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,IAAI,yBAAyB,CAE3D"}

package/esm/presentation/automations/alerting/state/AlertActionsContext.js

@@ -7,10 +7,11 @@ export const AlertActionsContextProvider = AlertActionsContext.Provider;
 /**
  * Reads the alerting dialog's mutators.
  *
- * Throws outside the alerting dialog's state providers, which mount only once
- * `useAlertingDialogContext().isLoading` is false — a replacement for `AlertingDialogComponent`
- * must check that flag before calling this. On the alerting side that state is reached only by an
- * automations refresh while the dialog is open, so it will not appear in manual testing.
+ * Throws outside the alerting dialog's state providers, which mount the state model on the first
+ * render where `useAlertingDialogContext().isLoading` is false and keep it mounted from then on —
+ * a replacement for `AlertingDialogComponent` must check that flag before reading state while the
+ * dialog first loads. An automations refresh flips `isLoading` back without unmounting the model,
+ * so the draft survives and this accessor keeps serving through it.
  *
  * @alpha
  */

package/esm/presentation/automations/alerting/state/AlertDataContext.d.ts

@@ -3,10 +3,11 @@ export declare const AlertDataContextProvider: import("react").Provider<IAlertDa
 /**
  * Reads the data the alerting dialog loads asynchronously.
  *
- * Throws outside the alerting dialog's state providers, which mount only once
- * `useAlertingDialogContext().isLoading` is false — a replacement for `AlertingDialogComponent`
- * must check that flag before calling this. On the alerting side that state is reached only by an
- * automations refresh while the dialog is open, so it will not appear in manual testing.
+ * Throws outside the alerting dialog's state providers, which mount the state model on the first
+ * render where `useAlertingDialogContext().isLoading` is false and keep it mounted from then on —
+ * a replacement for `AlertingDialogComponent` must check that flag before reading state while the
+ * dialog first loads. An automations refresh flips `isLoading` back without unmounting the model,
+ * so the draft survives and this accessor keeps serving through it.
  *
  * @alpha
  */

package/esm/presentation/automations/alerting/state/AlertDataContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AlertDataContext.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/state/AlertDataContext.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAKzD,eAAO,MAAM,wBAAwB,8DAA4B,CAAC;AAElE;;;;;;;;;GASG;AACH,wBAAgB,YAAY,IAAI,sBAAsB,CAErD"}
+{"version":3,"file":"AlertDataContext.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/state/AlertDataContext.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAKzD,eAAO,MAAM,wBAAwB,8DAA4B,CAAC;AAElE;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,IAAI,sBAAsB,CAErD"}

package/esm/presentation/automations/alerting/state/AlertDataContext.js

@@ -7,10 +7,11 @@ export const AlertDataContextProvider = AlertDataContext.Provider;
 /**
  * Reads the data the alerting dialog loads asynchronously.
  *
- * Throws outside the alerting dialog's state providers, which mount only once
- * `useAlertingDialogContext().isLoading` is false — a replacement for `AlertingDialogComponent`
- * must check that flag before calling this. On the alerting side that state is reached only by an
- * automations refresh while the dialog is open, so it will not appear in manual testing.
+ * Throws outside the alerting dialog's state providers, which mount the state model on the first
+ * render where `useAlertingDialogContext().isLoading` is false and keep it mounted from then on —
+ * a replacement for `AlertingDialogComponent` must check that flag before reading state while the
+ * dialog first loads. An automations refresh flips `isLoading` back without unmounting the model,
+ * so the draft survives and this accessor keeps serving through it.
  *
  * @alpha
  */

package/esm/presentation/automations/alerting/state/AlertDraftContext.d.ts

@@ -3,10 +3,11 @@ export declare const AlertDraftContextProvider: import("react").Provider<IAlertD
 /**
  * Reads the alerting dialog's edit draft.
  *
- * Throws outside the alerting dialog's state providers, which mount only once
- * `useAlertingDialogContext().isLoading` is false — a replacement for `AlertingDialogComponent`
- * must check that flag before calling this. On the alerting side that state is reached only by an
- * automations refresh while the dialog is open, so it will not appear in manual testing.
+ * Throws outside the alerting dialog's state providers, which mount the state model on the first
+ * render where `useAlertingDialogContext().isLoading` is false and keep it mounted from then on —
+ * a replacement for `AlertingDialogComponent` must check that flag before reading state while the
+ * dialog first loads. An automations refresh flips `isLoading` back without unmounting the model,
+ * so the draft survives and this accessor keeps serving through it.
  *
  * @alpha
  */

package/esm/presentation/automations/alerting/state/AlertDraftContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AlertDraftContext.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/state/AlertDraftContext.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAK1D,eAAO,MAAM,yBAAyB,+DAA6B,CAAC;AAEpE;;;;;;;;;GASG;AACH,wBAAgB,aAAa,IAAI,uBAAuB,CAEvD"}
+{"version":3,"file":"AlertDraftContext.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/state/AlertDraftContext.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAK1D,eAAO,MAAM,yBAAyB,+DAA6B,CAAC;AAEpE;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,IAAI,uBAAuB,CAEvD"}

package/esm/presentation/automations/alerting/state/AlertDraftContext.js

@@ -7,10 +7,11 @@ export const AlertDraftContextProvider = AlertDraftContext.Provider;
 /**
  * Reads the alerting dialog's edit draft.
  *
- * Throws outside the alerting dialog's state providers, which mount only once
- * `useAlertingDialogContext().isLoading` is false — a replacement for `AlertingDialogComponent`
- * must check that flag before calling this. On the alerting side that state is reached only by an
- * automations refresh while the dialog is open, so it will not appear in manual testing.
+ * Throws outside the alerting dialog's state providers, which mount the state model on the first
+ * render where `useAlertingDialogContext().isLoading` is false and keep it mounted from then on —
+ * a replacement for `AlertingDialogComponent` must check that flag before reading state while the
+ * dialog first loads. An automations refresh flips `isLoading` back without unmounting the model,
+ * so the draft survives and this accessor keeps serving through it.
  *
  * @alpha
  */

package/esm/presentation/automations/alerting/state/AlertFiltersContext.d.ts

@@ -3,10 +3,11 @@ export declare const AlertFiltersContextProvider: import("react").Provider<IAler
 /**
  * Reads the alerting dialog's filter and export-parameter model.
  *
- * Throws outside the alerting dialog's state providers, which mount only once
- * `useAlertingDialogContext().isLoading` is false — a replacement for `AlertingDialogComponent`
- * must check that flag before calling this. On the alerting side that state is reached only by an
- * automations refresh while the dialog is open, so it will not appear in manual testing.
+ * Throws outside the alerting dialog's state providers, which mount the state model on the first
+ * render where `useAlertingDialogContext().isLoading` is false and keep it mounted from then on —
+ * a replacement for `AlertingDialogComponent` must check that flag before reading state while the
+ * dialog first loads. An automations refresh flips `isLoading` back without unmounting the model,
+ * so the draft survives and this accessor keeps serving through it.
  *
  * @alpha
  */

package/esm/presentation/automations/alerting/state/AlertFiltersContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AlertFiltersContext.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/state/AlertFiltersContext.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAK5D,eAAO,MAAM,2BAA2B,iEAA+B,CAAC;AAExE;;;;;;;;;GASG;AACH,wBAAgB,eAAe,IAAI,yBAAyB,CAE3D"}
+{"version":3,"file":"AlertFiltersContext.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/state/AlertFiltersContext.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAK5D,eAAO,MAAM,2BAA2B,iEAA+B,CAAC;AAExE;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,IAAI,yBAAyB,CAE3D"}

package/esm/presentation/automations/alerting/state/AlertFiltersContext.js

@@ -7,10 +7,11 @@ export const AlertFiltersContextProvider = AlertFiltersContext.Provider;
 /**
  * Reads the alerting dialog's filter and export-parameter model.
  *
- * Throws outside the alerting dialog's state providers, which mount only once
- * `useAlertingDialogContext().isLoading` is false — a replacement for `AlertingDialogComponent`
- * must check that flag before calling this. On the alerting side that state is reached only by an
- * automations refresh while the dialog is open, so it will not appear in manual testing.
+ * Throws outside the alerting dialog's state providers, which mount the state model on the first
+ * render where `useAlertingDialogContext().isLoading` is false and keep it mounted from then on —
+ * a replacement for `AlertingDialogComponent` must check that flag before reading state while the
+ * dialog first loads. An automations refresh flips `isLoading` back without unmounting the model,
+ * so the draft survives and this accessor keeps serving through it.
  *
  * @alpha
  */

package/esm/presentation/automations/alerting/state/AlertingDialogStateProvider.d.ts

@@ -1,13 +1,15 @@
 import { type ReactNode } from "react";
 /**
- * Publishes the alerting create/edit dialog's state as the four alert state contexts once the
- * dialog's data has loaded.
+ * Publishes the alerting create/edit dialog's state as the four alert state contexts from the
+ * first render where the dialog's data has loaded.
  *
  * Mounts above the resolved `AlertingDialogComponent`, so the default dialog, a shell of blocks
- * and a wholesale replacement all read the same state with no extra wiring. Defers mounting the
- * state model itself until `useAlertingDialogContext().isLoading` is false, because the state
- * model seeds its draft from the dialog's loaded data in `useState` initializers that never
- * re-run — mounting earlier would freeze that seed against not-yet-loaded data.
+ * and a wholesale replacement all read the same state with no extra wiring. Mounts the state
+ * model on the first render where `useAlertingDialogContext().isLoading` is false and keeps it
+ * mounted for the rest of the dialog's life: the model seeds its draft from the dialog's loaded
+ * data in `useState` initializers that never re-run, so mounting earlier would freeze that seed
+ * against not-yet-loaded data — and unmounting on a later `isLoading` flip (an automations
+ * refresh) would discard the in-flight draft.
  *
  * Runs `useIntl`-calling hooks, so an `IntlProvider` must sit above it. Inside a `Dashboard` the
  * ambient wrapper in `DashboardInner` supplies one with the same locale; a mount site without one

package/esm/presentation/automations/alerting/state/AlertingDialogStateProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AlertingDialogStateProvider.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/state/AlertingDialogStateProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAW,MAAM,OAAO,CAAC;AAqBhD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,2BAA2B,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,2CAIhF"}
+{"version":3,"file":"AlertingDialogStateProvider.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/state/AlertingDialogStateProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAqB,MAAM,OAAO,CAAC;AAqB1D;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,2BAA2B,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,2CAWhF"}

package/esm/presentation/automations/alerting/state/AlertingDialogStateProvider.js

@@ -1,6 +1,6 @@
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 // (C) 2026 GoodData Corporation
-import { useMemo } from "react";
+import { useMemo, useState } from "react";
 import { useAlertingDialogContext } from "../../contexts/AlertingDialogContext.js";
 import { useAutomationsContext } from "../../contexts/AutomationsContext.js";
 import { useAutomationFiltersSelect } from "../../shared/automationFilters/useAutomationFiltersSelect.js";
@@ -13,14 +13,16 @@ import { useAlertFormState } from "./useAlertFormState.js";
 import { getAlertSelectedValues } from "./useAlertSelectedValues.js";
 import { useAlertSupportedMetrics } from "./useAlertSupportedMetrics.js";
 /**
- * Publishes the alerting create/edit dialog's state as the four alert state contexts once the
- * dialog's data has loaded.
+ * Publishes the alerting create/edit dialog's state as the four alert state contexts from the
+ * first render where the dialog's data has loaded.
  *
  * Mounts above the resolved `AlertingDialogComponent`, so the default dialog, a shell of blocks
- * and a wholesale replacement all read the same state with no extra wiring. Defers mounting the
- * state model itself until `useAlertingDialogContext().isLoading` is false, because the state
- * model seeds its draft from the dialog's loaded data in `useState` initializers that never
- * re-run — mounting earlier would freeze that seed against not-yet-loaded data.
+ * and a wholesale replacement all read the same state with no extra wiring. Mounts the state
+ * model on the first render where `useAlertingDialogContext().isLoading` is false and keeps it
+ * mounted for the rest of the dialog's life: the model seeds its draft from the dialog's loaded
+ * data in `useState` initializers that never re-run, so mounting earlier would freeze that seed
+ * against not-yet-loaded data — and unmounting on a later `isLoading` flip (an automations
+ * refresh) would discard the in-flight draft.
  *
  * Runs `useIntl`-calling hooks, so an `IntlProvider` must sit above it. Inside a `Dashboard` the
  * ambient wrapper in `DashboardInner` supplies one with the same locale; a mount site without one
@@ -30,7 +32,13 @@ import { useAlertSupportedMetrics } from "./useAlertSupportedMetrics.js";
  */
 export function AlertingDialogStateProvider({ children }) {
     const { isLoading } = useAlertingDialogContext();
-    return isLoading ? _jsx(_Fragment, { children: children }) : _jsx(LoadedAlertingDialogState, { children: children });
+    // Latches on the first non-loading render: the draft seed must not run against unloaded
+    // data, and once seeded it must survive isLoading flipping back (an automations refresh).
+    const [hasLoaded, setHasLoaded] = useState(!isLoading);
+    if (!isLoading && !hasLoaded) {
+        setHasLoaded(true);
+    }
+    return hasLoaded ? _jsx(LoadedAlertingDialogState, { children: children }) : _jsx(_Fragment, { children: children });
 }
 function LoadedAlertingDialogState({ children }) {
     const { weekStart, timezone, externalRecipient } = useAutomationsContext();

package/esm/presentation/automations/alerting/state/missingAlertStateProvider.js

@@ -5,5 +5,5 @@
  * @internal
  */
 export function missingAlertStateProvider(accessor) {
-    throw new Error(`${accessor} must be used within AlertingDialogStateProvider. The provider mounts only once the dialog's data has loaded, so check useAlertingDialogContext().isLoading before reading alerting dialog state.`);
+    throw new Error(`${accessor} must be used within AlertingDialogStateProvider. The state model mounts once the dialog's data has first loaded, so check useAlertingDialogContext().isLoading before reading alerting dialog state.`);
 }

package/esm/presentation/automations/alerting/types.d.ts

@@ -766,7 +766,7 @@ export interface IAlertingDialogShellProps extends Pick<IAlertingDialogProps, "o
      * The dialog's single submit — `submit` of the caller's {@link useAlertSubmit} instance. Drives the
      * footer's submit button and the Enter key on it. The shell does not own the submit hook, so a
      * caller's own Enter handler or button can share the same instance. Create the hook instance only
-     * once the dialog context reports `isLoading: false`.
+     * once the dialog's data has first loaded — the state hooks throw before then.
      */
     onSubmit: () => void;
     /**

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/DefaultScheduledEmailDialog.d.ts

@@ -8,7 +8,8 @@ import { type IDefaultScheduledEmailDialogProps } from "../types.js";
  * export draft's state from those contexts rather than from the dashboard store. It must therefore
  * be rendered within an `AutomationsContextProvider`, a `ScheduledEmailDialogContextProvider` (for
  * the create/edit flow), and a `ScheduledEmailDialogStateProvider`, whose state model establishes
- * itself once `useScheduledEmailDialogContext().isLoading` is false. Inside a `Dashboard`, the
+ * itself once `useScheduledEmailDialogContext().isLoading` is first false and stays mounted from
+ * then on. Inside a `Dashboard`, the
  * scheduled export connector supplies the first two providers above the
  * `ScheduledEmailDialogComponent` slot and mounts `ScheduledEmailDialogStateProvider` around the
  * resolved slot component — so the default component, and any wholesale slot replacement, inherit

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/DefaultScheduledEmailDialog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DefaultScheduledEmailDialog.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/DefaultScheduledEmailDialog.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAuB1C,OAAO,EAAE,KAAK,iCAAiC,EAAE,MAAM,aAAa,CAAC;AAMrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,iCAAiC,GAAG,YAAY,CAiBlG"}
+{"version":3,"file":"DefaultScheduledEmailDialog.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/DefaultScheduledEmailDialog.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAuB1C,OAAO,EAAE,KAAK,iCAAiC,EAAE,MAAM,aAAa,CAAC;AAMrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,iCAAiC,GAAG,YAAY,CAiBlG"}

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/DefaultScheduledEmailDialog.js

@@ -26,7 +26,8 @@ import { DefaultScheduledEmailDialogTimezone } from "./components/DefaultSchedul
  * export draft's state from those contexts rather than from the dashboard store. It must therefore
  * be rendered within an `AutomationsContextProvider`, a `ScheduledEmailDialogContextProvider` (for
  * the create/edit flow), and a `ScheduledEmailDialogStateProvider`, whose state model establishes
- * itself once `useScheduledEmailDialogContext().isLoading` is false. Inside a `Dashboard`, the
+ * itself once `useScheduledEmailDialogContext().isLoading` is first false and stays mounted from
+ * then on. Inside a `Dashboard`, the
  * scheduled export connector supplies the first two providers above the
  * `ScheduledEmailDialogComponent` slot and mounts `ScheduledEmailDialogStateProvider` around the
  * resolved slot component — so the default component, and any wholesale slot replacement, inherit

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogShell.d.ts

@@ -15,9 +15,9 @@ import { type IScheduledEmailDialogShellProps } from "../types.js";
  * shell itself. The shell does not own the save: call {@link useSaveScheduledEmailToBackend} and pass its
  * `handleSaveScheduledEmail`, `isSavingScheduledEmail` and `savingErrorMessage`; build Enter handlers for
  * the blocks you place with {@link useScheduledEmailSubmitOnEnter} over the same `handleSaveScheduledEmail`.
- * Call that hook only once `useScheduledEmailDialogContext().isLoading` is false — the state hooks throw
- * while the dialog loads — and render the shell alone (any `onSubmit`, `isSaving: false`) until then, as
- * the example does.
+ * Call that hook only once `useScheduledEmailDialogContext().isLoading` is first false — the state hooks
+ * throw until the dialog's data has first loaded (after that they stay available through a refresh) —
+ * and render the shell alone (any `onSubmit`, `isSaving: false`) until then, as the example does.
  *
  * Needs an ambient `IntlProvider`; inside a `Dashboard` the dashboard's provider covers it.
  *
@@ -25,7 +25,7 @@ import { type IScheduledEmailDialogShellProps } from "../types.js";
  * ```tsx
  * function MyScheduledEmailDialog(props: IScheduledEmailDialogProps) {
  *     const { isLoading } = useScheduledEmailDialogContext();
- *     // the state hooks throw while the dialog loads; the shell renders the loading skeleton
+ *     // the state hooks throw until the dialog's data has first loaded; the shell shows the skeleton
  *     if (isLoading) {
  *         return <ScheduledEmailDialogShell {...props} onSubmit={() => {}} isSaving={false} />;
  *     }

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogShell.js

@@ -40,9 +40,9 @@ const overlayController = OverlayController.getInstance(DASHBOARD_DIALOG_OVERS_Z
  * shell itself. The shell does not own the save: call {@link useSaveScheduledEmailToBackend} and pass its
  * `handleSaveScheduledEmail`, `isSavingScheduledEmail` and `savingErrorMessage`; build Enter handlers for
  * the blocks you place with {@link useScheduledEmailSubmitOnEnter} over the same `handleSaveScheduledEmail`.
- * Call that hook only once `useScheduledEmailDialogContext().isLoading` is false — the state hooks throw
- * while the dialog loads — and render the shell alone (any `onSubmit`, `isSaving: false`) until then, as
- * the example does.
+ * Call that hook only once `useScheduledEmailDialogContext().isLoading` is first false — the state hooks
+ * throw until the dialog's data has first loaded (after that they stay available through a refresh) —
+ * and render the shell alone (any `onSubmit`, `isSaving: false`) until then, as the example does.
  *
  * Needs an ambient `IntlProvider`; inside a `Dashboard` the dashboard's provider covers it.
  *
@@ -50,7 +50,7 @@ const overlayController = OverlayController.getInstance(DASHBOARD_DIALOG_OVERS_Z
  * ```tsx
  * function MyScheduledEmailDialog(props: IScheduledEmailDialogProps) {
  *     const { isLoading } = useScheduledEmailDialogContext();
- *     // the state hooks throw while the dialog loads; the shell renders the loading skeleton
+ *     // the state hooks throw until the dialog's data has first loaded; the shell shows the skeleton
  *     if (isLoading) {
  *         return <ScheduledEmailDialogShell {...props} onSubmit={() => {}} isSaving={false} />;
  *     }

package/esm/presentation/automations/scheduledEmail/blocks/WhenScheduledEmailDialogLoaded.d.ts

@@ -1,9 +1,10 @@
 import { type ReactNode } from "react";
 /**
- * Renders its children only once the scheduled-export dialog's data has loaded — the state accessors
- * throw while `useScheduledEmailDialogContext().isLoading` is true, because the state providers mount
- * only then. Every connected scheduled-email block goes through it. On scheduled email this state is
- * on the ordinary path — a widget export renders while its filters load — so a shell sees its blocks
+ * Renders its children only while `useScheduledEmailDialogContext().isLoading` is false. The state
+ * accessors throw until the dialog's data has first loaded; during a later refresh the state model
+ * stays mounted and keeps serving, but the blocks still hide behind the loading state. Every
+ * connected scheduled-email block goes through it. On scheduled email the loading state is on the
+ * ordinary path — a widget export renders while its filters load — so a shell sees its blocks
  * appear once loading ends.
  *
  * @internal

package/esm/presentation/automations/scheduledEmail/blocks/WhenScheduledEmailDialogLoaded.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WhenScheduledEmailDialogLoaded.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/blocks/WhenScheduledEmailDialogLoaded.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAIvC;;;;;;;;GAQG;AACH,wBAAgB,8BAA8B,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,kDAGnF"}
+{"version":3,"file":"WhenScheduledEmailDialogLoaded.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/blocks/WhenScheduledEmailDialogLoaded.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAIvC;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,kDAGnF"}

package/esm/presentation/automations/scheduledEmail/blocks/WhenScheduledEmailDialogLoaded.js

@@ -1,10 +1,11 @@
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 import { useScheduledEmailDialogContext } from "../../contexts/ScheduledEmailDialogContext.js";
 /**
- * Renders its children only once the scheduled-export dialog's data has loaded — the state accessors
- * throw while `useScheduledEmailDialogContext().isLoading` is true, because the state providers mount
- * only then. Every connected scheduled-email block goes through it. On scheduled email this state is
- * on the ordinary path — a widget export renders while its filters load — so a shell sees its blocks
+ * Renders its children only while `useScheduledEmailDialogContext().isLoading` is false. The state
+ * accessors throw until the dialog's data has first loaded; during a later refresh the state model
+ * stays mounted and keeps serving, but the blocks still hide behind the loading state. Every
+ * connected scheduled-email block goes through it. On scheduled email the loading state is on the
+ * ordinary path — a widget export renders while its filters load — so a shell sees its blocks
  * appear once loading ends.
  *
  * @internal

package/esm/presentation/automations/scheduledEmail/state/ScheduledEmailDialogStateProvider.d.ts

@@ -1,14 +1,16 @@
 import { type ReactNode } from "react";
 /**
  * Publishes the scheduled-export create/edit dialog's state as the four scheduled-export state
- * contexts once the dialog's data has loaded.
+ * contexts from the first render where the dialog's data has loaded.
  *
  * Mounts above the resolved `ScheduledEmailDialogComponent`, so the default dialog, a shell of
- * blocks and a wholesale replacement all read the same state with no extra wiring. Defers mounting
- * the state model itself until `useScheduledEmailDialogContext().isLoading` is false, because the
- * state model seeds its draft from the dialog's loaded data in `useState` initializers that never
- * re-run — mounting earlier would freeze that seed against not-yet-loaded data. That is the
- * ordinary path here, not an edge case: a widget export's filters load after the dialog opens.
+ * blocks and a wholesale replacement all read the same state with no extra wiring. Mounts the
+ * state model on the first render where `useScheduledEmailDialogContext().isLoading` is false and
+ * keeps it mounted for the rest of the dialog's life: the model seeds its draft from the dialog's
+ * loaded data in `useState` initializers that never re-run, so mounting earlier would freeze that
+ * seed against not-yet-loaded data — that is the ordinary path here, not an edge case: a widget
+ * export's filters load after the dialog opens — and unmounting on a later `isLoading` flip (an
+ * automations refresh) would discard the in-flight draft.
  *
  * Runs `useIntl`-calling hooks, so an `IntlProvider` must sit above it. Inside a `Dashboard` the
  * ambient wrapper in `DashboardInner` supplies one with the same locale; a mount site without one

package/esm/presentation/automations/scheduledEmail/state/ScheduledEmailDialogStateProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ScheduledEmailDialogStateProvider.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/state/ScheduledEmailDialogStateProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAW,MAAM,OAAO,CAAC;AAsBhD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iCAAiC,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,2CAQtF"}
+{"version":3,"file":"ScheduledEmailDialogStateProvider.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/state/ScheduledEmailDialogStateProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAqB,MAAM,OAAO,CAAC;AAsB1D;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,iCAAiC,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,2CAetF"}

package/esm/presentation/automations/scheduledEmail/state/ScheduledEmailDialogStateProvider.js

@@ -1,6 +1,6 @@
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 // (C) 2026 GoodData Corporation
-import { useMemo } from "react";
+import { useMemo, useState } from "react";
 import { useAutomationsContext } from "../../contexts/AutomationsContext.js";
 import { useScheduledEmailDialogContext } from "../../contexts/ScheduledEmailDialogContext.js";
 import { useAutomationFiltersSelect } from "../../shared/automationFilters/useAutomationFiltersSelect.js";
@@ -16,14 +16,16 @@ import { useScheduledEmailFiltersModel } from "./useScheduledEmailFiltersModel.j
 import { useScheduledEmailFormState } from "./useScheduledEmailFormState.js";
 /**
  * Publishes the scheduled-export create/edit dialog's state as the four scheduled-export state
- * contexts once the dialog's data has loaded.
+ * contexts from the first render where the dialog's data has loaded.
  *
  * Mounts above the resolved `ScheduledEmailDialogComponent`, so the default dialog, a shell of
- * blocks and a wholesale replacement all read the same state with no extra wiring. Defers mounting
- * the state model itself until `useScheduledEmailDialogContext().isLoading` is false, because the
- * state model seeds its draft from the dialog's loaded data in `useState` initializers that never
- * re-run — mounting earlier would freeze that seed against not-yet-loaded data. That is the
- * ordinary path here, not an edge case: a widget export's filters load after the dialog opens.
+ * blocks and a wholesale replacement all read the same state with no extra wiring. Mounts the
+ * state model on the first render where `useScheduledEmailDialogContext().isLoading` is false and
+ * keeps it mounted for the rest of the dialog's life: the model seeds its draft from the dialog's
+ * loaded data in `useState` initializers that never re-run, so mounting earlier would freeze that
+ * seed against not-yet-loaded data — that is the ordinary path here, not an edge case: a widget
+ * export's filters load after the dialog opens — and unmounting on a later `isLoading` flip (an
+ * automations refresh) would discard the in-flight draft.
  *
  * Runs `useIntl`-calling hooks, so an `IntlProvider` must sit above it. Inside a `Dashboard` the
  * ambient wrapper in `DashboardInner` supplies one with the same locale; a mount site without one
@@ -33,7 +35,13 @@ import { useScheduledEmailFormState } from "./useScheduledEmailFormState.js";
  */
 export function ScheduledEmailDialogStateProvider({ children }) {
     const { isLoading } = useScheduledEmailDialogContext();
-    return isLoading ? (_jsx(_Fragment, { children: children })) : (_jsx(LoadedScheduledEmailDialogState, { children: children }));
+    // Latches on the first non-loading render: the draft seed must not run against unloaded
+    // data, and once seeded it must survive isLoading flipping back (an automations refresh).
+    const [hasLoaded, setHasLoaded] = useState(!isLoading);
+    if (!isLoading && !hasLoaded) {
+        setHasLoaded(true);
+    }
+    return hasLoaded ? (_jsx(LoadedScheduledEmailDialogState, { children: children })) : (_jsx(_Fragment, { children: children }));
 }
 function LoadedScheduledEmailDialogState({ children }) {
     const { settings, externalRecipient } = useAutomationsContext();

package/esm/presentation/automations/scheduledEmail/state/ScheduledExportActionsContext.d.ts

@@ -3,10 +3,12 @@ export declare const ScheduledExportActionsContextProvider: import("react").Prov
 /**
  * Reads the scheduled-export dialog's draft mutators.
  *
- * Throws outside the scheduled-export dialog's state providers, which mount only once
- * `useScheduledEmailDialogContext().isLoading` is false — a replacement for
- * `ScheduledEmailDialogComponent` must check that flag before calling this. That state is on the
- * ordinary path here: a widget export renders while its filters load.
+ * Throws outside the scheduled-export dialog's state providers, which mount the state model on
+ * the first render where `useScheduledEmailDialogContext().isLoading` is false and keep it
+ * mounted from then on — a replacement for `ScheduledEmailDialogComponent` must check that flag
+ * before reading state while the dialog first loads. That state is on the ordinary path here: a
+ * widget export renders while its filters load. An automations refresh flips `isLoading` back
+ * without unmounting the model, so the draft survives and this accessor keeps serving through it.
  *
  * @alpha
  */

package/esm/presentation/automations/scheduledEmail/state/ScheduledExportActionsContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ScheduledExportActionsContext.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/state/ScheduledExportActionsContext.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,mCAAmC,EAAE,MAAM,YAAY,CAAC;AAOtE,eAAO,MAAM,qCAAqC,2EAAyC,CAAC;AAE5F;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,IAAI,mCAAmC,CAK/E"}
+{"version":3,"file":"ScheduledExportActionsContext.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/state/ScheduledExportActionsContext.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,mCAAmC,EAAE,MAAM,YAAY,CAAC;AAOtE,eAAO,MAAM,qCAAqC,2EAAyC,CAAC;AAE5F;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,IAAI,mCAAmC,CAK/E"}

package/esm/presentation/automations/scheduledEmail/state/ScheduledExportActionsContext.js

@@ -7,10 +7,12 @@ export const ScheduledExportActionsContextProvider = ScheduledExportActionsConte
 /**
  * Reads the scheduled-export dialog's draft mutators.
  *
- * Throws outside the scheduled-export dialog's state providers, which mount only once
- * `useScheduledEmailDialogContext().isLoading` is false — a replacement for
- * `ScheduledEmailDialogComponent` must check that flag before calling this. That state is on the
- * ordinary path here: a widget export renders while its filters load.
+ * Throws outside the scheduled-export dialog's state providers, which mount the state model on
+ * the first render where `useScheduledEmailDialogContext().isLoading` is false and keep it
+ * mounted from then on — a replacement for `ScheduledEmailDialogComponent` must check that flag
+ * before reading state while the dialog first loads. That state is on the ordinary path here: a
+ * widget export renders while its filters load. An automations refresh flips `isLoading` back
+ * without unmounting the model, so the draft survives and this accessor keeps serving through it.
  *
  * @alpha
  */

package/esm/presentation/automations/scheduledEmail/state/ScheduledExportDataContext.d.ts

@@ -3,10 +3,12 @@ export declare const ScheduledExportDataContextProvider: import("react").Provide
 /**
  * Reads the scheduled-export dialog's recipient defaults.
  *
- * Throws outside the scheduled-export dialog's state providers, which mount only once
- * `useScheduledEmailDialogContext().isLoading` is false — a replacement for
- * `ScheduledEmailDialogComponent` must check that flag before calling this. That state is on the
- * ordinary path here: a widget export renders while its filters load.
+ * Throws outside the scheduled-export dialog's state providers, which mount the state model on
+ * the first render where `useScheduledEmailDialogContext().isLoading` is false and keep it
+ * mounted from then on — a replacement for `ScheduledEmailDialogComponent` must check that flag
+ * before reading state while the dialog first loads. That state is on the ordinary path here: a
+ * widget export renders while its filters load. An automations refresh flips `isLoading` back
+ * without unmounting the model, so the draft survives and this accessor keeps serving through it.
  *
  * @alpha
  */

package/esm/presentation/automations/scheduledEmail/state/ScheduledExportDataContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ScheduledExportDataContext.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/state/ScheduledExportDataContext.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,gCAAgC,EAAE,MAAM,YAAY,CAAC;AAKnE,eAAO,MAAM,kCAAkC,wEAAsC,CAAC;AAEtF;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,IAAI,gCAAgC,CAKzE"}
+{"version":3,"file":"ScheduledExportDataContext.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/state/ScheduledExportDataContext.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,gCAAgC,EAAE,MAAM,YAAY,CAAC;AAKnE,eAAO,MAAM,kCAAkC,wEAAsC,CAAC;AAEtF;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,IAAI,gCAAgC,CAKzE"}

package/esm/presentation/automations/scheduledEmail/state/ScheduledExportDataContext.js

@@ -7,10 +7,12 @@ export const ScheduledExportDataContextProvider = ScheduledExportDataContext.Pro
 /**
  * Reads the scheduled-export dialog's recipient defaults.
  *
- * Throws outside the scheduled-export dialog's state providers, which mount only once
- * `useScheduledEmailDialogContext().isLoading` is false — a replacement for
- * `ScheduledEmailDialogComponent` must check that flag before calling this. That state is on the
- * ordinary path here: a widget export renders while its filters load.
+ * Throws outside the scheduled-export dialog's state providers, which mount the state model on
+ * the first render where `useScheduledEmailDialogContext().isLoading` is false and keep it
+ * mounted from then on — a replacement for `ScheduledEmailDialogComponent` must check that flag
+ * before reading state while the dialog first loads. That state is on the ordinary path here: a
+ * widget export renders while its filters load. An automations refresh flips `isLoading` back
+ * without unmounting the model, so the draft survives and this accessor keeps serving through it.
  *
  * @alpha
  */

package/esm/presentation/automations/scheduledEmail/state/ScheduledExportDraftContext.d.ts

@@ -3,10 +3,12 @@ export declare const ScheduledExportDraftContextProvider: import("react").Provid
 /**
  * Reads the scheduled-export dialog's edit draft.
  *
- * Throws outside the scheduled-export dialog's state providers, which mount only once
- * `useScheduledEmailDialogContext().isLoading` is false — a replacement for
- * `ScheduledEmailDialogComponent` must check that flag before calling this. That state is on the
- * ordinary path here: a widget export renders while its filters load.
+ * Throws outside the scheduled-export dialog's state providers, which mount the state model on
+ * the first render where `useScheduledEmailDialogContext().isLoading` is false and keep it
+ * mounted from then on — a replacement for `ScheduledEmailDialogComponent` must check that flag
+ * before reading state while the dialog first loads. That state is on the ordinary path here: a
+ * widget export renders while its filters load. An automations refresh flips `isLoading` back
+ * without unmounting the model, so the draft survives and this accessor keeps serving through it.
  *
  * @alpha
  */

package/esm/presentation/automations/scheduledEmail/state/ScheduledExportDraftContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ScheduledExportDraftContext.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/state/ScheduledExportDraftContext.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,iCAAiC,EAAE,MAAM,YAAY,CAAC;AAKpE,eAAO,MAAM,mCAAmC,yEAAuC,CAAC;AAExF;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,IAAI,iCAAiC,CAK3E"}
+{"version":3,"file":"ScheduledExportDraftContext.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/state/ScheduledExportDraftContext.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,iCAAiC,EAAE,MAAM,YAAY,CAAC;AAKpE,eAAO,MAAM,mCAAmC,yEAAuC,CAAC;AAExF;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,IAAI,iCAAiC,CAK3E"}

package/esm/presentation/automations/scheduledEmail/state/ScheduledExportDraftContext.js

@@ -7,10 +7,12 @@ export const ScheduledExportDraftContextProvider = ScheduledExportDraftContext.P
 /**
  * Reads the scheduled-export dialog's edit draft.
  *
- * Throws outside the scheduled-export dialog's state providers, which mount only once
- * `useScheduledEmailDialogContext().isLoading` is false — a replacement for
- * `ScheduledEmailDialogComponent` must check that flag before calling this. That state is on the
- * ordinary path here: a widget export renders while its filters load.
+ * Throws outside the scheduled-export dialog's state providers, which mount the state model on
+ * the first render where `useScheduledEmailDialogContext().isLoading` is false and keep it
+ * mounted from then on — a replacement for `ScheduledEmailDialogComponent` must check that flag
+ * before reading state while the dialog first loads. That state is on the ordinary path here: a
+ * widget export renders while its filters load. An automations refresh flips `isLoading` back
+ * without unmounting the model, so the draft survives and this accessor keeps serving through it.
  *
  * @alpha
  */

package/esm/presentation/automations/scheduledEmail/state/ScheduledExportFiltersContext.d.ts

@@ -3,10 +3,12 @@ export declare const ScheduledExportFiltersContextProvider: import("react").Prov
 /**
  * Reads the scheduled-export dialog's filter and export-parameter model.
  *
- * Throws outside the scheduled-export dialog's state providers, which mount only once
- * `useScheduledEmailDialogContext().isLoading` is false — a replacement for
- * `ScheduledEmailDialogComponent` must check that flag before calling this. That state is on the
- * ordinary path here: a widget export renders while its filters load.
+ * Throws outside the scheduled-export dialog's state providers, which mount the state model on
+ * the first render where `useScheduledEmailDialogContext().isLoading` is false and keep it
+ * mounted from then on — a replacement for `ScheduledEmailDialogComponent` must check that flag
+ * before reading state while the dialog first loads. That state is on the ordinary path here: a
+ * widget export renders while its filters load. An automations refresh flips `isLoading` back
+ * without unmounting the model, so the draft survives and this accessor keeps serving through it.
  *
  * @alpha
  */

package/esm/presentation/automations/scheduledEmail/state/ScheduledExportFiltersContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ScheduledExportFiltersContext.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/state/ScheduledExportFiltersContext.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,mCAAmC,EAAE,MAAM,YAAY,CAAC;AAOtE,eAAO,MAAM,qCAAqC,2EAAyC,CAAC;AAE5F;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,IAAI,mCAAmC,CAK/E"}
+{"version":3,"file":"ScheduledExportFiltersContext.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/state/ScheduledExportFiltersContext.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,mCAAmC,EAAE,MAAM,YAAY,CAAC;AAOtE,eAAO,MAAM,qCAAqC,2EAAyC,CAAC;AAE5F;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,IAAI,mCAAmC,CAK/E"}

package/esm/presentation/automations/scheduledEmail/state/ScheduledExportFiltersContext.js

@@ -7,10 +7,12 @@ export const ScheduledExportFiltersContextProvider = ScheduledExportFiltersConte
 /**
  * Reads the scheduled-export dialog's filter and export-parameter model.
  *
- * Throws outside the scheduled-export dialog's state providers, which mount only once
- * `useScheduledEmailDialogContext().isLoading` is false — a replacement for
- * `ScheduledEmailDialogComponent` must check that flag before calling this. That state is on the
- * ordinary path here: a widget export renders while its filters load.
+ * Throws outside the scheduled-export dialog's state providers, which mount the state model on
+ * the first render where `useScheduledEmailDialogContext().isLoading` is false and keep it
+ * mounted from then on — a replacement for `ScheduledEmailDialogComponent` must check that flag
+ * before reading state while the dialog first loads. That state is on the ordinary path here: a
+ * widget export renders while its filters load. An automations refresh flips `isLoading` back
+ * without unmounting the model, so the draft survives and this accessor keeps serving through it.
  *
  * @alpha
  */

package/esm/presentation/automations/scheduledEmail/state/missingScheduledExportStateProvider.js

@@ -5,5 +5,5 @@
  * @internal
  */
 export function missingScheduledExportStateProvider(accessor) {
-    throw new Error(`${accessor} must be used within ScheduledEmailDialogStateProvider. The provider mounts only once the dialog's data has loaded, so check useScheduledEmailDialogContext().isLoading before reading scheduled-export dialog state.`);
+    throw new Error(`${accessor} must be used within ScheduledEmailDialogStateProvider. The state model mounts once the dialog's data has first loaded, so check useScheduledEmailDialogContext().isLoading before reading scheduled-export dialog state.`);
 }

package/esm/presentation/automations/scheduledEmail/types.d.ts

@@ -627,7 +627,7 @@ export interface IScheduledEmailDialogShellProps extends Pick<IScheduledEmailDia
      * {@link useSaveScheduledEmailToBackend} instance. Drives the footer's submit button, the Enter key on
      * it, and the header's Enter-to-submit. The shell does not own the save hook, so the caller's own Enter
      * handlers — {@link useScheduledEmailSubmitOnEnter} — share the same instance. Create the hook instance
-     * only once the dialog context reports `isLoading: false`.
+     * only once the dialog's data has first loaded — the state hooks throw before then.
      */
     onSubmit: () => void;
     /**

package/esm/sdk-ui-dashboard.d.ts

@@ -795,8 +795,9 @@ export declare function AlertingDialogSensitivity(overrides: Partial<IAlertingDi
  * `AlertingDialogComponent` that keeps this chrome and arranges the blocks differently renders the shell
  * itself. The shell does not own the submit: call {@link useAlertSubmit} and pass its `submit` and
  * `isSaving`, so the footer button and any Enter handler in the body share one instance. Call that hook
- * only once `useAlertingDialogContext().isLoading` is false — the state hooks throw while the dialog
- * loads — and render the shell alone (any `onSubmit`, `isSaving: false`) until then, as the example does.
+ * only once `useAlertingDialogContext().isLoading` is first false — the state hooks throw until the
+ * dialog's data has first loaded (after that they stay available through a refresh) — and render the
+ * shell alone (any `onSubmit`, `isSaving: false`) until then, as the example does.
  *
  * Needs an ambient `IntlProvider`; inside a `Dashboard` the dashboard's provider covers it.
  *
@@ -804,7 +805,7 @@ export declare function AlertingDialogSensitivity(overrides: Partial<IAlertingDi
  * ```tsx
  * function MyAlertingDialog(props: IAlertingDialogProps) {
  *     const { isLoading } = useAlertingDialogContext();
- *     // the state hooks throw while the dialog loads; the shell renders the loading skeleton
+ *     // the state hooks throw until the dialog's data has first loaded; the shell shows the skeleton
  *     if (isLoading) {
  *         return <AlertingDialogShell {...props} onSubmit={() => {}} isSaving={false} />;
  *     }
@@ -4541,8 +4542,9 @@ export declare const DEFAULT_TAB_ID = "defaultTabId";
  * rendered within an `AutomationsContextProvider`, an `AlertingDialogContextProvider` (for the
  * create/edit flow), and an `AlertingDialogStateProvider`. Inside a `Dashboard`, the alerting
  * connector supplies the first two providers above the `AlertingDialogComponent` slot, and mounts
- * `AlertingDialogStateProvider` around the resolved slot component once
- * `useAlertingDialogContext().isLoading` is false — so the default component, and any wholesale
+ * `AlertingDialogStateProvider` around the resolved slot component — its state model establishes
+ * itself once `useAlertingDialogContext().isLoading` is first false and stays mounted from then
+ * on — so the default component, and any wholesale
  * slot replacement, inherit all three contexts automatically and require no extra wiring.
  *
  * The providers are intentionally hoisted above the slot rather than built inside this component:
@@ -4961,7 +4963,8 @@ export declare function DefaultSaveButton({ isVisible, isEnabled, isSaving, butt
  * export draft's state from those contexts rather than from the dashboard store. It must therefore
  * be rendered within an `AutomationsContextProvider`, a `ScheduledEmailDialogContextProvider` (for
  * the create/edit flow), and a `ScheduledEmailDialogStateProvider`, whose state model establishes
- * itself once `useScheduledEmailDialogContext().isLoading` is false. Inside a `Dashboard`, the
+ * itself once `useScheduledEmailDialogContext().isLoading` is first false and stays mounted from
+ * then on. Inside a `Dashboard`, the
  * scheduled export connector supplies the first two providers above the
  * `ScheduledEmailDialogComponent` slot and mounts `ScheduledEmailDialogStateProvider` around the
  * resolved slot component — so the default component, and any wholesale slot replacement, inherit
@@ -7290,7 +7293,7 @@ export declare interface IAlertingDialogShellProps extends Pick<IAlertingDialogP
      * The dialog's single submit — `submit` of the caller's {@link useAlertSubmit} instance. Drives the
      * footer's submit button and the Enter key on it. The shell does not own the submit hook, so a
      * caller's own Enter handler or button can share the same instance. Create the hook instance only
-     * once the dialog context reports `isLoading: false`.
+     * once the dialog's data has first loaded — the state hooks throw before then.
      */
     onSubmit: () => void;
     /**
@@ -19693,7 +19696,7 @@ export declare interface IScheduledEmailDialogShellProps extends Pick<IScheduled
      * {@link useSaveScheduledEmailToBackend} instance. Drives the footer's submit button, the Enter key on
      * it, and the header's Enter-to-submit. The shell does not own the save hook, so the caller's own Enter
      * handlers — {@link useScheduledEmailSubmitOnEnter} — share the same instance. Create the hook instance
-     * only once the dialog context reports `isLoading: false`.
+     * only once the dialog's data has first loaded — the state hooks throw before then.
      */
     onSubmit: () => void;
     /**
@@ -26478,9 +26481,9 @@ export declare function ScheduledEmailDialogRecurrence(props: Partial<IScheduled
  * shell itself. The shell does not own the save: call {@link useSaveScheduledEmailToBackend} and pass its
  * `handleSaveScheduledEmail`, `isSavingScheduledEmail` and `savingErrorMessage`; build Enter handlers for
  * the blocks you place with {@link useScheduledEmailSubmitOnEnter} over the same `handleSaveScheduledEmail`.
- * Call that hook only once `useScheduledEmailDialogContext().isLoading` is false — the state hooks throw
- * while the dialog loads — and render the shell alone (any `onSubmit`, `isSaving: false`) until then, as
- * the example does.
+ * Call that hook only once `useScheduledEmailDialogContext().isLoading` is first false — the state hooks
+ * throw until the dialog's data has first loaded (after that they stay available through a refresh) —
+ * and render the shell alone (any `onSubmit`, `isSaving: false`) until then, as the example does.
  *
  * Needs an ambient `IntlProvider`; inside a `Dashboard` the dashboard's provider covers it.
  *
@@ -26488,7 +26491,7 @@ export declare function ScheduledEmailDialogRecurrence(props: Partial<IScheduled
  * ```tsx
  * function MyScheduledEmailDialog(props: IScheduledEmailDialogProps) {
  *     const { isLoading } = useScheduledEmailDialogContext();
- *     // the state hooks throw while the dialog loads; the shell renders the loading skeleton
+ *     // the state hooks throw until the dialog's data has first loaded; the shell shows the skeleton
  *     if (isLoading) {
  *         return <ScheduledEmailDialogShell {...props} onSubmit={() => {}} isSaving={false} />;
  *     }
@@ -31757,10 +31760,11 @@ export declare function updateVisualizationsFromSwitcherWidgetContent(ref: ObjRe
 /**
  * Reads the alerting dialog's mutators.
  *
- * Throws outside the alerting dialog's state providers, which mount only once
- * `useAlertingDialogContext().isLoading` is false — a replacement for `AlertingDialogComponent`
- * must check that flag before calling this. On the alerting side that state is reached only by an
- * automations refresh while the dialog is open, so it will not appear in manual testing.
+ * Throws outside the alerting dialog's state providers, which mount the state model on the first
+ * render where `useAlertingDialogContext().isLoading` is false and keep it mounted from then on —
+ * a replacement for `AlertingDialogComponent` must check that flag before reading state while the
+ * dialog first loads. An automations refresh flips `isLoading` back without unmounting the model,
+ * so the draft survives and this accessor keeps serving through it.
  *
  * @alpha
  */
@@ -31769,10 +31773,11 @@ export declare function useAlertActions(): IAlertActionsContextValue;
 /**
  * Reads the data the alerting dialog loads asynchronously.
  *
- * Throws outside the alerting dialog's state providers, which mount only once
- * `useAlertingDialogContext().isLoading` is false — a replacement for `AlertingDialogComponent`
- * must check that flag before calling this. On the alerting side that state is reached only by an
- * automations refresh while the dialog is open, so it will not appear in manual testing.
+ * Throws outside the alerting dialog's state providers, which mount the state model on the first
+ * render where `useAlertingDialogContext().isLoading` is false and keep it mounted from then on —
+ * a replacement for `AlertingDialogComponent` must check that flag before reading state while the
+ * dialog first loads. An automations refresh flips `isLoading` back without unmounting the model,
+ * so the draft survives and this accessor keeps serving through it.
  *
  * @alpha
  */
@@ -31790,10 +31795,11 @@ export declare function useAlertDialogValidity(): IAlertDialogValidity;
 /**
  * Reads the alerting dialog's edit draft.
  *
- * Throws outside the alerting dialog's state providers, which mount only once
- * `useAlertingDialogContext().isLoading` is false — a replacement for `AlertingDialogComponent`
- * must check that flag before calling this. On the alerting side that state is reached only by an
- * automations refresh while the dialog is open, so it will not appear in manual testing.
+ * Throws outside the alerting dialog's state providers, which mount the state model on the first
+ * render where `useAlertingDialogContext().isLoading` is false and keep it mounted from then on —
+ * a replacement for `AlertingDialogComponent` must check that flag before reading state while the
+ * dialog first loads. An automations refresh flips `isLoading` back without unmounting the model,
+ * so the draft survives and this accessor keeps serving through it.
  *
  * @alpha
  */
@@ -31802,10 +31808,11 @@ export declare function useAlertDraft(): IAlertDraftContextValue;
 /**
  * Reads the alerting dialog's filter and export-parameter model.
  *
- * Throws outside the alerting dialog's state providers, which mount only once
- * `useAlertingDialogContext().isLoading` is false — a replacement for `AlertingDialogComponent`
- * must check that flag before calling this. On the alerting side that state is reached only by an
- * automations refresh while the dialog is open, so it will not appear in manual testing.
+ * Throws outside the alerting dialog's state providers, which mount the state model on the first
+ * render where `useAlertingDialogContext().isLoading` is false and keep it mounted from then on —
+ * a replacement for `AlertingDialogComponent` must check that flag before reading state while the
+ * dialog first loads. An automations refresh flips `isLoading` back without unmounting the model,
+ * so the draft survives and this accessor keeps serving through it.
  *
  * @alpha
  */
@@ -32660,10 +32667,12 @@ export declare function useScheduledEmailSubmitOnEnter({ onSubmit, isSaving, }:
 /**
  * Reads the scheduled-export dialog's draft mutators.
  *
- * Throws outside the scheduled-export dialog's state providers, which mount only once
- * `useScheduledEmailDialogContext().isLoading` is false — a replacement for
- * `ScheduledEmailDialogComponent` must check that flag before calling this. That state is on the
- * ordinary path here: a widget export renders while its filters load.
+ * Throws outside the scheduled-export dialog's state providers, which mount the state model on
+ * the first render where `useScheduledEmailDialogContext().isLoading` is false and keep it
+ * mounted from then on — a replacement for `ScheduledEmailDialogComponent` must check that flag
+ * before reading state while the dialog first loads. That state is on the ordinary path here: a
+ * widget export renders while its filters load. An automations refresh flips `isLoading` back
+ * without unmounting the model, so the draft survives and this accessor keeps serving through it.
  *
  * @alpha
  */
@@ -32686,10 +32695,12 @@ export declare function useScheduledExportAttachments(): IScheduledExportAttachm
 /**
  * Reads the scheduled-export dialog's recipient defaults.
  *
- * Throws outside the scheduled-export dialog's state providers, which mount only once
- * `useScheduledEmailDialogContext().isLoading` is false — a replacement for
- * `ScheduledEmailDialogComponent` must check that flag before calling this. That state is on the
- * ordinary path here: a widget export renders while its filters load.
+ * Throws outside the scheduled-export dialog's state providers, which mount the state model on
+ * the first render where `useScheduledEmailDialogContext().isLoading` is false and keep it
+ * mounted from then on — a replacement for `ScheduledEmailDialogComponent` must check that flag
+ * before reading state while the dialog first loads. That state is on the ordinary path here: a
+ * widget export renders while its filters load. An automations refresh flips `isLoading` back
+ * without unmounting the model, so the draft survives and this accessor keeps serving through it.
  *
  * @alpha
  */
@@ -32710,10 +32721,12 @@ export declare function useScheduledExportDialogValidity(): IScheduledExportDial
 /**
  * Reads the scheduled-export dialog's edit draft.
  *
- * Throws outside the scheduled-export dialog's state providers, which mount only once
- * `useScheduledEmailDialogContext().isLoading` is false — a replacement for
- * `ScheduledEmailDialogComponent` must check that flag before calling this. That state is on the
- * ordinary path here: a widget export renders while its filters load.
+ * Throws outside the scheduled-export dialog's state providers, which mount the state model on
+ * the first render where `useScheduledEmailDialogContext().isLoading` is false and keep it
+ * mounted from then on — a replacement for `ScheduledEmailDialogComponent` must check that flag
+ * before reading state while the dialog first loads. That state is on the ordinary path here: a
+ * widget export renders while its filters load. An automations refresh flips `isLoading` back
+ * without unmounting the model, so the draft survives and this accessor keeps serving through it.
  *
  * @alpha
  */
@@ -32722,10 +32735,12 @@ export declare function useScheduledExportDraft(): IScheduledExportDraftContextV
 /**
  * Reads the scheduled-export dialog's filter and export-parameter model.
  *
- * Throws outside the scheduled-export dialog's state providers, which mount only once
- * `useScheduledEmailDialogContext().isLoading` is false — a replacement for
- * `ScheduledEmailDialogComponent` must check that flag before calling this. That state is on the
- * ordinary path here: a widget export renders while its filters load.
+ * Throws outside the scheduled-export dialog's state providers, which mount the state model on
+ * the first render where `useScheduledEmailDialogContext().isLoading` is false and keep it
+ * mounted from then on — a replacement for `ScheduledEmailDialogComponent` must check that flag
+ * before reading state while the dialog first loads. That state is on the ordinary path here: a
+ * widget export renders while its filters load. An automations refresh flips `isLoading` back
+ * without unmounting the model, so the draft survives and this accessor keeps serving through it.
  *
  * @alpha
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddata/sdk-ui-dashboard",
-  "version": "11.56.0-alpha.4",
+  "version": "11.56.0-alpha.5",
   "description": "GoodData SDK - Dashboard Component",
   "license": "LicenseRef-LICENSE",
   "author": "GoodData Corporation",
@@ -60,20 +60,20 @@
     "ts-invariant": "0.10.3",
     "tslib": "2.8.1",
     "uuid": "11.1.1",
-    "@gooddata/sdk-backend-base": "11.56.0-alpha.4",
-    "@gooddata/sdk-backend-spi": "11.56.0-alpha.4",
-    "@gooddata/sdk-ui": "11.56.0-alpha.4",
-    "@gooddata/sdk-ui-charts": "11.56.0-alpha.4",
-    "@gooddata/sdk-ui-ext": "11.56.0-alpha.4",
-    "@gooddata/sdk-model": "11.56.0-alpha.4",
-    "@gooddata/sdk-ui-filters": "11.56.0-alpha.4",
-    "@gooddata/sdk-ui-geo": "11.56.0-alpha.4",
-    "@gooddata/sdk-ui-semantic-search": "11.56.0-alpha.4",
-    "@gooddata/sdk-ui-pivot": "11.56.0-alpha.4",
-    "@gooddata/sdk-ui-theme-provider": "11.56.0-alpha.4",
-    "@gooddata/sdk-ui-kit": "11.56.0-alpha.4",
-    "@gooddata/sdk-ui-vis-commons": "11.56.0-alpha.4",
-    "@gooddata/util": "11.56.0-alpha.4"
+    "@gooddata/sdk-backend-base": "11.56.0-alpha.5",
+    "@gooddata/sdk-ui": "11.56.0-alpha.5",
+    "@gooddata/sdk-model": "11.56.0-alpha.5",
+    "@gooddata/sdk-backend-spi": "11.56.0-alpha.5",
+    "@gooddata/sdk-ui-charts": "11.56.0-alpha.5",
+    "@gooddata/sdk-ui-ext": "11.56.0-alpha.5",
+    "@gooddata/sdk-ui-filters": "11.56.0-alpha.5",
+    "@gooddata/sdk-ui-geo": "11.56.0-alpha.5",
+    "@gooddata/sdk-ui-semantic-search": "11.56.0-alpha.5",
+    "@gooddata/sdk-ui-kit": "11.56.0-alpha.5",
+    "@gooddata/sdk-ui-theme-provider": "11.56.0-alpha.5",
+    "@gooddata/util": "11.56.0-alpha.5",
+    "@gooddata/sdk-ui-pivot": "11.56.0-alpha.5",
+    "@gooddata/sdk-ui-vis-commons": "11.56.0-alpha.5"
   },
   "devDependencies": {
     "@microsoft/api-documenter": "7.30.10",
@@ -116,12 +116,12 @@
     "typescript": "6.0.3",
     "vitest": "4.1.8",
     "vitest-dom": "0.1.1",
-    "@gooddata/eslint-config": "11.56.0-alpha.4",
-    "@gooddata/i18n-toolkit": "11.56.0-alpha.4",
-    "@gooddata/oxlint-config": "11.56.0-alpha.4",
-    "@gooddata/reference-workspace": "11.56.0-alpha.4",
-    "@gooddata/sdk-backend-mockingbird": "11.56.0-alpha.4",
-    "@gooddata/stylelint-config": "11.56.0-alpha.4"
+    "@gooddata/eslint-config": "11.56.0-alpha.5",
+    "@gooddata/i18n-toolkit": "11.56.0-alpha.5",
+    "@gooddata/reference-workspace": "11.56.0-alpha.5",
+    "@gooddata/oxlint-config": "11.56.0-alpha.5",
+    "@gooddata/sdk-backend-mockingbird": "11.56.0-alpha.5",
+    "@gooddata/stylelint-config": "11.56.0-alpha.5"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",