@gooddata/sdk-ui-dashboard 11.55.0-alpha.0 → 11.55.0-alpha.2

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

@@ -0,0 +1,30 @@
+import { type IAutomationDialogActionBarProps } from "../../shared/slots/types.js";
+import { type IUseAlertingDialogActionBarPropsInput } from "../state/useAlertingDialogRegionProps.js";
+/**
+ * Props of {@link AlertingDialogActionBar}: the dialog inputs {@link useAlertingDialogActionBarProps}
+ * needs (`onSubmit` and `isSaving` from {@link useAlertSubmit}, the dialog's `onCancel`, `onDelete`
+ * for edit mode) plus any {@link IAutomationDialogActionBarProps} member to override.
+ *
+ * @alpha
+ */
+export type IAlertingDialogActionBarBlockProps = IUseAlertingDialogActionBarPropsInput & Partial<IAutomationDialogActionBarProps>;
+/**
+ * The alerting dialog's action bar (documentation link, Delete in edit mode, Cancel, submit),
+ * connected to the dialog's state.
+ *
+ * Renders {@link DefaultAutomationDialogActionBar} with the props of
+ * {@link useAlertingDialogActionBarProps}; every override prop replaces the hook's value wholesale.
+ * The block does not own the submit: pass `submit` and `isSaving` from one {@link useAlertSubmit}
+ * instance, so an Enter handler elsewhere in the shell shares its in-flight guard. Renders nothing
+ * while `useAlertingDialogContext().isLoading` is true.
+ *
+ * @example
+ * ```tsx
+ * const { submit, isSaving } = useAlertSubmit(props);
+ * <AlertingDialogActionBar onCancel={props.onCancel} onSubmit={() => void submit()} isSaving={isSaving} />;
+ * ```
+ *
+ * @alpha
+ */
+export declare function AlertingDialogActionBar(props: IAlertingDialogActionBarBlockProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=AlertingDialogActionBar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AlertingDialogActionBar.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/blocks/AlertingDialogActionBar.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,+BAA+B,EAAE,MAAM,6BAA6B,CAAC;AACnF,OAAO,EACH,KAAK,qCAAqC,EAE7C,MAAM,0CAA0C,CAAC;AAIlD;;;;;;GAMG;AACH,MAAM,MAAM,kCAAkC,GAAG,qCAAqC,GAClF,OAAO,CAAC,+BAA+B,CAAC,CAAC;AAE7C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,kCAAkC,2CAMhF"}

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

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { DefaultAutomationDialogActionBar } from "../../shared/slots/DefaultAutomationDialogActionBar.js";
+import { useAlertingDialogActionBarProps, } from "../state/useAlertingDialogRegionProps.js";
+import { WhenAlertingDialogLoaded } from "./WhenAlertingDialogLoaded.js";
+/**
+ * The alerting dialog's action bar (documentation link, Delete in edit mode, Cancel, submit),
+ * connected to the dialog's state.
+ *
+ * Renders {@link DefaultAutomationDialogActionBar} with the props of
+ * {@link useAlertingDialogActionBarProps}; every override prop replaces the hook's value wholesale.
+ * The block does not own the submit: pass `submit` and `isSaving` from one {@link useAlertSubmit}
+ * instance, so an Enter handler elsewhere in the shell shares its in-flight guard. Renders nothing
+ * while `useAlertingDialogContext().isLoading` is true.
+ *
+ * @example
+ * ```tsx
+ * const { submit, isSaving } = useAlertSubmit(props);
+ * <AlertingDialogActionBar onCancel={props.onCancel} onSubmit={() => void submit()} isSaving={isSaving} />;
+ * ```
+ *
+ * @alpha
+ */
+export function AlertingDialogActionBar(props) {
+    return (_jsx(WhenAlertingDialogLoaded, { children: _jsx(ConnectedAlertingDialogActionBar, { ...props }) }));
+}
+function ConnectedAlertingDialogActionBar({ onCancel, onSubmit, isSaving, onDelete, ...overrides }) {
+    const defaultProps = useAlertingDialogActionBarProps({ onCancel, onSubmit, isSaving, onDelete });
+    return _jsx(DefaultAutomationDialogActionBar, { ...defaultProps, ...overrides });
+}

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

@@ -0,0 +1,16 @@
+import { type ReactElement } from "react";
+import { type IAlertingDialogAttributeProps } from "../types.js";
+/**
+ * The alerting dialog's attribute field ("For": the attribute value the condition is sliced by),
+ * connected to the dialog's state and rendered as a labelled form row.
+ *
+ * Renders {@link DefaultAlertingDialogAttribute} inside {@link AutomationDialogFormField} with the
+ * props of {@link useAlertingDialogAttributeProps}; every prop passed here replaces the hook's
+ * value for that prop wholesale. Renders nothing when the insight has no non-date attribute (there
+ * is nothing to slice by; the gate reads the `attributes` prop, so an override is honoured), and
+ * nothing while `useAlertingDialogContext().isLoading` is true.
+ *
+ * @alpha
+ */
+export declare function AlertingDialogAttribute(overrides: Partial<IAlertingDialogAttributeProps>): ReactElement;
+//# sourceMappingURL=AlertingDialogAttribute.d.ts.map

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

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

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

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { FormattedMessage } from "react-intl";
+import { AutomationDialogFormField } from "../../shared/slots/AutomationDialogFormField.js";
+import { DefaultAlertingDialogAttribute } from "../DefaultAlertingDialog/DefaultAlertingDialogAttribute.js";
+import { useAlertingDialogAttributeProps } from "../state/useAlertingDialogFieldProps.js";
+import { WhenAlertingDialogLoaded } from "./WhenAlertingDialogLoaded.js";
+/**
+ * The alerting dialog's attribute field ("For": the attribute value the condition is sliced by),
+ * connected to the dialog's state and rendered as a labelled form row.
+ *
+ * Renders {@link DefaultAlertingDialogAttribute} inside {@link AutomationDialogFormField} with the
+ * props of {@link useAlertingDialogAttributeProps}; every prop passed here replaces the hook's
+ * value for that prop wholesale. Renders nothing when the insight has no non-date attribute (there
+ * is nothing to slice by; the gate reads the `attributes` prop, so an override is honoured), and
+ * nothing while `useAlertingDialogContext().isLoading` is true.
+ *
+ * @alpha
+ */
+export function AlertingDialogAttribute(overrides) {
+    return (_jsx(WhenAlertingDialogLoaded, { children: _jsx(ConnectedAlertingDialogAttribute, { ...overrides }) }));
+}
+function ConnectedAlertingDialogAttribute(overrides) {
+    const props = { ...useAlertingDialogAttributeProps(), ...overrides };
+    if (!props.attributes.some((attribute) => attribute.type === "attribute")) {
+        return null;
+    }
+    return (_jsx(AutomationDialogFormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.for" }), htmlFor: props.id, children: _jsx(DefaultAlertingDialogAttribute, { ...props }) }));
+}

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

@@ -0,0 +1,22 @@
+import { type ReactElement } from "react";
+import { type IAlertingDialogComparisonOperatorProps } from "../types.js";
+/**
+ * The alerting dialog's condition field ("Condition": the operator — fixed threshold, change,
+ * difference or anomaly detection), connected to the dialog's state and rendered as a labelled
+ * form row.
+ *
+ * Renders {@link DefaultAlertingDialogComparisonOperator} inside {@link AutomationDialogFormField}
+ * with the props of {@link useAlertingDialogComparisonOperatorProps}; every prop passed here
+ * replaces the hook's value for that prop wholesale. Pass `enableAnomalyDetectionAlert={false}` to
+ * hide the anomaly-detection options. Renders nothing while
+ * `useAlertingDialogContext().isLoading` is true.
+ *
+ * @example
+ * ```tsx
+ * <AlertingDialogComparisonOperator enableAnomalyDetectionAlert={false} />
+ * ```
+ *
+ * @alpha
+ */
+export declare function AlertingDialogComparisonOperator(overrides: Partial<IAlertingDialogComparisonOperatorProps>): ReactElement;
+//# sourceMappingURL=AlertingDialogComparisonOperator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AlertingDialogComparisonOperator.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/blocks/AlertingDialogComparisonOperator.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAO1C,OAAO,EAAE,KAAK,sCAAsC,EAAE,MAAM,aAAa,CAAC;AAI1E;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gCAAgC,CAC5C,SAAS,EAAE,OAAO,CAAC,sCAAsC,CAAC,GAC3D,YAAY,CAMd"}

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

@@ -0,0 +1,31 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { FormattedMessage } from "react-intl";
+import { AutomationDialogFormField } from "../../shared/slots/AutomationDialogFormField.js";
+import { DefaultAlertingDialogComparisonOperator } from "../DefaultAlertingDialog/DefaultAlertingDialogComparisonOperator.js";
+import { useAlertingDialogComparisonOperatorProps } from "../state/useAlertingDialogFieldProps.js";
+import { WhenAlertingDialogLoaded } from "./WhenAlertingDialogLoaded.js";
+/**
+ * The alerting dialog's condition field ("Condition": the operator — fixed threshold, change,
+ * difference or anomaly detection), connected to the dialog's state and rendered as a labelled
+ * form row.
+ *
+ * Renders {@link DefaultAlertingDialogComparisonOperator} inside {@link AutomationDialogFormField}
+ * with the props of {@link useAlertingDialogComparisonOperatorProps}; every prop passed here
+ * replaces the hook's value for that prop wholesale. Pass `enableAnomalyDetectionAlert={false}` to
+ * hide the anomaly-detection options. Renders nothing while
+ * `useAlertingDialogContext().isLoading` is true.
+ *
+ * @example
+ * ```tsx
+ * <AlertingDialogComparisonOperator enableAnomalyDetectionAlert={false} />
+ * ```
+ *
+ * @alpha
+ */
+export function AlertingDialogComparisonOperator(overrides) {
+    return (_jsx(WhenAlertingDialogLoaded, { children: _jsx(ConnectedAlertingDialogComparisonOperator, { ...overrides }) }));
+}
+function ConnectedAlertingDialogComparisonOperator(overrides) {
+    const props = { ...useAlertingDialogComparisonOperatorProps(), ...overrides };
+    return (_jsx(AutomationDialogFormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.condition" }), htmlFor: props.id, children: _jsx(DefaultAlertingDialogComparisonOperator, { ...props }) }));
+}

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

@@ -0,0 +1,18 @@
+import { type ReactElement } from "react";
+import { type IAlertingDialogComparisonPeriodProps } from "../types.js";
+/**
+ * The alerting dialog's comparison-period field ("Compared to": the period a change or difference
+ * condition compares against), connected to the dialog's state and rendered as a labelled form
+ * row.
+ *
+ * Renders {@link DefaultAlertingDialogComparisonPeriod} inside {@link AutomationDialogFormField}
+ * with the props of {@link useAlertingDialogComparisonPeriodProps}; every prop passed here
+ * replaces the hook's value for that prop wholesale. Renders nothing unless the `alert` prop's
+ * condition is a change or difference (only those have a comparison period; the gate reads the
+ * prop, so an override is honoured), and nothing while `useAlertingDialogContext().isLoading` is
+ * true.
+ *
+ * @alpha
+ */
+export declare function AlertingDialogComparisonPeriod(overrides: Partial<IAlertingDialogComparisonPeriodProps>): ReactElement;
+//# sourceMappingURL=AlertingDialogComparisonPeriod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AlertingDialogComparisonPeriod.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/blocks/AlertingDialogComparisonPeriod.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAO1C,OAAO,EAAE,KAAK,oCAAoC,EAAE,MAAM,aAAa,CAAC;AAKxE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,8BAA8B,CAC1C,SAAS,EAAE,OAAO,CAAC,oCAAoC,CAAC,GACzD,YAAY,CAMd"}

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

@@ -0,0 +1,31 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { FormattedMessage } from "react-intl";
+import { AutomationDialogFormField } from "../../shared/slots/AutomationDialogFormField.js";
+import { DefaultAlertingDialogComparisonPeriod } from "../DefaultAlertingDialog/DefaultAlertingDialogComparisonPeriod.js";
+import { useAlertingDialogComparisonPeriodProps } from "../state/useAlertingDialogFieldProps.js";
+import { isChangeOrDifferenceOperator } from "../utils/guards.js";
+import { WhenAlertingDialogLoaded } from "./WhenAlertingDialogLoaded.js";
+/**
+ * The alerting dialog's comparison-period field ("Compared to": the period a change or difference
+ * condition compares against), connected to the dialog's state and rendered as a labelled form
+ * row.
+ *
+ * Renders {@link DefaultAlertingDialogComparisonPeriod} inside {@link AutomationDialogFormField}
+ * with the props of {@link useAlertingDialogComparisonPeriodProps}; every prop passed here
+ * replaces the hook's value for that prop wholesale. Renders nothing unless the `alert` prop's
+ * condition is a change or difference (only those have a comparison period; the gate reads the
+ * prop, so an override is honoured), and nothing while `useAlertingDialogContext().isLoading` is
+ * true.
+ *
+ * @alpha
+ */
+export function AlertingDialogComparisonPeriod(overrides) {
+    return (_jsx(WhenAlertingDialogLoaded, { children: _jsx(ConnectedAlertingDialogComparisonPeriod, { ...overrides }) }));
+}
+function ConnectedAlertingDialogComparisonPeriod(overrides) {
+    const props = { ...useAlertingDialogComparisonPeriodProps(), ...overrides };
+    if (!props.alert || !isChangeOrDifferenceOperator(props.alert.alert)) {
+        return null;
+    }
+    return (_jsx(AutomationDialogFormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.comparison" }), htmlFor: props.id, children: _jsx(DefaultAlertingDialogComparisonPeriod, { ...props }) }));
+}

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

@@ -0,0 +1,15 @@
+import { type IAutomationDialogDestinationProps } from "../../shared/slots/types.js";
+/**
+ * The alerting dialog's destination region (the notification-channel select), connected to the
+ * dialog's state.
+ *
+ * Renders {@link DefaultAlertingDialogDestination} with the props of
+ * {@link useAlertingDialogDestinationProps}; every prop passed here replaces the hook's value for
+ * that prop wholesale. Renders nothing while `useAlertingDialogContext().isLoading` is true. The
+ * default dialog renders this region only when more than one channel exists; the block renders
+ * wherever it is placed — a shell decides from `useAlertingDialogContext().notificationChannels`.
+ *
+ * @alpha
+ */
+export declare function AlertingDialogDestination(overrides: Partial<IAutomationDialogDestinationProps>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=AlertingDialogDestination.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AlertingDialogDestination.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/blocks/AlertingDialogDestination.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,iCAAiC,EAAE,MAAM,6BAA6B,CAAC;AAMrF;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,OAAO,CAAC,iCAAiC,CAAC,2CAM9F"}

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

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { DefaultAlertingDialogDestination } from "../DefaultAlertingDialog/DefaultAlertingDialogDestination.js";
+import { useAlertingDialogDestinationProps } from "../state/useAlertingDialogRegionProps.js";
+import { WhenAlertingDialogLoaded } from "./WhenAlertingDialogLoaded.js";
+/**
+ * The alerting dialog's destination region (the notification-channel select), connected to the
+ * dialog's state.
+ *
+ * Renders {@link DefaultAlertingDialogDestination} with the props of
+ * {@link useAlertingDialogDestinationProps}; every prop passed here replaces the hook's value for
+ * that prop wholesale. Renders nothing while `useAlertingDialogContext().isLoading` is true. The
+ * default dialog renders this region only when more than one channel exists; the block renders
+ * wherever it is placed — a shell decides from `useAlertingDialogContext().notificationChannels`.
+ *
+ * @alpha
+ */
+export function AlertingDialogDestination(overrides) {
+    return (_jsx(WhenAlertingDialogLoaded, { children: _jsx(ConnectedAlertingDialogDestination, { ...overrides }) }));
+}
+function ConnectedAlertingDialogDestination(overrides) {
+    const defaultProps = useAlertingDialogDestinationProps();
+    return _jsx(DefaultAlertingDialogDestination, { ...defaultProps, ...overrides });
+}

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

@@ -0,0 +1,11 @@
+import { type MessageDescriptor } from "react-intl";
+/**
+ * A form-row label with a "?" tooltip after it; the Granularity and TriggerInterval blocks use it.
+ *
+ * @internal
+ */
+export declare function AlertingDialogFieldLabelWithTooltip({ label, tooltip }: {
+    label: MessageDescriptor;
+    tooltip: MessageDescriptor;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=AlertingDialogFieldLabelWithTooltip.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AlertingDialogFieldLabelWithTooltip.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/blocks/AlertingDialogFieldLabelWithTooltip.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAoB,KAAK,iBAAiB,EAAW,MAAM,YAAY,CAAC;AAI/E;;;;GAIG;AACH,wBAAgB,mCAAmC,CAAC,EAChD,KAAK,EACL,OAAO,EACV,EAAE;IACC,KAAK,EAAE,iBAAiB,CAAC;IACzB,OAAO,EAAE,iBAAiB,CAAC;CAC9B,2CAuBA"}

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

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { FormattedMessage, useIntl } from "react-intl";
+import { UiIconButton, UiTooltip } from "@gooddata/sdk-ui-kit";
+/**
+ * A form-row label with a "?" tooltip after it; the Granularity and TriggerInterval blocks use it.
+ *
+ * @internal
+ */
+export function AlertingDialogFieldLabelWithTooltip({ label, tooltip, }) {
+    const intl = useIntl();
+    return (_jsxs("div", { className: "gd-dashboard-alerting-dialog-form-field__content-container-tooltip", children: [
+            _jsx(FormattedMessage, { ...label }), _jsx(UiTooltip, { anchor: _jsx(UiIconButton, { icon: "question", variant: "tertiary", size: "xsmall", accessibilityConfig: { ariaLabel: intl.formatMessage(label) } }), content: _jsx(FormattedMessage, { ...tooltip }), arrowPlacement: "left", optimalPlacement: true, offset: 10, width: 280, triggerBy: ["hover", "click"] })
+        ] }));
+}

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

@@ -0,0 +1,16 @@
+import { type IAlertingDialogFiltersProps } from "../types.js";
+/**
+ * The alerting dialog's filters region (the filter and parameter chips), connected to the dialog's
+ * state.
+ *
+ * Renders {@link DefaultAlertingDialogFilters} with the props of {@link useAlertingDialogFiltersProps};
+ * every prop passed here replaces the hook's value for that prop wholesale (an `onFiltersChange`
+ * override takes over the write and must submit the complete selection). Renders nothing while
+ * `useAlertingDialogContext().isLoading` is true. The default dialog also hides this region behind
+ * its stale-filters confirmation step; a shell that wants that step builds it from
+ * {@link useAlertFilters}.
+ *
+ * @alpha
+ */
+export declare function AlertingDialogFilters(overrides: Partial<IAlertingDialogFiltersProps>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=AlertingDialogFilters.d.ts.map

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

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

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

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { DefaultAlertingDialogFilters } from "../DefaultAlertingDialog/DefaultAlertingDialogFilters.js";
+import { useAlertingDialogFiltersProps } from "../state/useAlertingDialogRegionProps.js";
+import { WhenAlertingDialogLoaded } from "./WhenAlertingDialogLoaded.js";
+/**
+ * The alerting dialog's filters region (the filter and parameter chips), connected to the dialog's
+ * state.
+ *
+ * Renders {@link DefaultAlertingDialogFilters} with the props of {@link useAlertingDialogFiltersProps};
+ * every prop passed here replaces the hook's value for that prop wholesale (an `onFiltersChange`
+ * override takes over the write and must submit the complete selection). Renders nothing while
+ * `useAlertingDialogContext().isLoading` is true. The default dialog also hides this region behind
+ * its stale-filters confirmation step; a shell that wants that step builds it from
+ * {@link useAlertFilters}.
+ *
+ * @alpha
+ */
+export function AlertingDialogFilters(overrides) {
+    return (_jsx(WhenAlertingDialogLoaded, { children: _jsx(ConnectedAlertingDialogFilters, { ...overrides }) }));
+}
+function ConnectedAlertingDialogFilters(overrides) {
+    const defaultProps = useAlertingDialogFiltersProps();
+    return _jsx(DefaultAlertingDialogFilters, { ...defaultProps, ...overrides });
+}

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/AlertingDialogHeader.d.ts

@@ -0,0 +1,26 @@
+import { type IAlertingDialogHeaderProps } from "../types.js";
+/**
+ * The alerting dialog's header region (the title input row), connected to the dialog's state.
+ *
+ * Renders {@link DefaultAlertingDialogHeader} with the props of {@link useAlertingDialogHeaderProps}.
+ * Every prop passed here replaces the hook's value for that prop wholesale; pass the dialog's
+ * `onCancel` so the back button closes the dialog, and `ref` to receive the title input. Renders
+ * nothing while `useAlertingDialogContext().isLoading` is true.
+ *
+ * @example
+ * ```tsx
+ * function MyAlertingDialog(props: IAlertingDialogProps) {
+ *     return (
+ *         <MyShell onClose={props.onCancel}>
+ *             <AlertingDialogHeader onCancel={props.onCancel} />
+ *             <AlertingDialogFilters />
+ *         </MyShell>
+ *     );
+ * }
+ * <Dashboard AlertingDialogComponent={MyAlertingDialog} />;
+ * ```
+ *
+ * @alpha
+ */
+export declare const AlertingDialogHeader: import("react").ForwardRefExoticComponent<Partial<IAlertingDialogHeaderProps> & import("react").RefAttributes<HTMLInputElement>>;
+//# sourceMappingURL=AlertingDialogHeader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AlertingDialogHeader.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/blocks/AlertingDialogHeader.tsx"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,0BAA0B,EAAE,MAAM,aAAa,CAAC;AAI9D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,oBAAoB,kIAQhC,CAAC"}

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

@@ -0,0 +1,36 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { forwardRef } from "react";
+import { DefaultAlertingDialogHeader } from "../DefaultAlertingDialog/DefaultAlertingDialogHeader.js";
+import { useAlertingDialogHeaderProps } from "../state/useAlertingDialogRegionProps.js";
+import { WhenAlertingDialogLoaded } from "./WhenAlertingDialogLoaded.js";
+/**
+ * The alerting dialog's header region (the title input row), connected to the dialog's state.
+ *
+ * Renders {@link DefaultAlertingDialogHeader} with the props of {@link useAlertingDialogHeaderProps}.
+ * Every prop passed here replaces the hook's value for that prop wholesale; pass the dialog's
+ * `onCancel` so the back button closes the dialog, and `ref` to receive the title input. Renders
+ * nothing while `useAlertingDialogContext().isLoading` is true.
+ *
+ * @example
+ * ```tsx
+ * function MyAlertingDialog(props: IAlertingDialogProps) {
+ *     return (
+ *         <MyShell onClose={props.onCancel}>
+ *             <AlertingDialogHeader onCancel={props.onCancel} />
+ *             <AlertingDialogFilters />
+ *         </MyShell>
+ *     );
+ * }
+ * <Dashboard AlertingDialogComponent={MyAlertingDialog} />;
+ * ```
+ *
+ * @alpha
+ */
+export const AlertingDialogHeader = forwardRef(function AlertingDialogHeader(props, ref) {
+    return (_jsx(WhenAlertingDialogLoaded, { children: _jsx(ConnectedAlertingDialogHeader, { ...props, ref: ref }) }));
+});
+const ConnectedAlertingDialogHeader = forwardRef(function ConnectedAlertingDialogHeader({ onCancel, ...overrides }, ref) {
+    const defaultProps = useAlertingDialogHeaderProps({ onCancel, ref });
+    return _jsx(DefaultAlertingDialogHeader, { ...defaultProps, ...overrides });
+});

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/AlertingDialogRecipients.d.ts

@@ -0,0 +1,13 @@
+import { type IAutomationDialogRecipientsProps } from "../../shared/slots/types.js";
+/**
+ * The alerting dialog's recipients region, connected to the dialog's state.
+ *
+ * Renders {@link DefaultAlertingDialogRecipients} with the props of
+ * {@link useAlertingDialogRecipientsProps}; every prop passed here replaces the hook's value for
+ * that prop wholesale, e.g. `<AlertingDialogRecipients maxRecipients={3} />`. Renders nothing while
+ * `useAlertingDialogContext().isLoading` is true.
+ *
+ * @alpha
+ */
+export declare function AlertingDialogRecipients(overrides: Partial<IAutomationDialogRecipientsProps>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=AlertingDialogRecipients.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AlertingDialogRecipients.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/blocks/AlertingDialogRecipients.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,gCAAgC,EAAE,MAAM,6BAA6B,CAAC;AAMpF;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,OAAO,CAAC,gCAAgC,CAAC,2CAM5F"}

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

@@ -0,0 +1,21 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { DefaultAlertingDialogRecipients } from "../DefaultAlertingDialog/DefaultAlertingDialogRecipients.js";
+import { useAlertingDialogRecipientsProps } from "../state/useAlertingDialogRegionProps.js";
+import { WhenAlertingDialogLoaded } from "./WhenAlertingDialogLoaded.js";
+/**
+ * The alerting dialog's recipients region, connected to the dialog's state.
+ *
+ * Renders {@link DefaultAlertingDialogRecipients} with the props of
+ * {@link useAlertingDialogRecipientsProps}; every prop passed here replaces the hook's value for
+ * that prop wholesale, e.g. `<AlertingDialogRecipients maxRecipients={3} />`. Renders nothing while
+ * `useAlertingDialogContext().isLoading` is true.
+ *
+ * @alpha
+ */
+export function AlertingDialogRecipients(overrides) {
+    return (_jsx(WhenAlertingDialogLoaded, { children: _jsx(ConnectedAlertingDialogRecipients, { ...overrides }) }));
+}
+function ConnectedAlertingDialogRecipients(overrides) {
+    const defaultProps = useAlertingDialogRecipientsProps();
+    return _jsx(DefaultAlertingDialogRecipients, { ...defaultProps, ...overrides });
+}

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"}