@gooddata/sdk-ui-dashboard 11.52.0-alpha.4 → 11.52.0-alpha.6

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":"AAwCA,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,aAAa,CAAC;AA4BxD,wBAAgB,sBAAsB,CAAC,EACnC,QAAQ,EACR,eAAe,EACf,aAAa,EACb,OAAO,EACP,SAAS,EACT,WAAW,EACX,aAAa,EAChB,EAAE,oBAAoB,2CAwhBtB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,oBAAoB,2CAchE"}
+{"version":3,"file":"DefaultAlertingDialog.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/DefaultAlertingDialog/DefaultAlertingDialog.tsx"],"names":[],"mappings":"AA8CA,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,aAAa,CAAC;AA4BxD,wBAAgB,sBAAsB,CAAC,EACnC,QAAQ,EACR,eAAe,EACf,aAAa,EACb,OAAO,EACP,SAAS,EACT,WAAW,EACX,aAAa,EAChB,EAAE,oBAAoB,2CAwiBtB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,oBAAoB,2CAchE"}

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

@@ -12,6 +12,12 @@ import { RecipientsSelect } from "../../scheduledEmail/DefaultScheduledEmailDial
 import { ApplyCurrentFiltersConfirmDialog } from "../../shared/automationFilters/components/ApplyLatestFiltersConfirmDialog.js";
 import { AutomationFiltersSelect } from "../../shared/automationFilters/components/AutomationFiltersSelect.js";
 import { DeleteAlertConfirmDialog } from "../DefaultAlertingManagementDialog/components/DeleteAlertConfirmDialog.js";
+import { useAlertActions } from "../state/AlertActionsContext.js";
+import { useAlertData } from "../state/AlertDataContext.js";
+import { useAlertDraft } from "../state/AlertDraftContext.js";
+import { useAlertFilters } from "../state/AlertFiltersContext.js";
+import { useAlertDialogValidity } from "../state/useAlertDialogValidity.js";
+import { useAlertSelectedValues } from "../state/useAlertSelectedValues.js";
 import { AlertingDialogHeader } from "./AlertingDialogHeader.js";
 import { AlertAttributeSelect } from "./components/AlertAttributeSelect.js";
 import { AlertComparisonOperatorSelect } from "./components/AlertComparisonOperatorSelect.js";
@@ -28,7 +34,7 @@ import { AlertTriggerModeSelect } from "./components/AlertTriggerModeSelect.js";
 import { ALERTING_DIALOG_ID } from "./constants.js";
 import { DefaultLoadingAlertingDialog } from "./DefaultLoadingAlertingDialog.js";
 import { useAlertSubmit } from "./hooks/useAlertSubmit.js";
-import { useEditAlert } from "./hooks/useEditAlert.js";
+import { useAlertThreshold } from "./hooks/useAlertThreshold.js";
 import { getValueSuffix } from "./utils/getters.js";
 import { isAnomalyDetection, isChangeOrDifferenceOperator } from "./utils/guards.js";
 import { isMobileView } from "./utils/responsive.js";
@@ -38,17 +44,29 @@ const overlayController = OverlayController.getInstance(DASHBOARD_DIALOG_OVERS_Z
 export function AlertingDialogRenderer({ onCancel, onDeleteSuccess, onDeleteError, onError, onSuccess, onSaveError, onSaveSuccess, }) {
     const intl = useIntl();
     const dialogTitleRef = useRef(null);
-    const { isWhiteLabeled, isSecondaryTitleVisible, externalRecipient: externalRecipientOverride, maxAutomationsRecipients, isExecutionTimestampMode, features: { enableAlertOncePerInterval, enableAnomalyDetectionAlert, canUseAiAssistant: enableAiAssistant, }, } = useAutomationsContext();
-    const { widgetTitle, alertToEdit } = useAlertingDialogContext();
+    const { isWhiteLabeled, isSecondaryTitleVisible, externalRecipient: externalRecipientOverride, maxAutomationsRecipients, isExecutionTimestampMode, features: { enableAlertOncePerInterval, enableAnomalyDetectionAlert, canUseAiAssistant: enableAiAssistant, }, catalogAttributes, catalogDateDatasets, separators, allowHourlyRecurrence, } = useAutomationsContext();
+    const { widgetTitle, alertToEdit, notificationChannels } = useAlertingDialogContext();
     const [alertToDelete, setAlertToDelete] = useState(null);
     const handleAlertDeleteSuccess = (alert) => {
         onDeleteSuccess?.(alert);
         setAlertToDelete(null);
     };
-    const { onTitleChange, onRecipientsChange, selectedFilters, availableFilters, onFiltersChange, onApplyCurrentFilters, automationIsValid, filtersAreStale, dropStaleParameters, automationParameters, availableParameters, onParameterChange, onParameterDelete, onParameterAdd, onMeasureChange, getAttributeValues, onAttributeChange, onComparisonOperatorChange, onRelativeOperatorChange, onAnomalyDetectionChange, onChange, onBlur, onComparisonTypeChange, onDestinationChange, onTriggerModeChange, onTriggerIntervalChange, selectedMeasure, canChangeMeasure, supportedMeasures, selectedAttribute, selectedValue, supportedAttributes, catalogAttributes, catalogDateDatasets, isResultLoading, selectedComparisonOperator, selectedRelativeOperator, selectedAiOperator, value, selectedComparator, selectedSensitivity, onSensitivityChange, selectedGranularity, onGranularityChange, separators, defaultUser, originalAutomation, editedAutomation, allowOnlyLoggedUserRecipients, allowExternalRecipients, warningMessage, validationErrorMessage, isInvalidConnectionToInsight, isSubmitDisabled, isParentValid, thresholdErrorMessage, allowHourlyRecurrence, notificationChannels, } = useEditAlert({
-        maxAutomationsRecipients,
-        externalRecipientOverride,
+    const { editedAutomation, originalAutomation, warningMessage } = useAlertDraft();
+    const { onTitleChange, onRecipientsChange, onMeasureChange, onAttributeChange, onComparisonOperatorChange, onRelativeOperatorChange, onAnomalyDetectionChange, onComparisonTypeChange, onDestinationChange, onTriggerModeChange, onTriggerIntervalChange, onSensitivityChange, onGranularityChange, setEditedAutomation, } = useAlertActions();
+    const { supportedMeasures, supportedAttributes, isResultLoading, getAttributeValues, defaultUser, getMetricValue, } = useAlertData();
+    const { selectedFilters, availableFilters, onFiltersChange, onApplyCurrentFilters, automationIsValid, filtersAreStale, automationParameters, availableParameters, onParameterChange, onParameterDelete, onParameterAdd, dropStaleParameters, } = useAlertFilters();
+    const { selectedMeasure, selectedComparisonOperator, selectedRelativeOperator, selectedAiOperator, selectedComparator, selectedSensitivity, selectedGranularity, selectedAttribute, selectedValue, allowExternalRecipients, allowOnlyLoggedUserRecipients, } = useAlertSelectedValues();
+    const { value, onChange, onBlur, thresholdErrorMessage } = useAlertThreshold({
+        setEditedAutomation,
+        editedAutomation,
+        getMetricValue,
+        isNewAlert: !alertToEdit,
+        selectedRelativeOperator,
+        selectedMeasure,
+        selectedAttribute,
+        selectedValue,
     });
+    const { isSubmitDisabled, validationErrorMessage, isParentValid, canChangeMeasure, isInvalidConnectionToInsight, } = useAlertDialogValidity();
     const [isApplyCurrentFiltersDialogOpen, setIsApplyCurrentFiltersDialogOpen] = useState(!automationIsValid);
     const { isSaving, submit } = useAlertSubmit({
         editedAutomation,
@@ -142,12 +160,15 @@ export function AlertingDialogRenderer({ onCancel, onDeleteSuccess, onDeleteErro
 /**
  * Default implementation of the alerting create/edit dialog.
  *
- * This component is a pure consumer of `AutomationsContext` and `AlertingDialogContext`: it reads
- * org/workspace data and per-dialog state from those contexts rather than from the dashboard store.
- * It must therefore be rendered within an `AutomationsContextProvider` (and, for the create/edit
- * flow, an `AlertingDialogContextProvider`). Inside a `Dashboard`, the alerting connector supplies
- * both providers above the `AlertingDialogComponent` slot — so the default component, and any
- * wholesale slot replacement, inherit the contexts automatically and require no extra wiring.
+ * This component is a pure consumer of `AutomationsContext`, `AlertingDialogContext`, and the
+ * alerting dialog state contexts: it reads org/workspace data, per-dialog state, and the alert
+ * draft's state from those contexts rather than from the dashboard store. It must therefore be
+ * 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
+ * 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:
  * that is what lets a wholesale replacement receive the same contexts. Rendering this component

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

@@ -11,6 +11,15 @@ export interface IUseAlertThresholdProps {
     selectedAttribute: AlertAttribute | undefined;
     selectedValue: string | null | undefined;
 }
+/**
+ * Owns the alerting dialog's threshold field: the displayed value, its change and blur handlers,
+ * and its validation message.
+ *
+ * Writes the draft — its effect auto-computes the comparison threshold when the selection changes
+ * and clears it for relative operators — so exactly one consumer per dialog tree may call it.
+ *
+ * @internal
+ */
 export declare function useAlertThreshold({ setEditedAutomation, editedAutomation, getMetricValue, isNewAlert, selectedRelativeOperator, selectedMeasure, selectedAttribute, selectedValue }: IUseAlertThresholdProps): {
     value: number | undefined;
     onChange: (e: string | number, event?: import("react").ChangeEvent<HTMLInputElement> | undefined) => void;

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

@@ -1 +1 @@
-{"version":3,"file":"useAlertThreshold.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/automations/alerting/DefaultAlertingDialog/hooks/useAlertThreshold.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,cAAc,EAAe,MAAM,OAAO,CAAC;AAExE,OAAO,EACH,KAAK,gCAAgC,EACrC,KAAK,sBAAsB,EAC3B,KAAK,UAAU,EAEf,KAAK,mCAAmC,EACxC,KAAK,QAAQ,EAChB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAKvE,MAAM,WAAW,uBAAuB;IACpC,mBAAmB,EAAE,QAAQ,CAAC,cAAc,CAAC,mCAAmC,GAAG,SAAS,CAAC,CAAC,CAAC;IAC/F,gBAAgB,EAAE,mCAAmC,GAAG,SAAS,CAAC;IAClE,cAAc,EAAE,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAE,UAAU,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,KAAK,MAAM,GAAG,SAAS,CAAC;IACrG,UAAU,EAAE,OAAO,CAAC;IACpB,wBAAwB,EAAE,CAAC,sBAAsB,EAAE,gCAAgC,CAAC,GAAG,SAAS,CAAC;IACjG,eAAe,EAAE,WAAW,GAAG,SAAS,CAAC;IACzC,iBAAiB,EAAE,cAAc,GAAG,SAAS,CAAC;IAC9C,aAAa,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CAC5C;AAED,wBAAgB,iBAAiB,CAAC,EAC9B,mBAAmB,EACnB,gBAAgB,EAChB,cAAc,EACd,UAAU,EACV,wBAAwB,EACxB,eAAe,EACf,iBAAiB,EACjB,aAAa,EAChB,EAAE,uBAAuB;;;;;EAgCzB"}
+{"version":3,"file":"useAlertThreshold.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/automations/alerting/DefaultAlertingDialog/hooks/useAlertThreshold.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,cAAc,EAAe,MAAM,OAAO,CAAC;AAExE,OAAO,EACH,KAAK,gCAAgC,EACrC,KAAK,sBAAsB,EAC3B,KAAK,UAAU,EAEf,KAAK,mCAAmC,EACxC,KAAK,QAAQ,EAChB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAKvE,MAAM,WAAW,uBAAuB;IACpC,mBAAmB,EAAE,QAAQ,CAAC,cAAc,CAAC,mCAAmC,GAAG,SAAS,CAAC,CAAC,CAAC;IAC/F,gBAAgB,EAAE,mCAAmC,GAAG,SAAS,CAAC;IAClE,cAAc,EAAE,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAE,UAAU,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,KAAK,MAAM,GAAG,SAAS,CAAC;IACrG,UAAU,EAAE,OAAO,CAAC;IACpB,wBAAwB,EAAE,CAAC,sBAAsB,EAAE,gCAAgC,CAAC,GAAG,SAAS,CAAC;IACjG,eAAe,EAAE,WAAW,GAAG,SAAS,CAAC;IACzC,iBAAiB,EAAE,cAAc,GAAG,SAAS,CAAC;IAC9C,aAAa,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CAC5C;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,EAC9B,mBAAmB,EACnB,gBAAgB,EAChB,cAAc,EACd,UAAU,EACV,wBAAwB,EACxB,eAAe,EACf,iBAAiB,EACjB,aAAa,EAChB,EAAE,uBAAuB;;;;;EAgCzB"}

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

@@ -2,6 +2,15 @@
 import { useCallback } from "react";
 import { transformAlertByValue } from "../utils/transformation.js";
 import { useThresholdValue } from "./useThresholdValue.js";
+/**
+ * Owns the alerting dialog's threshold field: the displayed value, its change and blur handlers,
+ * and its validation message.
+ *
+ * Writes the draft — its effect auto-computes the comparison threshold when the selection changes
+ * and clears it for relative operators — so exactly one consumer per dialog tree may call it.
+ *
+ * @internal
+ */
 export function useAlertThreshold({ setEditedAutomation, editedAutomation, getMetricValue, isNewAlert, selectedRelativeOperator, selectedMeasure, selectedAttribute, selectedValue, }) {
     const onValueChange = useCallback((value) => {
         setEditedAutomation((alert) => alert ? transformAlertByValue(alert, value) : undefined);

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

@@ -0,0 +1,23 @@
+import { type useAlertFormState } from "./useAlertFormState.js";
+/**
+ * The alerting dialog's mutators: the draft setter and every form change-handler.
+ *
+ * Changes rarely: `onGranularityChange` is re-created when `triggerIntervalDirty` toggles or the
+ * supported measures load. The shape is derived from `useAlertFormState`, which owns them.
+ *
+ * @internal
+ */
+export type IAlertActionsContextValue = Pick<ReturnType<typeof useAlertFormState>, "setEditedAutomation" | "onTitleChange" | "onMeasureChange" | "onAttributeChange" | "onComparisonOperatorChange" | "onRelativeOperatorChange" | "onAnomalyDetectionChange" | "onComparisonTypeChange" | "onSensitivityChange" | "onTriggerIntervalChange" | "onGranularityChange" | "onDestinationChange" | "onTriggerModeChange" | "onRecipientsChange">;
+export declare const AlertActionsContextProvider: import("react").Provider<IAlertActionsContextValue | undefined>;
+/**
+ * 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.
+ *
+ * @internal
+ */
+export declare function useAlertActions(): IAlertActionsContextValue;
+//# sourceMappingURL=AlertActionsContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AlertActionsContext.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/state/AlertActionsContext.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE;;;;;;;GAOG;AACH,MAAM,MAAM,yBAAyB,GAAG,IAAI,CACxC,UAAU,CAAC,OAAO,iBAAiB,CAAC,EAClC,qBAAqB,GACrB,eAAe,GACf,iBAAiB,GACjB,mBAAmB,GACnB,4BAA4B,GAC5B,0BAA0B,GAC1B,0BAA0B,GAC1B,wBAAwB,GACxB,qBAAqB,GACrB,yBAAyB,GACzB,qBAAqB,GACrB,qBAAqB,GACrB,qBAAqB,GACrB,oBAAoB,CACzB,CAAC;AAKF,eAAO,MAAM,2BAA2B,iEAA+B,CAAC;AAExE;;;;;;;;;GASG;AACH,wBAAgB,eAAe,IAAI,yBAAyB,CAE3D"}

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

@@ -0,0 +1,19 @@
+// (C) 2026 GoodData Corporation
+import { createContext, useContext } from "react";
+import { missingAlertStateProvider } from "./missingAlertStateProvider.js";
+const AlertActionsContext = createContext(undefined);
+AlertActionsContext.displayName = "AlertActionsContext";
+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.
+ *
+ * @internal
+ */
+export function useAlertActions() {
+    return useContext(AlertActionsContext) ?? missingAlertStateProvider("useAlertActions");
+}

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

@@ -0,0 +1,24 @@
+import { type useAlertFormState } from "./useAlertFormState.js";
+import { type useAlertSupportedMetrics } from "./useAlertSupportedMetrics.js";
+/**
+ * The data the alerting dialog loads asynchronously: the supported measures and attributes with
+ * their formats, the execution-result readers, and the current user's default recipients.
+ *
+ * Changes when an async load resolves, not per keystroke.
+ *
+ * @internal
+ */
+export type IAlertDataContextValue = Pick<ReturnType<typeof useAlertSupportedMetrics>, "supportedMeasures" | "supportedAttributes" | "measureFormatMap" | "isResultLoading" | "getAttributeValues" | "getMetricValue"> & Pick<ReturnType<typeof useAlertFormState>, "defaultUser" | "defaultRecipient">;
+export declare const AlertDataContextProvider: import("react").Provider<IAlertDataContextValue | undefined>;
+/**
+ * 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.
+ *
+ * @internal
+ */
+export declare function useAlertData(): IAlertDataContextValue;
+//# sourceMappingURL=AlertDataContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AlertDataContext.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/state/AlertDataContext.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAE9E;;;;;;;GAOG;AACH,MAAM,MAAM,sBAAsB,GAAG,IAAI,CACrC,UAAU,CAAC,OAAO,wBAAwB,CAAC,EACzC,mBAAmB,GACnB,qBAAqB,GACrB,kBAAkB,GAClB,iBAAiB,GACjB,oBAAoB,GACpB,gBAAgB,CACrB,GACG,IAAI,CAAC,UAAU,CAAC,OAAO,iBAAiB,CAAC,EAAE,aAAa,GAAG,kBAAkB,CAAC,CAAC;AAKnF,eAAO,MAAM,wBAAwB,8DAA4B,CAAC;AAElE;;;;;;;;;GASG;AACH,wBAAgB,YAAY,IAAI,sBAAsB,CAErD"}

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

@@ -0,0 +1,19 @@
+// (C) 2026 GoodData Corporation
+import { createContext, useContext } from "react";
+import { missingAlertStateProvider } from "./missingAlertStateProvider.js";
+const AlertDataContext = createContext(undefined);
+AlertDataContext.displayName = "AlertDataContext";
+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.
+ *
+ * @internal
+ */
+export function useAlertData() {
+    return useContext(AlertDataContext) ?? missingAlertStateProvider("useAlertData");
+}

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

@@ -0,0 +1,24 @@
+import { type useAlertFormState } from "./useAlertFormState.js";
+/**
+ * The alerting dialog's edit draft: the automation being edited, the baseline it is compared
+ * against, and the form-level warning and title-validity flag that move with it.
+ *
+ * Changes on every keystroke; consumers re-render by design. The shape is derived from
+ * `useAlertFormState`, which owns these values.
+ *
+ * @internal
+ */
+export type IAlertDraftContextValue = Pick<ReturnType<typeof useAlertFormState>, "editedAutomation" | "originalAutomation" | "warningMessage" | "isTitleValid">;
+export declare const AlertDraftContextProvider: import("react").Provider<IAlertDraftContextValue | undefined>;
+/**
+ * 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.
+ *
+ * @internal
+ */
+export declare function useAlertDraft(): IAlertDraftContextValue;
+//# sourceMappingURL=AlertDraftContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AlertDraftContext.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/state/AlertDraftContext.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE;;;;;;;;GAQG;AACH,MAAM,MAAM,uBAAuB,GAAG,IAAI,CACtC,UAAU,CAAC,OAAO,iBAAiB,CAAC,EACpC,kBAAkB,GAAG,oBAAoB,GAAG,gBAAgB,GAAG,cAAc,CAChF,CAAC;AAKF,eAAO,MAAM,yBAAyB,+DAA6B,CAAC;AAEpE;;;;;;;;;GASG;AACH,wBAAgB,aAAa,IAAI,uBAAuB,CAEvD"}

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

@@ -0,0 +1,19 @@
+// (C) 2026 GoodData Corporation
+import { createContext, useContext } from "react";
+import { missingAlertStateProvider } from "./missingAlertStateProvider.js";
+const AlertDraftContext = createContext(undefined);
+AlertDraftContext.displayName = "AlertDraftContext";
+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.
+ *
+ * @internal
+ */
+export function useAlertDraft() {
+    return useContext(AlertDraftContext) ?? missingAlertStateProvider("useAlertDraft");
+}

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

@@ -0,0 +1,26 @@
+import { type useAlertFiltersModel } from "./useAlertFiltersModel.js";
+import { type useAlertFormState } from "./useAlertFormState.js";
+/**
+ * The alerting dialog's filter and export-parameter model: the current selection, the available
+ * filters, the two filter mutators and the staleness flags, plus the automation's execution
+ * parameters and their mutators.
+ *
+ * Changes when a filter or a parameter is edited. The shape is derived from
+ * `useAlertFiltersModel` and from the parameter members `useAlertFormState` re-exports.
+ *
+ * @internal
+ */
+export type IAlertFiltersContextValue = Pick<ReturnType<typeof useAlertFiltersModel>, "selectedFilters" | "availableFilters" | "onFiltersChange" | "onApplyCurrentFilters" | "automationIsValid" | "filtersAreStale"> & Pick<ReturnType<typeof useAlertFormState>, "automationParameters" | "availableParameters" | "onParameterChange" | "onParameterDelete" | "onParameterAdd" | "dropStaleParameters">;
+export declare const AlertFiltersContextProvider: import("react").Provider<IAlertFiltersContextValue | undefined>;
+/**
+ * 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.
+ *
+ * @internal
+ */
+export declare function useAlertFilters(): IAlertFiltersContextValue;
+//# sourceMappingURL=AlertFiltersContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AlertFiltersContext.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/state/AlertFiltersContext.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACtE,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE;;;;;;;;;GASG;AACH,MAAM,MAAM,yBAAyB,GAAG,IAAI,CACxC,UAAU,CAAC,OAAO,oBAAoB,CAAC,EACrC,iBAAiB,GACjB,kBAAkB,GAClB,iBAAiB,GACjB,uBAAuB,GACvB,mBAAmB,GACnB,iBAAiB,CACtB,GACG,IAAI,CACA,UAAU,CAAC,OAAO,iBAAiB,CAAC,EAClC,sBAAsB,GACtB,qBAAqB,GACrB,mBAAmB,GACnB,mBAAmB,GACnB,gBAAgB,GAChB,qBAAqB,CAC1B,CAAC;AAKN,eAAO,MAAM,2BAA2B,iEAA+B,CAAC;AAExE;;;;;;;;;GASG;AACH,wBAAgB,eAAe,IAAI,yBAAyB,CAE3D"}

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

@@ -0,0 +1,19 @@
+// (C) 2026 GoodData Corporation
+import { createContext, useContext } from "react";
+import { missingAlertStateProvider } from "./missingAlertStateProvider.js";
+const AlertFiltersContext = createContext(undefined);
+AlertFiltersContext.displayName = "AlertFiltersContext";
+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.
+ *
+ * @internal
+ */
+export function useAlertFilters() {
+    return useContext(AlertFiltersContext) ?? missingAlertStateProvider("useAlertFilters");
+}

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

@@ -0,0 +1,21 @@
+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.
+ *
+ * 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.
+ *
+ * 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
+ * throws in react-intl.
+ *
+ * @internal
+ */
+export declare function AlertingDialogStateProvider({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=AlertingDialogStateProvider.d.ts.map

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

@@ -0,0 +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;AAehD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,2BAA2B,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,2CAIhF"}

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

@@ -0,0 +1,168 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { useMemo } from "react";
+import { useAlertingDialogContext } from "../../contexts/AlertingDialogContext.js";
+import { useAutomationsContext } from "../../contexts/AutomationsContext.js";
+import { useAutomationFiltersSelect } from "../../shared/automationFilters/useAutomationFiltersSelect.js";
+import { AlertActionsContextProvider } from "./AlertActionsContext.js";
+import { AlertDataContextProvider } from "./AlertDataContext.js";
+import { AlertDraftContextProvider } from "./AlertDraftContext.js";
+import { AlertFiltersContextProvider } from "./AlertFiltersContext.js";
+import { useAlertFiltersModel } from "./useAlertFiltersModel.js";
+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.
+ *
+ * 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.
+ *
+ * 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
+ * throws in react-intl.
+ *
+ * @internal
+ */
+export function AlertingDialogStateProvider({ children }) {
+    const { isLoading } = useAlertingDialogContext();
+    return isLoading ? _jsx(_Fragment, { children: children }) : _jsx(LoadedAlertingDialogState, { children: children });
+}
+function LoadedAlertingDialogState({ children }) {
+    const { weekStart, timezone, externalRecipient } = useAutomationsContext();
+    const { hiddenFilters: dashboardHiddenFilters, commonDateFilterId, alertToEdit, notificationChannels, widget, insight, } = useAlertingDialogContext();
+    const { editedAutomationFilters, setEditedAutomationFilters, availableFilters, availableFiltersAsVisibleFilters, filtersForNewAutomation, } = useAutomationFiltersSelect({ automationToEdit: alertToEdit, widget });
+    const { measureFormatMap, supportedMeasures, supportedAttributes, isResultLoading, getAttributeValues, getMetricValue, } = useAlertSupportedMetrics({ insight, widget, alertToEdit });
+    const formState = useAlertFormState({
+        alertToEdit,
+        insight,
+        widget,
+        notificationChannels,
+        editedAutomationFilters,
+        availableFiltersAsVisibleFilters,
+        externalRecipientOverride: externalRecipient,
+        supportedMeasures,
+        supportedAttributes,
+        measureFormatMap,
+    });
+    const { selectedMeasure, selectedAttribute, selectedValue } = getAlertSelectedValues({
+        editedAutomation: formState.editedAutomation,
+        supportedMeasures,
+        supportedAttributes,
+        notificationChannels,
+    });
+    const filtersModel = useAlertFiltersModel({
+        setEditedAutomation: formState.setEditedAutomation,
+        alertToEdit,
+        editedAutomationFilters,
+        setEditedAutomationFilters,
+        availableFilters,
+        filtersForNewAutomation,
+        availableFiltersAsVisibleFilters,
+        dashboardHiddenFilters,
+        commonDateFilterId,
+        widget,
+        insight,
+        supportedMeasures,
+        supportedAttributes,
+        measureFormatMap,
+        selectedMeasure,
+        selectedAttribute,
+        selectedValue,
+        weekStart,
+        timezone,
+    });
+    const draft = useMemo(() => ({
+        editedAutomation: formState.editedAutomation,
+        originalAutomation: formState.originalAutomation,
+        warningMessage: formState.warningMessage,
+        isTitleValid: formState.isTitleValid,
+    }), [
+        formState.editedAutomation,
+        formState.originalAutomation,
+        formState.warningMessage,
+        formState.isTitleValid,
+    ]);
+    const actions = useMemo(() => ({
+        setEditedAutomation: formState.setEditedAutomation,
+        onTitleChange: formState.onTitleChange,
+        onMeasureChange: formState.onMeasureChange,
+        onAttributeChange: formState.onAttributeChange,
+        onComparisonOperatorChange: formState.onComparisonOperatorChange,
+        onRelativeOperatorChange: formState.onRelativeOperatorChange,
+        onAnomalyDetectionChange: formState.onAnomalyDetectionChange,
+        onComparisonTypeChange: formState.onComparisonTypeChange,
+        onSensitivityChange: formState.onSensitivityChange,
+        onTriggerIntervalChange: formState.onTriggerIntervalChange,
+        onGranularityChange: formState.onGranularityChange,
+        onDestinationChange: formState.onDestinationChange,
+        onTriggerModeChange: formState.onTriggerModeChange,
+        onRecipientsChange: formState.onRecipientsChange,
+    }), [
+        formState.setEditedAutomation,
+        formState.onTitleChange,
+        formState.onMeasureChange,
+        formState.onAttributeChange,
+        formState.onComparisonOperatorChange,
+        formState.onRelativeOperatorChange,
+        formState.onAnomalyDetectionChange,
+        formState.onComparisonTypeChange,
+        formState.onSensitivityChange,
+        formState.onTriggerIntervalChange,
+        formState.onGranularityChange,
+        formState.onDestinationChange,
+        formState.onTriggerModeChange,
+        formState.onRecipientsChange,
+    ]);
+    const data = useMemo(() => ({
+        supportedMeasures,
+        supportedAttributes,
+        measureFormatMap,
+        isResultLoading,
+        getAttributeValues,
+        getMetricValue,
+        defaultUser: formState.defaultUser,
+        defaultRecipient: formState.defaultRecipient,
+    }), [
+        supportedMeasures,
+        supportedAttributes,
+        measureFormatMap,
+        isResultLoading,
+        getAttributeValues,
+        getMetricValue,
+        formState.defaultUser,
+        formState.defaultRecipient,
+    ]);
+    const filters = useMemo(() => ({
+        selectedFilters: filtersModel.selectedFilters,
+        availableFilters: filtersModel.availableFilters,
+        onFiltersChange: filtersModel.onFiltersChange,
+        onApplyCurrentFilters: filtersModel.onApplyCurrentFilters,
+        automationIsValid: filtersModel.automationIsValid,
+        filtersAreStale: filtersModel.filtersAreStale,
+        automationParameters: formState.automationParameters,
+        availableParameters: formState.availableParameters,
+        onParameterChange: formState.onParameterChange,
+        onParameterDelete: formState.onParameterDelete,
+        onParameterAdd: formState.onParameterAdd,
+        dropStaleParameters: formState.dropStaleParameters,
+    }), [
+        filtersModel.selectedFilters,
+        filtersModel.availableFilters,
+        filtersModel.onFiltersChange,
+        filtersModel.onApplyCurrentFilters,
+        filtersModel.automationIsValid,
+        filtersModel.filtersAreStale,
+        formState.automationParameters,
+        formState.availableParameters,
+        formState.onParameterChange,
+        formState.onParameterDelete,
+        formState.onParameterAdd,
+        formState.dropStaleParameters,
+    ]);
+    return (_jsx(AlertDraftContextProvider, { value: draft, children: _jsx(AlertActionsContextProvider, { value: actions, children: _jsx(AlertDataContextProvider, { value: data, children: _jsx(AlertFiltersContextProvider, { value: filters, children: children }) }) }) }));
+}

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

@@ -0,0 +1,7 @@
+/**
+ * The single error every alerting dialog state accessor throws when no provider is above it.
+ *
+ * @internal
+ */
+export declare function missingAlertStateProvider(accessor: string): never;
+//# sourceMappingURL=missingAlertStateProvider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"missingAlertStateProvider.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/state/missingAlertStateProvider.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,GAAG,KAAK,CAIjE"}

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

@@ -0,0 +1,9 @@
+// (C) 2026 GoodData Corporation
+/**
+ * The single error every alerting dialog state accessor throws when no provider is above it.
+ *
+ * @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.`);
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Reads the alerting dialog's validity: whether submit is enabled, the validation message to show,
+ * whether the parent widget is still valid, whether the measure may be changed, and whether the
+ * saved alert points at a widget whose insight is gone.
+ *
+ * @internal
+ */
+export declare function useAlertDialogValidity(): {
+    isSubmitDisabled: boolean;
+    validationErrorMessage: string | undefined;
+    isParentValid: boolean;
+    canChangeMeasure: boolean;
+    isInvalidConnectionToInsight: boolean;
+};
+//# sourceMappingURL=useAlertDialogValidity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useAlertDialogValidity.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/state/useAlertDialogValidity.ts"],"names":[],"mappings":"AAUA;;;;;;GAMG;AACH,wBAAgB,sBAAsB,IAAI;IACtC,gBAAgB,EAAE,OAAO,CAAC;IAC1B,sBAAsB,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3C,aAAa,EAAE,OAAO,CAAC;IACvB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,4BAA4B,EAAE,OAAO,CAAC;CACzC,CAkCA"}

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

@@ -0,0 +1,45 @@
+// (C) 2026 GoodData Corporation
+import { useAlertingDialogContext } from "../../contexts/AlertingDialogContext.js";
+import { useAutomationsContext } from "../../contexts/AutomationsContext.js";
+import { useAlertData } from "./AlertDataContext.js";
+import { useAlertDraft } from "./AlertDraftContext.js";
+import { useAlertFormValidation } from "./useAlertFormValidation.js";
+import { useAlertSelectedValues } from "./useAlertSelectedValues.js";
+/**
+ * Reads the alerting dialog's validity: whether submit is enabled, the validation message to show,
+ * whether the parent widget is still valid, whether the measure may be changed, and whether the
+ * saved alert points at a widget whose insight is gone.
+ *
+ * @internal
+ */
+export function useAlertDialogValidity() {
+    const { catalogDateDatasets, maxAutomationsRecipients } = useAutomationsContext();
+    const { alertToEdit, widget, insight } = useAlertingDialogContext();
+    const { editedAutomation, originalAutomation, isTitleValid } = useAlertDraft();
+    const { defaultRecipient } = useAlertData();
+    const { selectedNotificationChannel, allowExternalRecipients, allowOnlyLoggedUserRecipients } = useAlertSelectedValues();
+    const canChangeMeasure = !!insight;
+    const isInvalidConnectionToInsight = !!alertToEdit?.metadata?.widget && !insight;
+    const { isSubmitDisabled, validationErrorMessage, isParentValid } = useAlertFormValidation({
+        editedAutomation,
+        originalAutomation,
+        alertToEdit,
+        widget,
+        insight,
+        catalogDateDatasets,
+        isInvalidConnectionToInsight,
+        selectedNotificationChannel,
+        allowExternalRecipients,
+        allowOnlyLoggedUserRecipients,
+        maxAutomationsRecipients,
+        defaultRecipient,
+        isTitleValid,
+    });
+    return {
+        isSubmitDisabled,
+        validationErrorMessage,
+        isParentValid,
+        canChangeMeasure,
+        isInvalidConnectionToInsight,
+    };
+}