@gooddata/sdk-ui-dashboard 11.55.0-alpha.1 → 11.55.0-alpha.3

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

@@ -0,0 +1,12 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * A heading with a column of field rows under it — the default alerting dialog's "When" (the condition
+ * fields) and "Do" (the action fields) groups. Layout only; reads no dialog context.
+ *
+ * @alpha
+ */
+export function AlertingDialogFormFieldGroup({ label, children, }) {
+    return (_jsxs("div", { className: "gd-input-component gd-input-component--no-last-child-margin gd-dashboard-alerting-dialog-form-field-group", children: [
+            _jsx("div", { className: "gd-dashboard-alerting-dialog-form-field-group__label-container", children: _jsx("label", { className: "gd-label gd-dashboard-alerting-dialog-form-field-group__label", children: label }) }), _jsx("div", { className: "gd-dashboard-alerting-dialog-form-field-group__content-container", children: children })
+        ] }));
+}

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

@@ -0,0 +1,15 @@
+import { type ReactElement } from "react";
+import { type IAlertingDialogGranularityProps } from "../types.js";
+/**
+ * The alerting dialog's granularity field (the period anomaly detection evaluates over), connected
+ * to the dialog's state and rendered as a labelled form row.
+ *
+ * Renders {@link DefaultAlertingDialogGranularity} inside {@link AutomationDialogFormField} with
+ * the props of {@link useAlertingDialogGranularityProps}; every prop passed here replaces the
+ * hook's value for that prop wholesale. Renders nothing unless the draft uses anomaly detection,
+ * and nothing while `useAlertingDialogContext().isLoading` is true.
+ *
+ * @alpha
+ */
+export declare function AlertingDialogGranularity(overrides: Partial<IAlertingDialogGranularityProps>): ReactElement;
+//# sourceMappingURL=AlertingDialogGranularity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AlertingDialogGranularity.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/blocks/AlertingDialogGranularity.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAQ1C,OAAO,EAAE,KAAK,+BAA+B,EAAE,MAAM,aAAa,CAAC;AASnE;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,OAAO,CAAC,+BAA+B,CAAC,GAAG,YAAY,CAM3G"}

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

@@ -0,0 +1,33 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { defineMessage } from "react-intl";
+import { AutomationDialogFormField } from "../../shared/slots/AutomationDialogFormField.js";
+import { DefaultAlertingDialogGranularity } from "../DefaultAlertingDialog/DefaultAlertingDialogGranularity.js";
+import { useAlertDraft } from "../state/AlertDraftContext.js";
+import { useAlertingDialogGranularityProps } from "../state/useAlertingDialogFieldProps.js";
+import { isAnomalyDetection } from "../utils/guards.js";
+import { AlertingDialogFieldLabelWithTooltip } from "./AlertingDialogFieldLabelWithTooltip.js";
+import { WhenAlertingDialogLoaded } from "./WhenAlertingDialogLoaded.js";
+const GRANULARITY_LABEL = defineMessage({ id: "insightAlert.config.granularity" });
+const GRANULARITY_TOOLTIP = defineMessage({ id: "insightAlert.config.granularity.tooltip" });
+/**
+ * The alerting dialog's granularity field (the period anomaly detection evaluates over), connected
+ * to the dialog's state and rendered as a labelled form row.
+ *
+ * Renders {@link DefaultAlertingDialogGranularity} inside {@link AutomationDialogFormField} with
+ * the props of {@link useAlertingDialogGranularityProps}; every prop passed here replaces the
+ * hook's value for that prop wholesale. Renders nothing unless the draft uses anomaly detection,
+ * and nothing while `useAlertingDialogContext().isLoading` is true.
+ *
+ * @alpha
+ */
+export function AlertingDialogGranularity(overrides) {
+    return (_jsx(WhenAlertingDialogLoaded, { children: _jsx(ConnectedAlertingDialogGranularity, { ...overrides }) }));
+}
+function ConnectedAlertingDialogGranularity(overrides) {
+    const props = { ...useAlertingDialogGranularityProps(), ...overrides };
+    const { editedAutomation } = useAlertDraft();
+    if (!isAnomalyDetection(editedAutomation?.alert)) {
+        return null;
+    }
+    return (_jsx(AutomationDialogFormField, { label: _jsx(AlertingDialogFieldLabelWithTooltip, { label: GRANULARITY_LABEL, tooltip: GRANULARITY_TOOLTIP }), htmlFor: props.id, children: _jsx(DefaultAlertingDialogGranularity, { ...props }) }));
+}

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

@@ -0,0 +1,30 @@
+import { type ReactElement } from "react";
+import { type IAlertingDialogMeasureProps } from "../types.js";
+/**
+ * The alerting dialog's measure field ("Metric": the measure the condition targets), connected to
+ * the dialog's state and rendered as a labelled form row.
+ *
+ * Renders {@link DefaultAlertingDialogMeasure} inside {@link AutomationDialogFormField} with the
+ * props of {@link useAlertingDialogMeasureProps}; every prop passed here replaces the hook's value
+ * for that prop wholesale. Renders nothing while `useAlertingDialogContext().isLoading` is true.
+ * The row's label is the default dialog's — a shell that wants its own label renders the hook and
+ * the render component inside its own `AutomationDialogFormField`.
+ *
+ * @example
+ * ```tsx
+ * function MyAlertingDialog(props: IAlertingDialogProps) {
+ *     return (
+ *         <MyShell onClose={props.onCancel}>
+ *             <AlertingDialogMeasure />
+ *             <AlertingDialogComparisonOperator />
+ *             <AlertingDialogThreshold />
+ *         </MyShell>
+ *     );
+ * }
+ * <Dashboard AlertingDialogComponent={MyAlertingDialog} />;
+ * ```
+ *
+ * @alpha
+ */
+export declare function AlertingDialogMeasure(overrides: Partial<IAlertingDialogMeasureProps>): ReactElement;
+//# sourceMappingURL=AlertingDialogMeasure.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AlertingDialogMeasure.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/blocks/AlertingDialogMeasure.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAO1C,OAAO,EAAE,KAAK,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAI/D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,OAAO,CAAC,2BAA2B,CAAC,GAAG,YAAY,CAMnG"}

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

@@ -0,0 +1,39 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { FormattedMessage } from "react-intl";
+import { AutomationDialogFormField } from "../../shared/slots/AutomationDialogFormField.js";
+import { DefaultAlertingDialogMeasure } from "../DefaultAlertingDialog/DefaultAlertingDialogMeasure.js";
+import { useAlertingDialogMeasureProps } from "../state/useAlertingDialogFieldProps.js";
+import { WhenAlertingDialogLoaded } from "./WhenAlertingDialogLoaded.js";
+/**
+ * The alerting dialog's measure field ("Metric": the measure the condition targets), connected to
+ * the dialog's state and rendered as a labelled form row.
+ *
+ * Renders {@link DefaultAlertingDialogMeasure} inside {@link AutomationDialogFormField} with the
+ * props of {@link useAlertingDialogMeasureProps}; every prop passed here replaces the hook's value
+ * for that prop wholesale. Renders nothing while `useAlertingDialogContext().isLoading` is true.
+ * The row's label is the default dialog's — a shell that wants its own label renders the hook and
+ * the render component inside its own `AutomationDialogFormField`.
+ *
+ * @example
+ * ```tsx
+ * function MyAlertingDialog(props: IAlertingDialogProps) {
+ *     return (
+ *         <MyShell onClose={props.onCancel}>
+ *             <AlertingDialogMeasure />
+ *             <AlertingDialogComparisonOperator />
+ *             <AlertingDialogThreshold />
+ *         </MyShell>
+ *     );
+ * }
+ * <Dashboard AlertingDialogComponent={MyAlertingDialog} />;
+ * ```
+ *
+ * @alpha
+ */
+export function AlertingDialogMeasure(overrides) {
+    return (_jsx(WhenAlertingDialogLoaded, { children: _jsx(ConnectedAlertingDialogMeasure, { ...overrides }) }));
+}
+function ConnectedAlertingDialogMeasure(overrides) {
+    const props = { ...useAlertingDialogMeasureProps(), ...overrides };
+    return (_jsx(AutomationDialogFormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.metric" }), htmlFor: props.id, children: _jsx(DefaultAlertingDialogMeasure, { ...props }) }));
+}

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

@@ -0,0 +1,15 @@
+import { type ReactElement } from "react";
+import { type IAlertingDialogSensitivityProps } from "../types.js";
+/**
+ * The alerting dialog's sensitivity field (the "Sensitivity" of anomaly detection), connected to
+ * the dialog's state and rendered as a labelled form row.
+ *
+ * Renders {@link DefaultAlertingDialogSensitivity} inside {@link AutomationDialogFormField} with
+ * the props of {@link useAlertingDialogSensitivityProps}; every prop passed here replaces the
+ * hook's value for that prop wholesale. Renders nothing unless the draft uses anomaly detection,
+ * and nothing while `useAlertingDialogContext().isLoading` is true.
+ *
+ * @alpha
+ */
+export declare function AlertingDialogSensitivity(overrides: Partial<IAlertingDialogSensitivityProps>): ReactElement;
+//# sourceMappingURL=AlertingDialogSensitivity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AlertingDialogSensitivity.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/blocks/AlertingDialogSensitivity.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAQ1C,OAAO,EAAE,KAAK,+BAA+B,EAAE,MAAM,aAAa,CAAC;AAKnE;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,OAAO,CAAC,+BAA+B,CAAC,GAAG,YAAY,CAM3G"}

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

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { FormattedMessage } from "react-intl";
+import { AutomationDialogFormField } from "../../shared/slots/AutomationDialogFormField.js";
+import { DefaultAlertingDialogSensitivity } from "../DefaultAlertingDialog/DefaultAlertingDialogSensitivity.js";
+import { useAlertDraft } from "../state/AlertDraftContext.js";
+import { useAlertingDialogSensitivityProps } from "../state/useAlertingDialogFieldProps.js";
+import { isAnomalyDetection } from "../utils/guards.js";
+import { WhenAlertingDialogLoaded } from "./WhenAlertingDialogLoaded.js";
+/**
+ * The alerting dialog's sensitivity field (the "Sensitivity" of anomaly detection), connected to
+ * the dialog's state and rendered as a labelled form row.
+ *
+ * Renders {@link DefaultAlertingDialogSensitivity} inside {@link AutomationDialogFormField} with
+ * the props of {@link useAlertingDialogSensitivityProps}; every prop passed here replaces the
+ * hook's value for that prop wholesale. Renders nothing unless the draft uses anomaly detection,
+ * and nothing while `useAlertingDialogContext().isLoading` is true.
+ *
+ * @alpha
+ */
+export function AlertingDialogSensitivity(overrides) {
+    return (_jsx(WhenAlertingDialogLoaded, { children: _jsx(ConnectedAlertingDialogSensitivity, { ...overrides }) }));
+}
+function ConnectedAlertingDialogSensitivity(overrides) {
+    const props = { ...useAlertingDialogSensitivityProps(), ...overrides };
+    const { editedAutomation } = useAlertDraft();
+    if (!isAnomalyDetection(editedAutomation?.alert)) {
+        return null;
+    }
+    return (_jsx(AutomationDialogFormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.sensitivity" }), htmlFor: props.id, children: _jsx(DefaultAlertingDialogSensitivity, { ...props }) }));
+}

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

@@ -0,0 +1,49 @@
+import { type ReactElement } from "react";
+import { type IAlertingDialogShellProps } from "../types.js";
+/**
+ * The alerting dialog's chrome, connected to the dialog's state: the modal overlay, the dialog frame
+ * with the header row (the title input) and the action bar, the scrollable content area around
+ * `children`, the dialog's warning and validation messages, the stale-filters confirmation step shown
+ * before the dialog when the saved filters no longer match the dashboard, and the delete confirmation
+ * reached from the action bar in edit mode. While `useAlertingDialogContext().isLoading` is true it
+ * renders the loading skeleton and none of its children.
+ *
+ * The default dialog is `<AlertingDialogShell>` around the region and field blocks; a custom
+ * `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.
+ *
+ * Needs an ambient `IntlProvider`; inside a `Dashboard` the dashboard's provider covers it.
+ *
+ * @example
+ * ```tsx
+ * function MyAlertingDialog(props: IAlertingDialogProps) {
+ *     const { isLoading } = useAlertingDialogContext();
+ *     // the state hooks throw while the dialog loads; the shell renders the loading skeleton
+ *     if (isLoading) {
+ *         return <AlertingDialogShell {...props} onSubmit={() => {}} isSaving={false} />;
+ *     }
+ *     return <MyAlertingDialogBody {...props} />;
+ * }
+ *
+ * function MyAlertingDialogBody(props: IAlertingDialogProps) {
+ *     const { isSaving, submit } = useAlertSubmit(props);
+ *     return (
+ *         <AlertingDialogShell {...props} onSubmit={() => void submit()} isSaving={isSaving}>
+ *             <AlertingDialogFormFieldGroup label="When">
+ *                 <AlertingDialogMeasure />
+ *                 <AlertingDialogComparisonOperator />
+ *                 <AlertingDialogThreshold />
+ *             </AlertingDialogFormFieldGroup>
+ *             <AlertingDialogRecipients />
+ *         </AlertingDialogShell>
+ *     );
+ * }
+ * ```
+ *
+ * @alpha
+ */
+export declare function AlertingDialogShell(props: IAlertingDialogShellProps): ReactElement;
+//# sourceMappingURL=AlertingDialogShell.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,128 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { useEffect, useRef, useState } from "react";
+import { useIntl } from "react-intl";
+import { ValidationContextStore, createInvalidDatapoint, createInvalidNode, useValidationContextValue, } from "@gooddata/sdk-ui";
+import { ConfirmDialogBase, Message, Overlay, OverlayController, OverlayControllerProvider, ScrollablePanel, useId, } from "@gooddata/sdk-ui-kit";
+import { DASHBOARD_DIALOG_OVERS_Z_INDEX } from "../../../constants/zIndex.js";
+import { useAlertingDialogContext } from "../../contexts/AlertingDialogContext.js";
+import { ApplyCurrentFiltersConfirmDialog } from "../../shared/automationFilters/components/ApplyLatestFiltersConfirmDialog.js";
+import { DefaultAutomationDialogActionBar } from "../../shared/slots/DefaultAutomationDialogActionBar.js";
+import { ALERTING_DIALOG_ID } from "../DefaultAlertingDialog/constants.js";
+import { DefaultAlertingDialogHeader } from "../DefaultAlertingDialog/DefaultAlertingDialogHeader.js";
+import { DeleteAlertConfirmDialog } from "../DefaultAlertingManagementDialog/components/DeleteAlertConfirmDialog.js";
+import { useAlertDraft } from "../state/AlertDraftContext.js";
+import { useAlertFilters } from "../state/AlertFiltersContext.js";
+import { useAlertDialogValidity } from "../state/useAlertDialogValidity.js";
+import { useAlertingDialogActionBarProps, useAlertingDialogHeaderProps, } from "../state/useAlertingDialogRegionProps.js";
+import { DefaultLoadingAlertingDialog } from "./DefaultLoadingAlertingDialog.js";
+const overlayController = OverlayController.getInstance(DASHBOARD_DIALOG_OVERS_Z_INDEX);
+/**
+ * The alerting dialog's chrome, connected to the dialog's state: the modal overlay, the dialog frame
+ * with the header row (the title input) and the action bar, the scrollable content area around
+ * `children`, the dialog's warning and validation messages, the stale-filters confirmation step shown
+ * before the dialog when the saved filters no longer match the dashboard, and the delete confirmation
+ * reached from the action bar in edit mode. While `useAlertingDialogContext().isLoading` is true it
+ * renders the loading skeleton and none of its children.
+ *
+ * The default dialog is `<AlertingDialogShell>` around the region and field blocks; a custom
+ * `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.
+ *
+ * Needs an ambient `IntlProvider`; inside a `Dashboard` the dashboard's provider covers it.
+ *
+ * @example
+ * ```tsx
+ * function MyAlertingDialog(props: IAlertingDialogProps) {
+ *     const { isLoading } = useAlertingDialogContext();
+ *     // the state hooks throw while the dialog loads; the shell renders the loading skeleton
+ *     if (isLoading) {
+ *         return <AlertingDialogShell {...props} onSubmit={() => {}} isSaving={false} />;
+ *     }
+ *     return <MyAlertingDialogBody {...props} />;
+ * }
+ *
+ * function MyAlertingDialogBody(props: IAlertingDialogProps) {
+ *     const { isSaving, submit } = useAlertSubmit(props);
+ *     return (
+ *         <AlertingDialogShell {...props} onSubmit={() => void submit()} isSaving={isSaving}>
+ *             <AlertingDialogFormFieldGroup label="When">
+ *                 <AlertingDialogMeasure />
+ *                 <AlertingDialogComparisonOperator />
+ *                 <AlertingDialogThreshold />
+ *             </AlertingDialogFormFieldGroup>
+ *             <AlertingDialogRecipients />
+ *         </AlertingDialogShell>
+ *     );
+ * }
+ * ```
+ *
+ * @alpha
+ */
+export function AlertingDialogShell(props) {
+    const { isLoading, alertToEdit } = useAlertingDialogContext();
+    if (isLoading) {
+        return _jsx(DefaultLoadingAlertingDialog, { onCancel: props.onCancel, alertToEdit: alertToEdit });
+    }
+    return _jsx(LoadedAlertingDialogShell, { ...props });
+}
+function LoadedAlertingDialogShell({ onCancel, onDeleteSuccess, onDeleteError, onSubmit, isSaving, slots, topContent, bottomContent, children, }) {
+    const HeaderSlot = slots?.Header;
+    const ActionBarSlot = slots?.ActionBar;
+    const intl = useIntl();
+    const dialogTitleRef = useRef(null);
+    const { alertToEdit } = useAlertingDialogContext();
+    const [alertToDelete, setAlertToDelete] = useState(null);
+    const handleAlertDeleteSuccess = (alert) => {
+        onDeleteSuccess?.(alert);
+        setAlertToDelete(null);
+    };
+    const { warningMessage } = useAlertDraft();
+    const { onApplyCurrentFilters, automationIsValid, filtersAreStale, dropStaleParameters } = useAlertFilters();
+    const { validationErrorMessage, isInvalidConnectionToInsight } = useAlertDialogValidity();
+    const [isApplyCurrentFiltersDialogOpen, setIsApplyCurrentFiltersDialogOpen] = useState(!automationIsValid);
+    const headerDefaultProps = useAlertingDialogHeaderProps({ onCancel, ref: dialogTitleRef });
+    const actionBarDefaultProps = useAlertingDialogActionBarProps({
+        onCancel,
+        onSubmit,
+        isSaving,
+        onDelete: () => setAlertToDelete(alertToEdit),
+    });
+    const validationContextValue = useValidationContextValue(createInvalidNode({ id: "AlertingDialog" }));
+    const { setInvalidDatapoints, getInvalidDatapoints } = validationContextValue;
+    const invalidDatapoints = getInvalidDatapoints();
+    useEffect(() => {
+        setInvalidDatapoints(() => [
+            !!validationErrorMessage &&
+                createInvalidDatapoint({
+                    message: validationErrorMessage,
+                    severity: isInvalidConnectionToInsight ? "error" : "warning",
+                }),
+        ]);
+    }, [validationErrorMessage, isInvalidConnectionToInsight, setInvalidDatapoints]);
+    const titleElementId = useId();
+    if (isApplyCurrentFiltersDialogOpen) {
+        return (_jsx(ApplyCurrentFiltersConfirmDialog, { automationType: "alert", onCancel: () => onCancel?.(), onEdit: () => {
+                // Repair only what is actually stale: replace filters when they are invalid, and
+                // drop catalog-absent parameters. A valid saved filter set survives a param-only fix.
+                if (filtersAreStale) {
+                    onApplyCurrentFilters();
+                }
+                dropStaleParameters();
+                setIsApplyCurrentFiltersDialogOpen(false);
+            } }));
+    }
+    return (_jsxs(_Fragment, { children: [
+            _jsx(Overlay, { className: "gd-notifications-channels-dialog-overlay", isModal: true, positionType: "fixed", ensureVisibility: true, children: _jsx(OverlayControllerProvider, { overlayController: overlayController, children: _jsx(ValidationContextStore, { value: validationContextValue, children: _jsxs(ConfirmDialogBase, { className: "gd-notifications-channels-dialog s-gd-notifications-channels-dialog gd-dialog--wide gd-notifications-channels-dialog--wide", accessibilityConfig: {
+                                closeButton: {
+                                    ariaLabel: intl.formatMessage({ id: "dialogs.alert.closeLabel" }),
+                                },
+                                titleElementId,
+                                dialogId: ALERTING_DIALOG_ID,
+                            }, returnFocusAfterClose: false, footerRenderer: () => ActionBarSlot ? (_jsx(ActionBarSlot, { Default: DefaultAutomationDialogActionBar, defaultProps: actionBarDefaultProps })) : (_jsx(DefaultAutomationDialogActionBar, { ...actionBarDefaultProps })), isSubmitDisabled: actionBarDefaultProps.isSubmitDisabled, initialFocus: dialogTitleRef, submitOnEnterKey: false, onCancel: onCancel, onSubmit: actionBarDefaultProps.onSubmit, headline: undefined, headerLeftButtonRenderer: () => HeaderSlot ? (_jsx(HeaderSlot, { Default: DefaultAlertingDialogHeader, defaultProps: headerDefaultProps })) : (_jsx(DefaultAlertingDialogHeader, { ...headerDefaultProps })), children: [
+                                _jsx("h2", { className: "sr-only", id: titleElementId, children: intl.formatMessage({ id: "dialogs.alert.accessibility.label.title" }) }), _jsxs(ScrollablePanel, { className: "gd-notifications-channel-dialog-content-wrapper gd-notification-channel-dialog-with-automation-filters", children: [topContent, _jsx("div", { className: "gd-divider-with-margin" }), children, warningMessage ? (_jsx(Message, { type: "warning", className: "gd-notifications-channels-dialog-error", children: warningMessage })) : null, invalidDatapoints.map((datapoint) => (_jsx(Message, { id: datapoint.id, type: datapoint.severity === "info" ? "progress" : datapoint.severity, className: "gd-notifications-channels-dialog-error gd-notifications-channels-dialog-error-scrollable", children: datapoint.message }, datapoint.id))), bottomContent] })
+                            ] }) }) }) }), alertToDelete ? (_jsx(DeleteAlertConfirmDialog, { alert: alertToDelete, onCancel: () => setAlertToDelete(null), onSuccess: handleAlertDeleteSuccess, onError: onDeleteError })) : null] }));
+}

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

@@ -0,0 +1,21 @@
+import { type ReactElement } from "react";
+import { type IAlertingDialogThresholdProps } from "../types.js";
+/**
+ * The alerting dialog's threshold field (the value a fixed-threshold, change or difference
+ * condition is compared against), connected to the dialog's state and rendered as a labelled form
+ * row.
+ *
+ * Renders {@link DefaultAlertingDialogThreshold} inside {@link AutomationDialogFormField} with the
+ * props of {@link useAlertingDialogThresholdProps}; every prop passed here replaces the hook's
+ * value for that prop wholesale. **The one `useAlertThreshold` mount**:
+ * {@link useAlertingDialogThresholdProps} owns the field's state and writes the draft
+ * (auto-computing a new alert's threshold), so place this block once per dialog and do not also
+ * call the hook. Renders nothing while the draft uses anomaly detection (that condition has no
+ * threshold); the hook stays mounted behind the gate, so the field's touched state survives a
+ * switch to anomaly detection and back. Renders nothing while
+ * `useAlertingDialogContext().isLoading` is true.
+ *
+ * @alpha
+ */
+export declare function AlertingDialogThreshold(overrides: Partial<IAlertingDialogThresholdProps>): ReactElement;
+//# sourceMappingURL=AlertingDialogThreshold.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AlertingDialogThreshold.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/blocks/AlertingDialogThreshold.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAQ1C,OAAO,EAAE,KAAK,6BAA6B,EAAE,MAAM,aAAa,CAAC;AAKjE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,OAAO,CAAC,6BAA6B,CAAC,GAAG,YAAY,CAMvG"}

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

@@ -0,0 +1,36 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { FormattedMessage } from "react-intl";
+import { AutomationDialogFormField } from "../../shared/slots/AutomationDialogFormField.js";
+import { DefaultAlertingDialogThreshold } from "../DefaultAlertingDialog/DefaultAlertingDialogThreshold.js";
+import { useAlertDraft } from "../state/AlertDraftContext.js";
+import { useAlertingDialogThresholdProps } from "../state/useAlertingDialogFieldProps.js";
+import { isAnomalyDetection } from "../utils/guards.js";
+import { WhenAlertingDialogLoaded } from "./WhenAlertingDialogLoaded.js";
+/**
+ * The alerting dialog's threshold field (the value a fixed-threshold, change or difference
+ * condition is compared against), connected to the dialog's state and rendered as a labelled form
+ * row.
+ *
+ * Renders {@link DefaultAlertingDialogThreshold} inside {@link AutomationDialogFormField} with the
+ * props of {@link useAlertingDialogThresholdProps}; every prop passed here replaces the hook's
+ * value for that prop wholesale. **The one `useAlertThreshold` mount**:
+ * {@link useAlertingDialogThresholdProps} owns the field's state and writes the draft
+ * (auto-computing a new alert's threshold), so place this block once per dialog and do not also
+ * call the hook. Renders nothing while the draft uses anomaly detection (that condition has no
+ * threshold); the hook stays mounted behind the gate, so the field's touched state survives a
+ * switch to anomaly detection and back. Renders nothing while
+ * `useAlertingDialogContext().isLoading` is true.
+ *
+ * @alpha
+ */
+export function AlertingDialogThreshold(overrides) {
+    return (_jsx(WhenAlertingDialogLoaded, { children: _jsx(ConnectedAlertingDialogThreshold, { ...overrides }) }));
+}
+function ConnectedAlertingDialogThreshold(overrides) {
+    const props = { ...useAlertingDialogThresholdProps(), ...overrides };
+    const { editedAutomation } = useAlertDraft();
+    if (isAnomalyDetection(editedAutomation?.alert)) {
+        return null;
+    }
+    return (_jsx(AutomationDialogFormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.threshold" }), htmlFor: props.id, children: _jsx(DefaultAlertingDialogThreshold, { ...props }) }));
+}

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

@@ -0,0 +1,15 @@
+import { type ReactElement } from "react";
+import { type IAlertingDialogTriggerIntervalProps } from "../types.js";
+/**
+ * The alerting dialog's trigger-interval field (the interval a once-per-interval trigger notifies
+ * on), connected to the dialog's state and rendered as a labelled form row.
+ *
+ * Renders {@link DefaultAlertingDialogTriggerInterval} inside {@link AutomationDialogFormField}
+ * with the props of {@link useAlertingDialogTriggerIntervalProps}; every prop passed here replaces
+ * the hook's value for that prop wholesale. Renders nothing unless the draft's trigger mode is
+ * `ONCE_PER_INTERVAL`, and nothing while `useAlertingDialogContext().isLoading` is true.
+ *
+ * @alpha
+ */
+export declare function AlertingDialogTriggerInterval(overrides: Partial<IAlertingDialogTriggerIntervalProps>): ReactElement;
+//# sourceMappingURL=AlertingDialogTriggerInterval.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AlertingDialogTriggerInterval.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/blocks/AlertingDialogTriggerInterval.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAQ1C,OAAO,EAAE,KAAK,mCAAmC,EAAE,MAAM,aAAa,CAAC;AAQvE;;;;;;;;;;GAUG;AACH,wBAAgB,6BAA6B,CACzC,SAAS,EAAE,OAAO,CAAC,mCAAmC,CAAC,GACxD,YAAY,CAMd"}

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

@@ -0,0 +1,32 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { defineMessage } from "react-intl";
+import { AutomationDialogFormField } from "../../shared/slots/AutomationDialogFormField.js";
+import { DefaultAlertingDialogTriggerInterval } from "../DefaultAlertingDialog/DefaultAlertingDialogTriggerInterval.js";
+import { useAlertDraft } from "../state/AlertDraftContext.js";
+import { useAlertingDialogTriggerIntervalProps } from "../state/useAlertingDialogFieldProps.js";
+import { AlertingDialogFieldLabelWithTooltip } from "./AlertingDialogFieldLabelWithTooltip.js";
+import { WhenAlertingDialogLoaded } from "./WhenAlertingDialogLoaded.js";
+const INTERVAL_LABEL = defineMessage({ id: "insightAlert.config.interval" });
+const INTERVAL_TOOLTIP = defineMessage({ id: "insightAlert.config.interval.tooltip" });
+/**
+ * The alerting dialog's trigger-interval field (the interval a once-per-interval trigger notifies
+ * on), connected to the dialog's state and rendered as a labelled form row.
+ *
+ * Renders {@link DefaultAlertingDialogTriggerInterval} inside {@link AutomationDialogFormField}
+ * with the props of {@link useAlertingDialogTriggerIntervalProps}; every prop passed here replaces
+ * the hook's value for that prop wholesale. Renders nothing unless the draft's trigger mode is
+ * `ONCE_PER_INTERVAL`, and nothing while `useAlertingDialogContext().isLoading` is true.
+ *
+ * @alpha
+ */
+export function AlertingDialogTriggerInterval(overrides) {
+    return (_jsx(WhenAlertingDialogLoaded, { children: _jsx(ConnectedAlertingDialogTriggerInterval, { ...overrides }) }));
+}
+function ConnectedAlertingDialogTriggerInterval(overrides) {
+    const props = { ...useAlertingDialogTriggerIntervalProps(), ...overrides };
+    const { editedAutomation } = useAlertDraft();
+    if (editedAutomation?.alert?.trigger.mode !== "ONCE_PER_INTERVAL") {
+        return null;
+    }
+    return (_jsx(AutomationDialogFormField, { label: _jsx(AlertingDialogFieldLabelWithTooltip, { label: INTERVAL_LABEL, tooltip: INTERVAL_TOOLTIP }), htmlFor: props.id, children: _jsx(DefaultAlertingDialogTriggerInterval, { ...props }) }));
+}

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

@@ -0,0 +1,15 @@
+import { type ReactElement } from "react";
+import { type IAlertingDialogTriggerModeProps } from "../types.js";
+/**
+ * The alerting dialog's trigger-mode field ("Trigger": how often a met condition notifies),
+ * connected to the dialog's state and rendered as a labelled form row.
+ *
+ * Renders {@link DefaultAlertingDialogTriggerMode} inside {@link AutomationDialogFormField} with
+ * the props of {@link useAlertingDialogTriggerModeProps}; every prop passed here replaces the
+ * hook's value for that prop wholesale. Renders nothing while
+ * `useAlertingDialogContext().isLoading` is true.
+ *
+ * @alpha
+ */
+export declare function AlertingDialogTriggerMode(overrides: Partial<IAlertingDialogTriggerModeProps>): ReactElement;
+//# sourceMappingURL=AlertingDialogTriggerMode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AlertingDialogTriggerMode.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/blocks/AlertingDialogTriggerMode.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAO1C,OAAO,EAAE,KAAK,+BAA+B,EAAE,MAAM,aAAa,CAAC;AAInE;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,OAAO,CAAC,+BAA+B,CAAC,GAAG,YAAY,CAM3G"}

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

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { FormattedMessage } from "react-intl";
+import { AutomationDialogFormField } from "../../shared/slots/AutomationDialogFormField.js";
+import { DefaultAlertingDialogTriggerMode } from "../DefaultAlertingDialog/DefaultAlertingDialogTriggerMode.js";
+import { useAlertingDialogTriggerModeProps } from "../state/useAlertingDialogFieldProps.js";
+import { WhenAlertingDialogLoaded } from "./WhenAlertingDialogLoaded.js";
+/**
+ * The alerting dialog's trigger-mode field ("Trigger": how often a met condition notifies),
+ * connected to the dialog's state and rendered as a labelled form row.
+ *
+ * Renders {@link DefaultAlertingDialogTriggerMode} inside {@link AutomationDialogFormField} with
+ * the props of {@link useAlertingDialogTriggerModeProps}; every prop passed here replaces the
+ * hook's value for that prop wholesale. Renders nothing while
+ * `useAlertingDialogContext().isLoading` is true.
+ *
+ * @alpha
+ */
+export function AlertingDialogTriggerMode(overrides) {
+    return (_jsx(WhenAlertingDialogLoaded, { children: _jsx(ConnectedAlertingDialogTriggerMode, { ...overrides }) }));
+}
+function ConnectedAlertingDialogTriggerMode(overrides) {
+    const props = { ...useAlertingDialogTriggerModeProps(), ...overrides };
+    return (_jsx(AutomationDialogFormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.trigger" }), htmlFor: props.id, children: _jsx(DefaultAlertingDialogTriggerMode, { ...props }) }));
+}

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

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultLoadingAlertingDialog.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/blocks/DefaultLoadingAlertingDialog.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAarE,UAAU,kCAAkC;IACxC,WAAW,CAAC,EAAE,yBAAyB,CAAC;IACxC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;CACzB;AAED,wBAAgB,4BAA4B,CAAC,EAAE,WAAW,EAAE,QAAQ,EAAE,EAAE,kCAAkC,2CAkDzG"}

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

@@ -1,6 +1,6 @@
 import { type Dispatch, type SetStateAction } from "react";
 import { type IAlertRelativeArithmeticOperator, type IAlertRelativeOperator, type IAttribute, type IAutomationMetadataObjectDefinition, type IMeasure } from "@gooddata/sdk-model";
-import { type AlertAttribute, type AlertMetric } from "../../types.js";
+import { type AlertAttribute, type AlertMetric } from "../types.js";
 export interface IUseAlertThresholdProps {
     setEditedAutomation: Dispatch<SetStateAction<IAutomationMetadataObjectDefinition | undefined>>;
     editedAutomation: IAutomationMetadataObjectDefinition | undefined;

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

@@ -0,0 +1 @@
+{"version":3,"file":"useAlertThreshold.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/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,aAAa,CAAC;AAKpE,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 → hooks}/useAlertThreshold.js

@@ -1,6 +1,6 @@
 // (C) 2026 GoodData Corporation
 import { useCallback } from "react";
-import { transformAlertByValue } from "../../utils/transformation.js";
+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,

package/esm/presentation/automations/alerting/{DefaultAlertingDialog/hooks → hooks}/useThresholdValue.d.ts

@@ -1,6 +1,6 @@
 import { type ChangeEvent, type FocusEvent } from "react";
 import { type IAlertRelativeArithmeticOperator, type IAlertRelativeOperator, type IAttribute, type IAutomationAlert, type IMeasure } from "@gooddata/sdk-model";
-import { type AlertAttribute, type AlertMetric } from "../../types.js";
+import { type AlertAttribute, type AlertMetric } from "../types.js";
 export declare function useThresholdValue(changeValue: (value: number) => void, getMetricValue: (measure?: IMeasure, attr?: IAttribute, value?: string | null) => number | undefined, isNewAlert?: boolean, alert?: IAutomationAlert, selectedRelativeOperator?: [
     IAlertRelativeOperator | undefined,
     IAlertRelativeArithmeticOperator | undefined

package/esm/presentation/automations/alerting/hooks/useThresholdValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useThresholdValue.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/hooks/useThresholdValue.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAoC,MAAM,OAAO,CAAC;AAI5F,OAAO,EACH,KAAK,gCAAgC,EACrC,KAAK,sBAAsB,EAC3B,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,QAAQ,EAChB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAgCpE,wBAAgB,iBAAiB,CAC7B,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,EACpC,cAAc,EAAE,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAE,UAAU,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,KAAK,MAAM,GAAG,SAAS,EACpG,UAAU,CAAC,EAAE,OAAO,EACpB,KAAK,CAAC,EAAE,gBAAgB,EACxB,wBAAwB,GAAE;IACtB,sBAAsB,GAAG,SAAS;IAClC,gCAAgC,GAAG,SAAS;CACtB,EAC1B,eAAe,CAAC,EAAE,WAAW,EAC7B,iBAAiB,CAAC,EAAE,cAAc,EAClC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI;;;;;EAkFhC"}

package/esm/presentation/automations/alerting/{DefaultAlertingDialog/hooks → hooks}/useThresholdValue.js

@@ -1,8 +1,8 @@
 // (C) 2022-2026 GoodData Corporation
 import { useCallback, useEffect, useState } from "react";
 import { useIntl } from "react-intl";
-import { getAlertThreshold, getMeasureFormat } from "../../utils/getters.js";
-import { convertThresholdValue } from "../../utils/threshold.js";
+import { getAlertThreshold, getMeasureFormat } from "../utils/getters.js";
+import { convertThresholdValue } from "../utils/threshold.js";
 function clearValueForRelativeOperator(changeValue, setValue) {
     changeValue(undefined);
     setValue(undefined);

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

@@ -2,8 +2,8 @@ import { type Dispatch, type SetStateAction } from "react";
 import { type DateAttributeGranularity, type FilterContextItem, type IAlertAnomalyDetectionGranularity, type IAlertAnomalyDetectionSensitivity, type IAlertComparisonOperator, type IAlertRelativeArithmeticOperator, type IAlertRelativeOperator, type IAlertTriggerInterval, type IAlertTriggerMode, type IAttribute, type IAttributeMetadataObject, type IAutomationMetadataObjectDefinition, type IAutomationRecipient, type IMeasure, type INotificationChannelIdentifier, type INotificationChannelMetadataObject, type IdentifierRef, type ParameterValue } from "@gooddata/sdk-model";
 import { type IAutomationParameter } from "../../shared/automationFilters/automationParameters.js";
 import { type AttributeValue } from "../hooks/useAttributeValuesFromExecResults.js";
-import { type AlertAttribute, type AlertMetric, type AlertMetricComparator, type AlertMetricComparatorType, type IAlertingDialogProps } from "../types.js";
-import { type AlertAiOperator, type IMeasureFormatMap } from "../utils/getters.js";
+import { type AlertAiOperator, type AlertAttribute, type AlertMetric, type AlertMetricComparator, type AlertMetricComparatorType, type IAlertingDialogProps } from "../types.js";
+import { type IMeasureFormatMap } from "../utils/getters.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.