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

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

@@ -13,8 +13,8 @@ import { Action } from '@reduxjs/toolkit';
 import { ActionCreatorWithOptionalPayload } from '@reduxjs/toolkit';
 import { ActionCreatorWithoutPayload } from '@reduxjs/toolkit';
 import { ActionCreatorWithPayload } from '@reduxjs/toolkit';
-import { AI_OPERATOR } from '@gooddata/sdk-ui-ext';
-import { AI_OPERATORS } from '@gooddata/sdk-ui-ext';
+import type { AI_OPERATOR } from '@gooddata/sdk-ui-ext';
+import type { AI_OPERATORS } from '@gooddata/sdk-ui-ext';
 import { AnyAction } from '@reduxjs/toolkit';
 import { CaseReducer } from '@reduxjs/toolkit';
 import { CaseReducerActions } from '@reduxjs/toolkit';
@@ -46,6 +46,7 @@ import { EntityState } from '@reduxjs/toolkit';
 import { ExecutionResultLimitType } from '@gooddata/sdk-model';
 import { ExplicitDrill } from '@gooddata/sdk-ui';
 import { FilterContextItem } from '@gooddata/sdk-model';
+import { FocusEvent as FocusEvent_2 } from 'react';
 import { ForwardRefExoticComponent } from 'react';
 import { GoodDataSdkError } from '@gooddata/sdk-ui';
 import { IAbsoluteDateFilter } from '@gooddata/sdk-model';
@@ -145,7 +146,7 @@ import { IExecutionResult } from '@gooddata/sdk-backend-spi';
 import { IExecutionResultLimitBreak } from '@gooddata/sdk-model';
 import { IExportDefinitionVisualizationObjectSettings } from '@gooddata/sdk-model';
 import { IExportResult } from '@gooddata/sdk-backend-spi';
-import type { IExportTemplate } from '@gooddata/sdk-model';
+import { IExportTemplate } from '@gooddata/sdk-model';
 import { IFilter } from '@gooddata/sdk-model';
 import { IFilterableWidget } from '@gooddata/sdk-model';
 import { IFilterContext } from '@gooddata/sdk-model';
@@ -211,6 +212,7 @@ import { IVisualizationSwitcherWidget } from '@gooddata/sdk-model';
 import { IWidget } from '@gooddata/sdk-model';
 import { IWidgetDefinition } from '@gooddata/sdk-model';
 import { IWorkspacePermissions } from '@gooddata/sdk-model';
+import { IWorkspaceUser } from '@gooddata/sdk-model';
 import { JSX } from 'react/jsx-runtime';
 import { KeyboardEvent as KeyboardEvent_2 } from 'react';
 import { LocalIdRef } from '@gooddata/sdk-model';
@@ -529,7 +531,7 @@ export declare function addTextAttributeFilter(filter: DashboardTextAttributeFil
 export declare function addVisualizationToSwitcherWidgetContent(ref: ObjRef, visualization: IInsightWidget, insight: IInsight, sizeInfo: IVisualizationSizeInfo, correlationId?: string): IAddVisualizationToVisualizationSwitcherWidgetContent;
 
 /**
- * The operator id of an anomaly-detection alert condition.
+ * The operator id of an anomaly-detection condition (`"AI.ANOMALY_DETECTION"`).
  *
  * @alpha
  */
@@ -580,6 +582,56 @@ export declare function AlertingDialog(props: IAlertingDialogProps): ReactElemen
  */
 export declare function AlertingDialogActionBar(props: IAlertingDialogActionBarBlockProps): JSX.Element;
 
+/**
+ * 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;
+
+/**
+ * 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;
+
+/**
+ * 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;
+
 /**
  * Provides the alerting create/edit dialog context.
  *
@@ -620,6 +672,27 @@ export declare function AlertingDialogDestination(overrides: Partial<IAutomation
  */
 export declare function AlertingDialogFilters(overrides: Partial<IAlertingDialogFiltersProps>): JSX.Element;
 
+/**
+ * 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 declare function AlertingDialogFormFieldGroup({ label, children }: IAlertingDialogFormFieldGroupProps): ReactElement;
+
+/**
+ * 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;
+
 /**
  * The alerting dialog's header region (the title input row), connected to the dialog's state.
  *
@@ -655,6 +728,34 @@ export declare type AlertingDialogHeaderDefaultProps = IAlertingDialogHeaderProp
     ref?: Ref<HTMLInputElement>;
 };
 
+/**
+ * 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;
+
 /**
  * The alerting dialog's recipients region, connected to the dialog's state.
  *
@@ -667,6 +768,111 @@ export declare type AlertingDialogHeaderDefaultProps = IAlertingDialogHeaderProp
  */
 export declare function AlertingDialogRecipients(overrides: Partial<IAutomationDialogRecipientsProps>): JSX.Element;
 
+/**
+ * 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;
+
+/**
+ * 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;
+
+/**
+ * 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;
+
+/**
+ * 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;
+
+/**
+ * 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;
+
 /**
  * @internal
  */
@@ -930,6 +1136,17 @@ export declare type AttributeValue = {
     name: string;
 };
 
+/**
+ * A labelled form row of the automation dialogs: the label on the left, the control on the right.
+ * Props-driven — reads no context. The default alerting dialog renders every condition field
+ * through it, as do the field blocks ({@link AlertingDialogMeasure} and siblings); a custom dialog
+ * that wants its own label renders a field's `Default*` control inside its own
+ * `AutomationDialogFormField`.
+ *
+ * @alpha
+ */
+export declare function AutomationDialogFormField({ label, children, htmlFor, fullWidth }: IAutomationDialogFormFieldProps): ReactElement;
+
 /**
  * @alpha
  */
@@ -4174,20 +4391,61 @@ export declare const DEFAULT_TAB_ID = "defaultTabId";
  * that is what lets a wholesale replacement receive the same contexts. Rendering this component
  * outside those providers throws at runtime.
  *
- * The dialog is composed from the exported region renders — {@link DefaultAlertingDialogHeader},
- * {@link DefaultAlertingDialogFilters}, {@link DefaultAlertingDialogDestination},
- * {@link DefaultAlertingDialogRecipients}, {@link DefaultAutomationDialogActionBar} — fed by the
- * matching `use*Props` hooks ({@link useAlertingDialogFiltersProps} and siblings). A custom
- * `AlertingDialogComponent` that keeps our regions but owns the markup places the connected blocks
- * ({@link AlertingDialogFilters} and siblings) instead of this component, and reads or writes the
- * same draft through {@link useAlertDraft} and {@link useAlertActions}.
+ * The dialog is {@link AlertingDialogShell} — the chrome: overlay, frame, header row, action bar, the
+ * dialog's messages, the stale-filters and delete confirmation steps, the loading skeleton — around the
+ * exported region renders ({@link DefaultAlertingDialogFilters}, {@link DefaultAlertingDialogDestination},
+ * {@link DefaultAlertingDialogRecipients}, fed by {@link useAlertingDialogFiltersProps} and siblings; the
+ * header and action bar are the shell's) and the connected field blocks — {@link AlertingDialogMeasure},
+ * {@link AlertingDialogAttribute}, {@link AlertingDialogComparisonOperator}, {@link AlertingDialogThreshold},
+ * {@link AlertingDialogComparisonPeriod}, {@link AlertingDialogSensitivity}, {@link AlertingDialogGranularity},
+ * {@link AlertingDialogTriggerMode}, {@link AlertingDialogTriggerInterval} — grouped under the "When" and
+ * "Do" headings by {@link AlertingDialogFormFieldGroup}; each field is a labelled
+ * {@link AutomationDialogFormField} row and the conditional ones gate themselves on the draft. A custom
+ * `AlertingDialogComponent` that keeps this chrome but owns the arrangement renders
+ * {@link AlertingDialogShell} around the blocks it wants (see its example); one that owns the chrome too
+ * places the blocks in its own markup and reads or writes the same draft through {@link useAlertDraft} and
+ * {@link useAlertActions}.
  *
  * Slots render only in the fully rendered dialog: not while the dialog context reports loading,
  * and not while the stale-filters confirmation step is shown.
  *
  * @alpha
  */
-export declare function DefaultAlertingDialog(props: IDefaultAlertingDialogProps): JSX.Element;
+export declare function DefaultAlertingDialog(props: IDefaultAlertingDialogProps): ReactElement;
+
+/**
+ * Default render of the alerting dialog's attribute field: the dropdown slicing the condition by an
+ * attribute value; renders nothing when the insight has no non-date attribute. Props-driven — the
+ * bare control without its label; reads no dialog context (only `useIntl`). The default dialog and
+ * {@link AlertingDialogAttribute} render it with {@link useAlertingDialogAttributeProps} inside
+ * {@link AutomationDialogFormField}.
+ *
+ * @alpha
+ */
+export declare function DefaultAlertingDialogAttribute({ id, disabled, selectedAttribute: selectedAttributeProp, getAttributeValues, isResultLoading, selectedValue, onAttributeChange, attributes, catalogAttributes, catalogDateDatasets, showLabel, closeOnParentScroll }: IAlertingDialogAttributeProps): ReactElement | null;
+
+/**
+ * Default render of the alerting dialog's comparison-operator field: the dropdown selecting the
+ * condition's operator (fixed threshold, change, difference, anomaly detection); renders nothing
+ * without a measure. Props-driven — the bare control without its label; reads no dialog context
+ * (only `useIntl`). The default dialog and {@link AlertingDialogComparisonOperator} render it with
+ * {@link useAlertingDialogComparisonOperatorProps} inside {@link AutomationDialogFormField}.
+ *
+ * @alpha
+ */
+export declare function DefaultAlertingDialogComparisonOperator(props: IAlertingDialogComparisonOperatorProps): ReactElement | null;
+
+/**
+ * Default render of the alerting dialog's comparison-period field: the dropdown selecting the
+ * period a change or difference condition compares against; static text with a single comparator,
+ * nothing for other condition types. Props-driven — the bare control without its label; reads no
+ * dialog context (only `useIntl`). The default dialog and {@link AlertingDialogComparisonPeriod}
+ * render it with {@link useAlertingDialogComparisonPeriodProps} inside
+ * {@link AutomationDialogFormField}.
+ *
+ * @alpha
+ */
+export declare function DefaultAlertingDialogComparisonPeriod({ alert, measure, overlayPositionType, selectedComparison, selectedGranularity, onComparisonChange, id, closeOnParentScroll }: IAlertingDialogComparisonPeriodProps): ReactElement | null;
 
 /**
  * Default render of the alerting dialog's destination region: the "Action" row selecting the
@@ -4210,6 +4468,16 @@ export declare function DefaultAlertingDialogDestination({ notificationChannels,
  */
 export declare function DefaultAlertingDialogFilters(props: IAlertingDialogFiltersProps): JSX.Element;
 
+/**
+ * Default render of the alerting dialog's granularity field: the dropdown selecting the
+ * anomaly-detection granularity. Props-driven — the bare control without its label; reads no
+ * dialog context (only `useIntl`). The default dialog and {@link AlertingDialogGranularity} render
+ * it with {@link useAlertingDialogGranularityProps} inside {@link AutomationDialogFormField}.
+ *
+ * @alpha
+ */
+export declare function DefaultAlertingDialogGranularity({ id, allowHourlyRecurrence, selectedGranularity, onGranularityChange, overlayPositionType, closeOnParentScroll }: IAlertingDialogGranularityProps): ReactElement;
+
 /**
  * Default render of the alerting dialog's header region: the back button and the title input with
  * its length validation. Props-driven — reads no alerting dialog state. The default dialog and
@@ -4220,6 +4488,16 @@ export declare function DefaultAlertingDialogFilters(props: IAlertingDialogFilte
  */
 export declare const DefaultAlertingDialogHeader: ForwardRefExoticComponent<IAlertingDialogHeaderProps & RefAttributes<HTMLInputElement>>;
 
+/**
+ * Default render of the alerting dialog's measure field: the dropdown selecting the measure the
+ * condition targets. Props-driven — the bare control without its label; reads no dialog context
+ * (only `useIntl`). The default dialog and {@link AlertingDialogMeasure} render it with
+ * {@link useAlertingDialogMeasureProps} inside {@link AutomationDialogFormField}.
+ *
+ * @alpha
+ */
+export declare function DefaultAlertingDialogMeasure({ id, disabled, selectedMeasure, onMeasureChange, measures, overlayPositionType, closeOnParentScroll }: IAlertingDialogMeasureProps): ReactElement;
+
 /**
  * Default render of the alerting dialog's recipients region: the recipients select in a form-field
  * row; the row carries the label, so the select's own label is off. Props-driven — reads no context.
@@ -4230,6 +4508,47 @@ export declare const DefaultAlertingDialogHeader: ForwardRefExoticComponent<IAle
  */
 export declare function DefaultAlertingDialogRecipients(props: IAutomationDialogRecipientsProps): JSX.Element;
 
+/**
+ * Default render of the alerting dialog's sensitivity field: the dropdown selecting the
+ * anomaly-detection sensitivity. Props-driven — the bare control without its label; reads no
+ * dialog context (only `useIntl`). The default dialog and {@link AlertingDialogSensitivity} render
+ * it with {@link useAlertingDialogSensitivityProps} inside {@link AutomationDialogFormField}.
+ *
+ * @alpha
+ */
+export declare function DefaultAlertingDialogSensitivity({ id, selectedSensitivity, onSensitivityChange, overlayPositionType, closeOnParentScroll }: IAlertingDialogSensitivityProps): ReactElement;
+
+/**
+ * Default render of the alerting dialog's threshold field: the numeric input for the threshold,
+ * with its unit suffix and validation message. Props-driven — the bare control without its label;
+ * reads no dialog context (only `useIntl`). The default dialog and {@link AlertingDialogThreshold}
+ * render it with {@link useAlertingDialogThresholdProps} inside {@link AutomationDialogFormField}.
+ *
+ * @alpha
+ */
+export declare function DefaultAlertingDialogThreshold({ id, value, onChange, onBlur, suffix, errorMessage }: IAlertingDialogThresholdProps): ReactElement;
+
+/**
+ * Default render of the alerting dialog's trigger-interval field: the dropdown selecting the
+ * interval of a once-per-interval trigger. Props-driven — the bare control without its label;
+ * reads no dialog context (only `useIntl`). The default dialog and
+ * {@link AlertingDialogTriggerInterval} render it with {@link useAlertingDialogTriggerIntervalProps}
+ * inside {@link AutomationDialogFormField}.
+ *
+ * @alpha
+ */
+export declare function DefaultAlertingDialogTriggerInterval({ id, selectedTriggerInterval, onTriggerIntervalChange, overlayPositionType, closeOnParentScroll }: IAlertingDialogTriggerIntervalProps): ReactElement;
+
+/**
+ * Default render of the alerting dialog's trigger-mode field: the dropdown selecting when the
+ * alert fires. Props-driven — the bare control without its label; reads no dialog context (only
+ * `useIntl`). The default dialog and {@link AlertingDialogTriggerMode} render it with
+ * {@link useAlertingDialogTriggerModeProps} inside {@link AutomationDialogFormField}.
+ *
+ * @alpha
+ */
+export declare function DefaultAlertingDialogTriggerMode({ id, selectedTriggerMode, onTriggerModeChange, overlayPositionType, closeOnParentScroll, enableAlertOncePerInterval }: IAlertingDialogTriggerModeProps): ReactElement;
+
 /**
  * Self-contained version of DefaultAlertingManagementDialogNew that builds the required
  * AutomationsContext and AlertingManagementDialogContext internally from the dashboard
@@ -4494,14 +4813,19 @@ export declare function DefaultSaveButton({ isVisible, isEnabled, isSaving, butt
  * that is what lets a wholesale replacement receive the same contexts. Rendering this component
  * outside those providers throws at runtime.
  *
- * The dialog is composed from the exported region renders — {@link DefaultScheduledEmailDialogHeader},
- * {@link DefaultScheduledEmailDialogFilters}, {@link DefaultScheduledEmailDialogDestination},
- * {@link DefaultScheduledEmailDialogRecipients}, {@link DefaultScheduledEmailDialogTimezone},
- * {@link DefaultAutomationDialogActionBar} — fed by the matching `use*Props` hooks
- * ({@link useScheduledEmailDialogFiltersProps} and siblings). A custom `ScheduledEmailDialogComponent`
- * that keeps our regions but owns the markup places the connected blocks
- * ({@link ScheduledEmailDialogFilters} and siblings) instead of this component, and reads or writes
- * the same draft through {@link useScheduledExportDraft} and {@link useScheduledExportActions}.
+ * The dialog is {@link ScheduledEmailDialogShell} — the chrome: overlay, frame, header row, action bar, the
+ * General/Filters tabs, the body's messages, the stale-filters and delete confirmation steps, the loading
+ * skeleton — around the exported region renders ({@link DefaultScheduledEmailDialogDestination},
+ * {@link DefaultScheduledEmailDialogRecipients}, {@link DefaultScheduledEmailDialogTimezone}, fed by
+ * {@link useScheduledEmailDialogDestinationProps} and siblings; the header, action bar and the Filters tab's
+ * {@link DefaultScheduledEmailDialogFilters} are the shell's) and the General-tab field blocks
+ * ({@link ScheduledEmailDialogRecurrence}, {@link ScheduledEmailDialogSubject}, {@link ScheduledEmailDialogMessage},
+ * {@link ScheduledEmailDialogWidgetAttachments}, {@link ScheduledEmailDialogDashboardAttachments},
+ * {@link ScheduledEmailDialogEvaluationMode}). A custom `ScheduledEmailDialogComponent` that keeps this chrome
+ * but owns the arrangement renders {@link ScheduledEmailDialogShell} around the blocks it wants (see its
+ * example); one that owns the chrome too places the blocks ({@link ScheduledEmailDialogFilters} and
+ * siblings) in its own markup and reads or writes the same draft through {@link useScheduledExportDraft}
+ * and {@link useScheduledExportActions}.
  *
  * Slots render only in the fully rendered dialog: not while the dialog context reports loading,
  * and not while the stale-filters confirmation step is shown. The Filters slot additionally
@@ -4509,7 +4833,16 @@ export declare function DefaultSaveButton({ isVisible, isEnabled, isSaving, butt
  *
  * @alpha
  */
-export declare function DefaultScheduledEmailDialog(props: IDefaultScheduledEmailDialogProps): JSX.Element;
+export declare function DefaultScheduledEmailDialog(props: IDefaultScheduledEmailDialogProps): ReactElement;
+
+/**
+ * Default render of the scheduled-export dialog's dashboard-attachments field.
+ * Props-driven — reads no context. The default dialog and {@link ScheduledEmailDialogDashboardAttachments}
+ * render it with {@link useScheduledEmailDialogDashboardAttachmentsProps}.
+ *
+ * @alpha
+ */
+export declare function DefaultScheduledEmailDialogDashboardAttachments(props: IScheduledEmailDialogDashboardAttachmentsProps): ReactElement;
 
 /**
  * Default render of the scheduled-export dialog's destination region: the notification-channel
@@ -4521,6 +4854,15 @@ export declare function DefaultScheduledEmailDialog(props: IDefaultScheduledEmai
  */
 export declare function DefaultScheduledEmailDialogDestination({ notificationChannels, selectedNotificationChannelId, onChange }: IAutomationDialogDestinationProps): JSX.Element;
 
+/**
+ * Default render of the scheduled-export dialog's evaluation-mode field.
+ * Props-driven — reads no context. The default dialog and {@link ScheduledEmailDialogEvaluationMode}
+ * render it with {@link useScheduledEmailDialogEvaluationModeProps}.
+ *
+ * @alpha
+ */
+export declare function DefaultScheduledEmailDialogEvaluationMode(props: IScheduledEmailDialogEvaluationModeProps): ReactElement;
+
 /**
  * Default render of the scheduled-export dialog's filters region: the filter and parameter chips of
  * the Filters tab, flat or per dashboard tab. The title is hidden and the list always expanded
@@ -4542,6 +4884,15 @@ export declare function DefaultScheduledEmailDialogFilters(props: IScheduledEmai
  */
 export declare const DefaultScheduledEmailDialogHeader: ForwardRefExoticComponent<IScheduledEmailDialogHeaderProps & RefAttributes<HTMLInputElement>>;
 
+/**
+ * Default render of the scheduled-export dialog's message field.
+ * Props-driven — reads no context. The default dialog and {@link ScheduledEmailDialogMessage}
+ * render it with {@link useScheduledEmailDialogMessageProps}.
+ *
+ * @alpha
+ */
+export declare function DefaultScheduledEmailDialogMessage(props: IScheduledEmailDialogMessageProps): ReactElement;
+
 /**
  * Default render of the scheduled-export dialog's recipients region: the recipients select.
  * Props-driven — reads no context. The default dialog and {@link ScheduledEmailDialogRecipients}
@@ -4552,6 +4903,24 @@ export declare const DefaultScheduledEmailDialogHeader: ForwardRefExoticComponen
  */
 export declare function DefaultScheduledEmailDialogRecipients(props: IScheduledEmailDialogRecipientsProps): JSX.Element;
 
+/**
+ * Default render of the scheduled-export dialog's recurrence field: the recurrence form.
+ * Props-driven — reads no context. The default dialog and {@link ScheduledEmailDialogRecurrence}
+ * render it with {@link useScheduledEmailDialogRecurrenceProps}.
+ *
+ * @alpha
+ */
+export declare function DefaultScheduledEmailDialogRecurrence(props: IScheduledEmailDialogRecurrenceProps): ReactElement;
+
+/**
+ * Default render of the scheduled-export dialog's subject field.
+ * Props-driven — reads no context. The default dialog and {@link ScheduledEmailDialogSubject}
+ * render it with {@link useScheduledEmailDialogSubjectProps}.
+ *
+ * @alpha
+ */
+export declare function DefaultScheduledEmailDialogSubject(props: IScheduledEmailDialogSubjectProps): ReactElement;
+
 /**
  * The "Time zone" section of the scheduled-email dialog's General tab. Unlike the
  * dashboard-settings timezone picker, the dropdown offers no browser-detected option — the
@@ -4568,6 +4937,15 @@ export declare function DefaultScheduledEmailDialogRecipients(props: IScheduledE
  */
 export declare function DefaultScheduledEmailDialogTimezone({ isWidget, selection, defaultResolvedTimezone, onTimezoneChange }: IScheduledEmailDialogTimezoneProps): JSX.Element;
 
+/**
+ * Default render of the scheduled-export dialog's widget-attachments field.
+ * Props-driven — reads no context. The default dialog and {@link ScheduledEmailDialogWidgetAttachments}
+ * render it with {@link useScheduledEmailDialogWidgetAttachmentsProps}.
+ *
+ * @alpha
+ */
+export declare function DefaultScheduledEmailDialogWidgetAttachments(props: IScheduledEmailDialogWidgetAttachmentsProps): ReactElement;
+
 /**
  * @alpha
  */
@@ -6396,6 +6774,158 @@ export declare interface IAlertFiltersContextValue {
  */
 export declare type IAlertingDialogActionBarBlockProps = IUseAlertingDialogActionBarPropsInput & Partial<IAutomationDialogActionBarProps>;
 
+/**
+ * Props of the default alerting dialog's attribute field (the "For" row).
+ *
+ * @alpha
+ */
+export declare interface IAlertingDialogAttributeProps {
+    /**
+     * Id of the dropdown button; the form row's label points at it.
+     */
+    id: string;
+    /**
+     * Disables the select. The default dialog disables it when the dialog has no insight to pick measures from.
+     */
+    disabled?: boolean;
+    /**
+     * The attribute the condition is sliced by; undefined for the whole measure.
+     */
+    selectedAttribute: AlertAttribute | undefined;
+    /**
+     * The attribute element the condition is sliced to; null for the empty value, undefined for all values.
+     */
+    selectedValue: string | null | undefined;
+    /**
+     * Called with the picked attribute and value; `(undefined, undefined)` clears the slice.
+     */
+    onAttributeChange: (attribute: AlertAttribute | undefined, value: AttributeValue | undefined) => void;
+    /**
+     * The insight's attributes; the select offers the non-date ones and renders nothing when there is none.
+     */
+    attributes: AlertAttribute[];
+    /**
+     * The workspace catalog's attributes, to resolve titles and display forms.
+     */
+    catalogAttributes: ICatalogAttribute[];
+    /**
+     * The workspace catalog's date datasets, to resolve date attributes.
+     */
+    catalogDateDatasets: ICatalogDateDataset[];
+    /**
+     * Distinct values of an attribute in the widget's execution result.
+     */
+    getAttributeValues: (attribute: IAttributeMetadataObject) => AttributeValue[];
+    /**
+     * Disables the select while the execution result is loading.
+     */
+    isResultLoading?: boolean;
+    /**
+     * Renders the select's own "For" label above the control. The default dialog passes false — the
+     * form row carries the label.
+     */
+    showLabel?: boolean;
+    /**
+     * Closes the dropdown when an ancestor scrolls; the default dialog sets it.
+     */
+    closeOnParentScroll?: boolean;
+}
+
+/**
+ * Props of the default alerting dialog's comparison-operator field (the "Condition" row).
+ *
+ * @alpha
+ */
+export declare interface IAlertingDialogComparisonOperatorProps {
+    /**
+     * Id of the dropdown button; the form row's label points at it.
+     */
+    id: string;
+    /**
+     * The measure the condition targets; the select renders nothing without one.
+     */
+    measure: AlertMetric | undefined;
+    /**
+     * Offers the anomaly-detection operators. The default dialog passes the conjunction of the
+     * `enableAnomalyDetectionAlert` and `canUseAiAssistant` features; pass false to hide those
+     * options.
+     */
+    enableAnomalyDetectionAlert: boolean;
+    /**
+     * The operator of a fixed-threshold condition, when that is the condition type.
+     */
+    selectedComparisonOperator: IAlertComparisonOperator | undefined;
+    /**
+     * The relative and arithmetic operators of a relative condition, when that is the condition type.
+     */
+    selectedRelativeOperator: [IAlertRelativeOperator, IAlertRelativeArithmeticOperator] | undefined;
+    /**
+     * The operator id of an anomaly-detection condition, when that is the condition type.
+     */
+    selectedAiOperator: AlertAiOperator | undefined;
+    /**
+     * Called when a fixed-threshold operator is picked.
+     */
+    onComparisonOperatorChange: (measure: AlertMetric, comparisonOperator: IAlertComparisonOperator) => void;
+    /**
+     * Called when the anomaly-detection operator is picked.
+     */
+    onAnomalyDetectionChange: (measure: AlertMetric) => void;
+    /**
+     * Called when a relative (change / difference) operator is picked.
+     */
+    onRelativeOperatorChange: (measure: AlertMetric, relativeOperator: IAlertRelativeOperator, arithmeticOperator: IAlertRelativeArithmeticOperator) => void;
+    /**
+     * Positioning of the dropdown overlay; the default dialog uses `"sameAsTarget"`.
+     */
+    overlayPositionType?: OverlayPositionType;
+    /**
+     * Closes the dropdown when an ancestor scrolls; the default dialog sets it.
+     */
+    closeOnParentScroll?: boolean;
+}
+
+/**
+ * Props of the default alerting dialog's comparison-period field (the "Compared to" row).
+ *
+ * @alpha
+ */
+export declare interface IAlertingDialogComparisonPeriodProps {
+    /**
+     * Id of the dropdown button; the form row's label points at it.
+     */
+    id: string;
+    /**
+     * The alert draft; the select renders nothing unless its condition is a change or difference.
+     */
+    alert: IAutomationMetadataObjectDefinition | undefined;
+    /**
+     * The measure the condition targets, whose comparators are the options; with a single
+     * comparator the select renders it as static text.
+     */
+    measure: AlertMetric | undefined;
+    /**
+     * The selected period comparison.
+     */
+    selectedComparison?: AlertMetricComparatorType;
+    /**
+     * The selected granularity of the period shift.
+     */
+    selectedGranularity?: DateAttributeGranularity;
+    /**
+     * Called with the picked comparison and its granularity.
+     */
+    onComparisonChange: (comparison: AlertMetricComparatorType, granularity?: DateAttributeGranularity) => void;
+    /**
+     * Positioning of the dropdown overlay; the default dialog uses `"sameAsTarget"`.
+     */
+    overlayPositionType?: OverlayPositionType;
+    /**
+     * Closes the dropdown when an ancestor scrolls; the default dialog sets it.
+     */
+    closeOnParentScroll?: boolean;
+}
+
 /**
  * Sub-context for the alerting create/edit dialog.
  *
@@ -6451,6 +6981,54 @@ export declare interface IAlertingDialogFiltersProps extends IAutomationDialogFi
     disableDateFilters: boolean;
 }
 
+/**
+ * Props of {@link AlertingDialogFormFieldGroup}.
+ *
+ * @alpha
+ */
+export declare interface IAlertingDialogFormFieldGroupProps {
+    /**
+     * The group heading in the label column — "When" (the condition) and "Do" (the action) in the default dialog.
+     */
+    label: ReactNode;
+    /**
+     * The field rows of the group — {@link AlertingDialogMeasure} and its siblings.
+     */
+    children: ReactNode;
+}
+
+/**
+ * Props of the default alerting dialog's granularity field (anomaly detection).
+ *
+ * @alpha
+ */
+export declare interface IAlertingDialogGranularityProps {
+    /**
+     * Id of the dropdown button; the form row's label points at it.
+     */
+    id: string;
+    /**
+     * Offers the `"HOUR"` granularity.
+     */
+    allowHourlyRecurrence: boolean;
+    /**
+     * The anomaly-detection granularity; undefined renders as `"WEEK"`.
+     */
+    selectedGranularity: IAlertAnomalyDetectionGranularity | undefined;
+    /**
+     * Called with the picked granularity.
+     */
+    onGranularityChange: (granularity: IAlertAnomalyDetectionGranularity) => void;
+    /**
+     * Positioning of the dropdown overlay; the default dialog uses `"sameAsTarget"`.
+     */
+    overlayPositionType?: OverlayPositionType;
+    /**
+     * Closes the dropdown when an ancestor scrolls; the default dialog sets it.
+     */
+    closeOnParentScroll?: boolean;
+}
+
 /**
  * Props of the default alerting dialog's header region (the title input row).
  *
@@ -6463,6 +7041,42 @@ export declare interface IAlertingDialogHeaderProps extends IAutomationDialogHea
     onCancel?: () => void;
 }
 
+/**
+ * Props of the default alerting dialog's measure field (the "Metric" row).
+ *
+ * @alpha
+ */
+export declare interface IAlertingDialogMeasureProps {
+    /**
+     * Id of the dropdown button; the form row's label points at it.
+     */
+    id?: string;
+    /**
+     * Disables the select. The default dialog disables it when the dialog has no insight to pick measures from.
+     */
+    disabled?: boolean;
+    /**
+     * The measure the condition targets; undefined shows the placeholder.
+     */
+    selectedMeasure: AlertMetric | undefined;
+    /**
+     * Called with the picked measure.
+     */
+    onMeasureChange: (measure: AlertMetric) => void;
+    /**
+     * The insight's measures an alert can be built on.
+     */
+    measures: AlertMetric[];
+    /**
+     * Positioning of the dropdown overlay; the default dialog uses `"sameAsTarget"`.
+     */
+    overlayPositionType?: OverlayPositionType;
+    /**
+     * Closes the dropdown when an ancestor scrolls; the default dialog sets it.
+     */
+    closeOnParentScroll?: boolean;
+}
+
 /**
  * @alpha
  */
@@ -6545,62 +7159,227 @@ export declare interface IAlertingDialogProps {
 }
 
 /**
- * Section-level overrides of the default alerting dialog.
+ * Props of the default alerting dialog's sensitivity field (anomaly detection).
+ *
+ * @alpha
+ */
+export declare interface IAlertingDialogSensitivityProps {
+    /**
+     * Id of the dropdown button; the form row's label points at it.
+     */
+    id: string;
+    /**
+     * The anomaly-detection sensitivity; undefined renders as `"MEDIUM"`.
+     */
+    selectedSensitivity: IAlertAnomalyDetectionSensitivity | undefined;
+    /**
+     * Called with the picked sensitivity.
+     */
+    onSensitivityChange: (sensitivity: IAlertAnomalyDetectionSensitivity) => void;
+    /**
+     * Positioning of the dropdown overlay; the default dialog uses `"sameAsTarget"`.
+     */
+    overlayPositionType?: OverlayPositionType;
+    /**
+     * Closes the dropdown when an ancestor scrolls; the default dialog sets it.
+     */
+    closeOnParentScroll?: boolean;
+}
+
+/**
+ * Props of {@link AlertingDialogShell}.
+ *
+ * @alpha
+ */
+export declare interface IAlertingDialogShellProps extends Pick<IAlertingDialogProps, "onCancel" | "onDeleteSuccess" | "onDeleteError"> {
+    /**
+     * The dialog's single submit — `submit` of the caller's {@link useAlertSubmit} instance. Drives the
+     * footer's submit button and the Enter key on it. The shell does not own the submit hook, so a
+     * caller's own Enter handler or button can share the same instance. Create the hook instance only
+     * once the dialog context reports `isLoading: false`.
+     */
+    onSubmit: () => void;
+    /**
+     * `isSaving` of the same {@link useAlertSubmit} instance: disables submit and Delete and shows the
+     * footer's progress indicator.
+     */
+    isSaving: boolean;
+    /**
+     * Header and action-bar overrides — the Level 1 slot contract ({@link IAlertingDialogSlots.Header},
+     * {@link IAlertingDialogSlots.ActionBar}): each slot receives `{ Default, defaultProps }`, where
+     * `defaultProps` are the shell's live values (the header's `onCancel` and initial-focus `ref`; the
+     * action bar's `onSubmit`, `isSaving`, `onDelete`). Slot components need a stable reference identity —
+     * see {@link @gooddata/sdk-ui-kit#ISlotProps}. The body regions have no slot here: place their blocks
+     * ({@link AlertingDialogFilters} and siblings) as children instead.
+     */
+    slots?: Pick<IAlertingDialogSlots, "Header" | "ActionBar">;
+    /**
+     * Rendered first inside the dialog's scrollable content area, above `children`.
+     */
+    topContent?: ReactNode;
+    /**
+     * Rendered last inside the scrollable content area, below `children` and the dialog's warning and
+     * validation messages.
+     */
+    bottomContent?: ReactNode;
+    /**
+     * The body: the regions and fields, in the caller's order — {@link AlertingDialogFilters},
+     * {@link AlertingDialogFormFieldGroup} with the condition and action blocks, and so on. Not mounted
+     * while `useAlertingDialogContext().isLoading` is true (the shell shows its loading skeleton) or while
+     * the stale-filters confirmation step is shown.
+     */
+    children?: ReactNode;
+}
+
+/**
+ * Section-level overrides of the default alerting dialog.
+ *
+ * @alpha
+ */
+export declare interface IAlertingDialogSlots {
+    /**
+     * Wraps or replaces the dialog header (the title input row). Must have a stable reference
+     * identity — see {@link @gooddata/sdk-ui-kit#ISlotProps}.
+     */
+    Header?: ComponentType<ISlotProps<AlertingDialogHeaderDefaultProps>>;
+    /**
+     * Wraps or replaces the dialog's filters region (the filter and parameter chips). Must have
+     * a stable reference identity — see {@link @gooddata/sdk-ui-kit#ISlotProps}.
+     *
+     * Renders only in the fully rendered dialog: not while the dialog context reports loading,
+     * and not while the stale-filters confirmation step is shown.
+     *
+     * A replacement takes over computing the next filters array: `defaultProps.onFiltersChange`
+     * expects the complete selection, so change/remove/add gestures must submit the whole
+     * updated array, not a delta.
+     */
+    Filters?: ComponentType<ISlotProps<IAlertingDialogFiltersProps>>;
+    /**
+     * Wraps or replaces the dialog's destination region (the "Action" row selecting the
+     * notification channel). Must have a stable reference identity — see {@link @gooddata/sdk-ui-kit#ISlotProps}.
+     *
+     * Renders only in the fully rendered dialog — not while the dialog context reports loading,
+     * not while the stale-filters confirmation step is shown — **and only when more than one
+     * notification channel exists**: with a single channel the default dialog hides the whole
+     * row, and the slot with it.
+     */
+    Destination?: ComponentType<ISlotProps<IAutomationDialogDestinationProps>>;
+    /**
+     * Wraps or replaces the dialog's recipients region. Must have a stable reference identity —
+     * see {@link @gooddata/sdk-ui-kit#ISlotProps}.
+     *
+     * Renders only in the fully rendered dialog: not while the dialog context reports loading,
+     * and not while the stale-filters confirmation step is shown.
+     */
+    Recipients?: ComponentType<ISlotProps<IAutomationDialogRecipientsProps>>;
+    /**
+     * Wraps or replaces the dialog's action bar (the footer row: documentation link, Delete in
+     * edit mode, Cancel and the submit button). Must have a stable reference identity — see
+     * {@link @gooddata/sdk-ui-kit#ISlotProps}.
+     *
+     * Renders only in the fully rendered dialog: not while the dialog context reports loading
+     * (the loading dialog keeps its own footer), and not while the stale-filters confirmation
+     * step is shown.
+     *
+     * A replacement that does not render `Default` loses the submit button's Enter-key detection
+     * id (Enter no longer submits), the validation aria wiring, and the default row's ordering.
+     * Wraps that render `<Default {...defaultProps} />` keep everything; note the Enter-key path
+     * invokes the dialog's own submit handler and disabled state, so `defaultProps` overrides
+     * affect the buttons only.
+     */
+    ActionBar?: ComponentType<ISlotProps<IAutomationDialogActionBarProps>>;
+}
+
+/**
+ * Props of the default alerting dialog's threshold field (the "Threshold" row).
+ *
+ * @alpha
+ */
+export declare interface IAlertingDialogThresholdProps {
+    /**
+     * Id of the input; the form row's label and the error message point at it.
+     */
+    id: string;
+    /**
+     * The threshold shown; undefined for an empty input.
+     */
+    value: number | undefined;
+    /**
+     * Called with the raw input value on every keystroke.
+     */
+    onChange: (value: string | number) => void;
+    /**
+     * Called on blur; the default dialog rounds the value to the measure's format here.
+     */
+    onBlur: (event: FocusEvent_2<HTMLInputElement>) => void;
+    /**
+     * Unit shown after the input — `"%"` for a change condition.
+     */
+    suffix?: string;
+    /**
+     * Validation message shown under the input; undefined when there is none.
+     */
+    errorMessage?: string;
+}
+
+/**
+ * Props of the default alerting dialog's trigger-interval field (the "Interval" row).
+ *
+ * @alpha
+ */
+export declare interface IAlertingDialogTriggerIntervalProps {
+    /**
+     * Id of the dropdown button; the form row's label points at it.
+     */
+    id: string;
+    /**
+     * The interval of a `"ONCE_PER_INTERVAL"` trigger.
+     */
+    selectedTriggerInterval: IAlertTriggerInterval;
+    /**
+     * Called with the picked interval.
+     */
+    onTriggerIntervalChange: (triggerInterval: IAlertTriggerInterval) => void;
+    /**
+     * Positioning of the dropdown overlay; the default dialog uses `"sameAsTarget"`.
+     */
+    overlayPositionType?: OverlayPositionType;
+    /**
+     * Closes the dropdown when an ancestor scrolls; the default dialog sets it.
+     */
+    closeOnParentScroll?: boolean;
+}
+
+/**
+ * Props of the default alerting dialog's trigger-mode field (the "Trigger" row).
  *
  * @alpha
  */
-export declare interface IAlertingDialogSlots {
+export declare interface IAlertingDialogTriggerModeProps {
     /**
-     * Wraps or replaces the dialog header (the title input row). Must have a stable reference
-     * identity — see {@link @gooddata/sdk-ui-kit#ISlotProps}.
+     * Id of the dropdown button; the form row's label points at it.
      */
-    Header?: ComponentType<ISlotProps<AlertingDialogHeaderDefaultProps>>;
+    id: string;
     /**
-     * Wraps or replaces the dialog's filters region (the filter and parameter chips). Must have
-     * a stable reference identity — see {@link @gooddata/sdk-ui-kit#ISlotProps}.
-     *
-     * Renders only in the fully rendered dialog: not while the dialog context reports loading,
-     * and not while the stale-filters confirmation step is shown.
-     *
-     * A replacement takes over computing the next filters array: `defaultProps.onFiltersChange`
-     * expects the complete selection, so change/remove/add gestures must submit the whole
-     * updated array, not a delta.
+     * When the alert fires: `"ALWAYS"`, `"ONCE"` or `"ONCE_PER_INTERVAL"`.
      */
-    Filters?: ComponentType<ISlotProps<IAlertingDialogFiltersProps>>;
+    selectedTriggerMode: IAlertTriggerMode;
     /**
-     * Wraps or replaces the dialog's destination region (the "Action" row selecting the
-     * notification channel). Must have a stable reference identity — see {@link @gooddata/sdk-ui-kit#ISlotProps}.
-     *
-     * Renders only in the fully rendered dialog — not while the dialog context reports loading,
-     * not while the stale-filters confirmation step is shown — **and only when more than one
-     * notification channel exists**: with a single channel the default dialog hides the whole
-     * row, and the slot with it.
+     * Called with the picked mode.
      */
-    Destination?: ComponentType<ISlotProps<IAutomationDialogDestinationProps>>;
+    onTriggerModeChange: (triggerMode: IAlertTriggerMode) => void;
     /**
-     * Wraps or replaces the dialog's recipients region. Must have a stable reference identity —
-     * see {@link @gooddata/sdk-ui-kit#ISlotProps}.
-     *
-     * Renders only in the fully rendered dialog: not while the dialog context reports loading,
-     * and not while the stale-filters confirmation step is shown.
+     * Positioning of the dropdown overlay; the default dialog uses `"sameAsTarget"`.
      */
-    Recipients?: ComponentType<ISlotProps<IAutomationDialogRecipientsProps>>;
+    overlayPositionType?: OverlayPositionType;
     /**
-     * Wraps or replaces the dialog's action bar (the footer row: documentation link, Delete in
-     * edit mode, Cancel and the submit button). Must have a stable reference identity — see
-     * {@link @gooddata/sdk-ui-kit#ISlotProps}.
-     *
-     * Renders only in the fully rendered dialog: not while the dialog context reports loading
-     * (the loading dialog keeps its own footer), and not while the stale-filters confirmation
-     * step is shown.
-     *
-     * A replacement that does not render `Default` loses the submit button's Enter-key detection
-     * id (Enter no longer submits), the validation aria wiring, and the default row's ordering.
-     * Wraps that render `<Default {...defaultProps} />` keep everything; note the Enter-key path
-     * invokes the dialog's own submit handler and disabled state, so `defaultProps` overrides
-     * affect the buttons only.
+     * Closes the dropdown when an ancestor scrolls; the default dialog sets it.
      */
-    ActionBar?: ComponentType<ISlotProps<IAutomationDialogActionBarProps>>;
+    closeOnParentScroll?: boolean;
+    /**
+     * Offers `"ONCE_PER_INTERVAL"`; the default dialog passes the feature flag.
+     */
+    enableAlertOncePerInterval?: boolean;
 }
 
 /**
@@ -6623,6 +7402,18 @@ export declare interface IAlertingManagementDialogContextValue {
     automationsInvalidationId?: number;
     isEmbedded: boolean;
     enableAccessibilityMode: boolean;
+    /**
+     * Alerts visible in the management dialog, scoped to the current dashboard context.
+     */
+    automations: IAutomationMetadataObject[];
+    /**
+     * True while the automation list is still loading.
+     *
+     * The automations load only — deliberately narrower than the scheduled-email management
+     * context's flag, which also folds in a widget-filters load that has no bearing on a
+     * management list.
+     */
+    isLoading: boolean;
     getWidgetByRef: (ref: ObjRef | undefined) => IWidget | undefined;
     getInsightByWidgetRef: (ref: ObjRef | undefined) => IInsight | undefined;
     pauseAlert(alert: IAutomationMetadataObject): Promise<IAutomationMetadataObject>;
@@ -7029,6 +7820,30 @@ export declare interface IAutomationDialogFiltersProps {
     onParameterDelete: (ref: IdentifierRef) => void;
 }
 
+/**
+ * Props of {@link AutomationDialogFormField}: a labelled form row of the automation dialogs.
+ *
+ * @alpha
+ */
+export declare interface IAutomationDialogFormFieldProps {
+    /**
+     * The row's label, rendered in a `<label>` on the left.
+     */
+    label: ReactNode;
+    /**
+     * The control, rendered on the right.
+     */
+    children: ReactNode;
+    /**
+     * The id of the control the label is for.
+     */
+    htmlFor?: string;
+    /**
+     * Lets the control span the full row width instead of the default control column.
+     */
+    fullWidth?: boolean;
+}
+
 /**
  * Members shared by both automation dialogs' header regions.
  *
@@ -18385,6 +19200,79 @@ export declare interface IScheduledEmailDialogContextValue {
     isLoading: boolean;
 }
 
+/**
+ * Props of the scheduled-export dialog's dashboard-attachments field.
+ *
+ * @alpha
+ */
+export declare interface IScheduledEmailDialogDashboardAttachmentsProps {
+    /**
+     * The selected export formats.
+     */
+    selectedAttachments: DashboardAttachmentType[];
+    /**
+     * Dashboard filters the export is scoped to; the control passes them back as the second
+     * argument of every {@link IScheduledEmailDialogDashboardAttachmentsProps.onDashboardAttachmentsChange}
+     * call.
+     */
+    dashboardFilters?: FilterContextItem[];
+    /**
+     * When true and at least one attachment is selected, the control shows the notice that
+     * exports do not reflect cross-filtering.
+     */
+    isCrossFiltering: boolean;
+    /**
+     * Replaces the selected dashboard export formats. Called with the complete new selection and
+     * the current {@link IScheduledEmailDialogDashboardAttachmentsProps.dashboardFilters}.
+     */
+    onDashboardAttachmentsChange: (formats: DashboardAttachmentType[], filters?: FilterContextItem[]) => void;
+    /**
+     * XLSX export settings shown in the attachment's settings editor.
+     */
+    xlsxSettings: IExportDefinitionVisualizationObjectSettings;
+    /**
+     * Sets the XLSX export settings.
+     */
+    onXlsxSettingsChange: (settings: IExportDefinitionVisualizationObjectSettings) => void;
+    /**
+     * Whether the slide-based formats (PPTX, PDF slides) are offered; when false they are
+     * excluded from the add-attachment options.
+     */
+    isSlidesExportEnabled: boolean;
+    /**
+     * Export templates offered in the template picker of the slide-based formats.
+     */
+    exportTemplates?: IExportTemplate[];
+    /**
+     * The template chosen per slide-based format; undefined where the default template applies.
+     */
+    slidesTemplateIds?: {
+        PPTX?: string;
+        PDF_SLIDES?: string;
+        PDF?: string;
+    };
+    /**
+     * Sets the export template of one slide-based format.
+     */
+    onSlidesTemplateIdChange?: (templateId: string | undefined, format: "PPTX" | "PDF_SLIDES" | "PDF") => void;
+}
+
+/**
+ * Props of the scheduled-export dialog's evaluation-mode checkbox.
+ *
+ * @alpha
+ */
+export declare interface IScheduledEmailDialogEvaluationModeProps {
+    /**
+     * Whether the evaluation mode is SHARED.
+     */
+    isShared: boolean;
+    /**
+     * Switches between a shared and a per-recipient evaluation of the export.
+     */
+    onChange: (isShared: boolean) => void;
+}
+
 /**
  * Props of the default scheduled email dialog's filters region (the Filters tab content).
  *
@@ -18469,6 +19357,22 @@ export declare interface IScheduledEmailDialogHeaderProps extends IAutomationDia
     onBack?: () => void;
 }
 
+/**
+ * Props of the scheduled-export dialog's message field.
+ *
+ * @alpha
+ */
+export declare interface IScheduledEmailDialogMessageProps {
+    /**
+     * The e-mail message text.
+     */
+    value: string;
+    /**
+     * Sets the e-mail message; `isValid` is the field's own length verdict.
+     */
+    onChange: (value: string, isValid: boolean) => void;
+}
+
 /**
  * @alpha
  */
@@ -18605,6 +19509,120 @@ export declare interface IScheduledEmailDialogRecipientsProps extends IAutomatio
     onKeyDownSubmit: (e: KeyboardEvent_2) => void;
 }
 
+/**
+ * Props of the scheduled-export dialog's recurrence field.
+ *
+ * @alpha
+ */
+export declare interface IScheduledEmailDialogRecurrenceProps {
+    /**
+     * First-run date the cron editor is anchored to.
+     */
+    startDate: Date;
+    /**
+     * The draft's cron expression.
+     */
+    cronExpression: string;
+    /**
+     * Human-readable description of the cron expression, when the draft carries one.
+     */
+    cronDescription?: string;
+    /**
+     * Display-only timezone label shown in the occurrence description.
+     */
+    timezone: string;
+    /**
+     * Date format used by the first-run date picker.
+     */
+    dateFormat: string;
+    /**
+     * Locale of the recurrence editor.
+     */
+    locale: string;
+    /**
+     * First day of the week in the date picker.
+     */
+    weekStart: WeekStart;
+    /**
+     * Whether the hourly recurrence option is offered.
+     */
+    allowHourlyRecurrence: boolean;
+    /**
+     * Hides GoodData-specific copy when white-labeled.
+     */
+    isWhiteLabeled: boolean;
+    /**
+     * Closes the recurrence dropdowns when the dialog body scrolls.
+     */
+    closeDropdownsOnParentScroll: boolean;
+    /**
+     * Sets the cron expression and first run; `isValid` is the recurrence form's own verdict.
+     */
+    onChange: (cronExpression: string, startDate: Date | null, isValid: boolean) => void;
+    /**
+     * Key-down handler; the dialog submits on Enter through it.
+     */
+    onKeyDownSubmit: (event: KeyboardEvent_2) => void;
+}
+
+/**
+ * Props of {@link ScheduledEmailDialogShell}.
+ *
+ * @alpha
+ */
+export declare interface IScheduledEmailDialogShellProps extends Pick<IScheduledEmailDialogProps, "onCancel" | "onBack" | "onDeleteSuccess" | "onDeleteError"> {
+    /**
+     * The dialog's single save — `handleSaveScheduledEmail` of the caller's
+     * {@link useSaveScheduledEmailToBackend} instance. Drives the footer's submit button, the Enter key on
+     * it, and the header's Enter-to-submit. (Not the `onSubmit` observer of {@link IScheduledEmailDialogProps};
+     * that one goes to the save hook.) The shell does not own the save hook, so the caller's own Enter
+     * handlers — {@link useScheduledEmailSubmitOnEnter} — share the same instance. Create the hook instance
+     * only once the dialog context reports `isLoading: false`.
+     */
+    onSubmit: () => void;
+    /**
+     * `isSavingScheduledEmail` of the same instance: disables submit and Delete and shows the footer's
+     * progress indicator.
+     */
+    isSaving: boolean;
+    /**
+     * `savingErrorMessage` of the same instance; shown as the body's error message, ahead of the form's
+     * validation message.
+     */
+    savingErrorMessage?: string;
+    /**
+     * Header, action-bar and Filters-tab overrides — the Level 1 slot contract
+     * ({@link IScheduledEmailDialogSlots.Header}, {@link IScheduledEmailDialogSlots.ActionBar},
+     * {@link IScheduledEmailDialogSlots.Filters}): each slot receives `{ Default, defaultProps }` with the
+     * shell's live values. Slot components need a stable reference identity — see
+     * {@link @gooddata/sdk-ui-kit#ISlotProps}. `Filters` is ignored when `filtersTabContent` is passed. The
+     * General-tab regions have no slot here: place their blocks ({@link ScheduledEmailDialogDestination} and
+     * siblings) as children instead.
+     */
+    slots?: Pick<IScheduledEmailDialogSlots, "Header" | "ActionBar" | "Filters">;
+    /**
+     * Rendered first inside the dialog's scrollable content area, above the selected tab's content.
+     */
+    topContent?: ReactNode;
+    /**
+     * Rendered last inside the scrollable content area, below the selected tab's content.
+     */
+    bottomContent?: ReactNode;
+    /**
+     * The General tab's content: the regions and fields, in the caller's order. Rendered only while the
+     * General tab is selected; not mounted while `useScheduledEmailDialogContext().isLoading` is true (the
+     * shell shows its loading skeleton — on scheduled email the ordinary path while a widget export's
+     * filters load) or while the stale-filters confirmation step is shown.
+     */
+    children?: ReactNode;
+    /**
+     * The Filters tab's content. Defaults to the dialog's filters region ({@link DefaultScheduledEmailDialogFilters}
+     * with {@link useScheduledEmailDialogFiltersProps}, or the `Filters` slot). Rendered only while the Filters
+     * tab is selected. An explicit `null` counts as provided and renders an empty Filters tab.
+     */
+    filtersTabContent?: ReactNode;
+}
+
 /**
  * Section-level overrides of the default scheduled email dialog.
  *
@@ -18674,34 +19692,136 @@ export declare interface IScheduledEmailDialogSlots {
      * invokes the dialog's own submit handler and disabled state, so `defaultProps` overrides
      * affect the buttons only.
      */
-    ActionBar?: ComponentType<ISlotProps<IAutomationDialogActionBarProps>>;
-}
-
-/**
- * Props of the default scheduled email dialog's "Time zone" section (the export-content timezone
- * picker on the General tab; unrelated to the schedule cron timezone).
- *
- * @alpha
- */
-export declare interface IScheduledEmailDialogTimezoneProps {
+    ActionBar?: ComponentType<ISlotProps<IAutomationDialogActionBarProps>>;
+}
+
+/**
+ * Props of the scheduled-export dialog's subject field.
+ *
+ * @alpha
+ */
+export declare interface IScheduledEmailDialogSubjectProps {
+    /**
+     * Dashboard title, used as the subject placeholder (truncated to the title max length).
+     */
+    dashboardTitle: string;
+    /**
+     * The export draft; the field renders `details.subject`.
+     */
+    editedAutomation: IAutomationMetadataObjectDefinition;
+    /**
+     * Disables submit-on-Enter while the dialog is not submittable.
+     */
+    isSubmitDisabled?: boolean;
+    /**
+     * Sets the e-mail subject; `isValid` is the field's own length verdict.
+     */
+    onChange: (value: string, isValid: boolean) => void;
+    /**
+     * Called on Enter when submit is not disabled.
+     */
+    onKeyDownSubmit: () => void;
+}
+
+/**
+ * Props of the default scheduled email dialog's "Time zone" section (the export-content timezone
+ * picker on the General tab; unrelated to the schedule cron timezone).
+ *
+ * @alpha
+ */
+export declare interface IScheduledEmailDialogTimezoneProps {
+    /**
+     * Whether the dialog schedules a single-widget export. Widget schedules always show a concrete
+     * resolved timezone — they have no Default option, because the backend cannot derive anything
+     * dashboard-scoped for them.
+     */
+    isWidget: boolean;
+    /**
+     * Current selection; an undefined id is the Default option (dashboard schedules only).
+     */
+    selection: IScheduleTimezoneSelection;
+    /**
+     * Concrete timezone the Default option currently resolves to (display only).
+     */
+    defaultResolvedTimezone: string | undefined;
+    /**
+     * Called with the picked timezone; undefined selects the Default option.
+     */
+    onTimezoneChange: (timezoneId: string | undefined) => void;
+}
+
+/**
+ * Props of the scheduled-export dialog's widget-attachments field.
+ *
+ * @alpha
+ */
+export declare interface IScheduledEmailDialogWidgetAttachmentsProps {
+    /**
+     * The selected export formats.
+     */
+    selectedAttachments: WidgetAttachmentType[];
+    /**
+     * Replaces the selected widget export formats with the complete new selection.
+     */
+    onWidgetAttachmentsChange: (formats: WidgetAttachmentType[]) => void;
+    /**
+     * XLSX export settings shown in the attachment's settings editor.
+     */
+    xlsxSettings: IExportDefinitionVisualizationObjectSettings;
+    /**
+     * Sets the XLSX export settings.
+     */
+    onXlsxSettingsChange: (settings: IExportDefinitionVisualizationObjectSettings) => void;
+    /**
+     * Tabular-PDF export settings shown in the attachment's settings editor.
+     */
+    pdfSettings: IExportDefinitionVisualizationObjectSettings;
+    /**
+     * Sets the tabular-PDF export settings.
+     */
+    onPdfSettingsChange: (settings: IExportDefinitionVisualizationObjectSettings) => void;
+    /**
+     * CSV export settings shown in the attachment's settings editor.
+     */
+    csvSettings: IExportDefinitionVisualizationObjectSettings;
     /**
-     * Whether the dialog schedules a single-widget export. Widget schedules always show a concrete
-     * resolved timezone — they have no Default option, because the backend cannot derive anything
-     * dashboard-scoped for them.
+     * Sets the CSV export settings.
      */
-    isWidget: boolean;
+    onCsvSettingsChange: (settings: IExportDefinitionVisualizationObjectSettings) => void;
     /**
-     * Current selection; an undefined id is the Default option (dashboard schedules only).
+     * Raw-CSV export settings shown in the attachment's settings editor.
      */
-    selection: IScheduleTimezoneSelection;
+    csvRawSettings: IExportDefinitionVisualizationObjectSettings;
     /**
-     * Concrete timezone the Default option currently resolves to (display only).
+     * Sets the raw-CSV export settings.
      */
-    defaultResolvedTimezone: string | undefined;
+    onCsvRawSettingsChange: (settings: IExportDefinitionVisualizationObjectSettings) => void;
     /**
-     * Called with the picked timezone; undefined selects the Default option.
+     * Whether the slide-based formats (PPTX, PDF) are offered; when false they are excluded
+     * from the add-attachment options.
      */
-    onTimezoneChange: (timezoneId: string | undefined) => void;
+    isSlidesExportEnabled: boolean;
+    /**
+     * When true, formats without an accessible rendering (PDF_TABULAR) are excluded from the
+     * add-attachment options.
+     */
+    isAccessibilityModeEnabled: boolean;
+    /**
+     * Export templates offered in the template picker of the slide-based formats.
+     */
+    exportTemplates?: IExportTemplate[];
+    /**
+     * The template chosen per slide-based format; undefined where the default template applies.
+     */
+    slidesTemplateIds?: {
+        PPTX?: string;
+        PDF_SLIDES?: string;
+        PDF?: string;
+    };
+    /**
+     * Sets the export template of one slide-based format.
+     */
+    onSlidesTemplateIdChange?: (templateId: string | undefined, format: "PPTX" | "PDF_SLIDES" | "PDF") => void;
 }
 
 /**
@@ -22345,6 +23465,47 @@ export declare interface IUseScheduledEmailDialogRecipientsPropsInput {
     onKeyDownSubmit: (event: KeyboardEvent_2) => void;
 }
 
+/**
+ * Inputs of {@link useScheduledEmailDialogRecurrenceProps} that come from the dialog rather than its state.
+ *
+ * @alpha
+ */
+export declare interface IUseScheduledEmailDialogRecurrencePropsInput {
+    /**
+     * Key-down handler of the recurrence inputs; the dialog submits on Enter through it.
+     */
+    onKeyDownSubmit: (event: KeyboardEvent_2) => void;
+}
+
+/**
+ * Inputs of {@link useScheduledEmailDialogSubjectProps} that come from the dialog rather than its state.
+ *
+ * @alpha
+ */
+export declare interface IUseScheduledEmailDialogSubjectPropsInput {
+    /**
+     * Called on Enter in the subject input when submit is not disabled.
+     */
+    onKeyDownSubmit: () => void;
+}
+
+/**
+ * Inputs of {@link useScheduledEmailSubmitOnEnter} — the dialog's single save, from one
+ * {@link useSaveScheduledEmailToBackend} instance.
+ *
+ * @alpha
+ */
+export declare interface IUseScheduledEmailSubmitOnEnterInput {
+    /**
+     * `handleSaveScheduledEmail` of the dialog's {@link useSaveScheduledEmailToBackend} instance.
+     */
+    onSubmit: () => void;
+    /**
+     * `isSavingScheduledEmail` of the same instance; Enter does nothing while a save is in flight.
+     */
+    isSaving: boolean;
+}
+
 /**
  * @internal
  */
@@ -22375,6 +23536,39 @@ export declare interface IUseWidgetSelectionResult {
     hasConfigPanelOpen: boolean;
 }
 
+/**
+ * What {@link useWorkspaceUsersSearch} returns.
+ *
+ * @alpha
+ */
+export declare interface IUseWorkspaceUsersSearchResult {
+    /**
+     * The current, not yet debounced, search string.
+     */
+    search: string;
+    /**
+     * The workspace users of the last settled query; undefined until the first query settles.
+     */
+    users: IWorkspaceUser[] | undefined;
+    /**
+     * The last query's error, if it failed.
+     */
+    usersError: GoodDataSdkError | undefined;
+    /**
+     * True while the search debounce window or a query is open.
+     */
+    isLoading: boolean;
+    /**
+     * Sets the search string; the query fires after a 300 ms debounce.
+     */
+    onSearch: (search: string) => void;
+    /**
+     * Starts the first fetch — nothing loads on mount until this is called (wire it to the
+     * control's open/focus). After an error it doubles as retry.
+     */
+    onActivate: () => void;
+}
+
 /**
  * Set of functions you can use to customize some aspects of the VisualizationSwitcher.
  *
@@ -25050,6 +26244,20 @@ export declare function ScheduledEmailDialogActionBar(props: IScheduledEmailDial
  */
 export declare const ScheduledEmailDialogContextProvider: Provider<IScheduledEmailDialogContextValue | undefined>;
 
+/**
+ * The scheduled-export dialog's dashboard-attachments field, connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogDashboardAttachments} with the props of
+ * {@link useScheduledEmailDialogDashboardAttachmentsProps}; every prop passed here replaces the
+ * hook's value for that prop wholesale. Renders nothing while
+ * `useScheduledEmailDialogContext().isLoading` is true and when the dialog context has a `widget`
+ * (a widget schedule renders {@link ScheduledEmailDialogWidgetAttachments} instead), the same
+ * visibility the default dialog gives the field.
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogDashboardAttachments(props: Partial<IScheduledEmailDialogDashboardAttachmentsProps>): ReactElement;
+
 /**
  * The scheduled-export dialog's destination region (the notification-channel select), connected to
  * the dialog's state.
@@ -25062,6 +26270,20 @@ export declare const ScheduledEmailDialogContextProvider: Provider<IScheduledEma
  */
 export declare function ScheduledEmailDialogDestination(overrides: Partial<IAutomationDialogDestinationProps>): JSX.Element;
 
+/**
+ * The scheduled-export dialog's evaluation-mode checkbox, connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogEvaluationMode} with the props of
+ * {@link useScheduledEmailDialogEvaluationModeProps}; every prop passed here replaces the hook's
+ * value for that prop wholesale. Renders nothing while
+ * `useScheduledEmailDialogContext().isLoading` is true and while
+ * `useAutomationsContext().features.enableAutomationEvaluationMode` is off, the same visibility the
+ * default dialog gives the field.
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogEvaluationMode(props: Partial<IScheduledEmailDialogEvaluationModeProps>): ReactElement;
+
 /**
  * The scheduled-export dialog's filters region (the filter and parameter chips, flat or per tab),
  * connected to the dialog's state.
@@ -25104,6 +26326,19 @@ export declare type ScheduledEmailDialogHeaderDefaultProps = IScheduledEmailDial
     ref?: Ref<HTMLInputElement>;
 };
 
+/**
+ * The scheduled-export dialog's message field, connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogMessage} with the props of
+ * {@link useScheduledEmailDialogMessageProps}; every prop passed here replaces the hook's value for
+ * that prop wholesale. Renders nothing while `useScheduledEmailDialogContext().isLoading` is true
+ * and for an in-platform notification channel (which has no e-mail message), the same visibility
+ * the default dialog gives the field.
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogMessage(props: Partial<IScheduledEmailDialogMessageProps>): ReactElement;
+
 /**
  * The scheduled-export dialog's recipients region, connected to the dialog's state.
  *
@@ -25118,6 +26353,91 @@ export declare type ScheduledEmailDialogHeaderDefaultProps = IScheduledEmailDial
  */
 export declare function ScheduledEmailDialogRecipients(props: Partial<IScheduledEmailDialogRecipientsProps>): JSX.Element;
 
+/**
+ * The scheduled-export dialog's recurrence field, connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogRecurrence} with the props of
+ * {@link useScheduledEmailDialogRecurrenceProps}; every prop passed here replaces the hook's value
+ * for that prop wholesale. Pass `onKeyDownSubmit` to submit on Enter from the recurrence inputs —
+ * the default dialog passes its save action; without it Enter does nothing here. Renders nothing
+ * while `useScheduledEmailDialogContext().isLoading` is true; otherwise ungated, unlike the other
+ * General-tab fields.
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogRecurrence(props: Partial<IScheduledEmailDialogRecurrenceProps>): ReactElement;
+
+/**
+ * The scheduled-export dialog's chrome, connected to the dialog's state: the modal overlay, the dialog
+ * frame with the header row (the back button and the title input) and the action bar, the General and
+ * Filters tabs, the scrollable content area around the selected tab's content, the body's error and
+ * validation messages, the stale-filters confirmation step shown before the dialog when the saved filters
+ * or schedule timezone no longer match the dashboard, and the delete confirmation reached from the
+ * action bar in edit mode. While `useScheduledEmailDialogContext().isLoading` is true — on scheduled
+ * email the ordinary path while a widget export's filters load — it renders the loading skeleton and
+ * none of its children.
+ *
+ * The default dialog is `<ScheduledEmailDialogShell>` around the region blocks and form; a custom
+ * `ScheduledEmailDialogComponent` that keeps this chrome and arranges the blocks differently renders the
+ * shell itself. The shell does not own the save: call {@link useSaveScheduledEmailToBackend} and pass its
+ * `handleSaveScheduledEmail`, `isSavingScheduledEmail` and `savingErrorMessage`; build Enter handlers for
+ * the blocks you place with {@link useScheduledEmailSubmitOnEnter} over the same `handleSaveScheduledEmail`.
+ * Call that hook only once `useScheduledEmailDialogContext().isLoading` is false — the state hooks throw
+ * while the dialog loads — and render the shell alone (any `onSubmit`, `isSaving: false`) until then, as
+ * the example does.
+ *
+ * Needs an ambient `IntlProvider`; inside a `Dashboard` the dashboard's provider covers it.
+ *
+ * @example
+ * ```tsx
+ * function MyScheduledEmailDialog(props: IScheduledEmailDialogProps) {
+ *     const { isLoading } = useScheduledEmailDialogContext();
+ *     // the state hooks throw while the dialog loads; the shell renders the loading skeleton
+ *     if (isLoading) {
+ *         return <ScheduledEmailDialogShell {...props} onSubmit={() => {}} isSaving={false} />;
+ *     }
+ *     return <MyScheduledEmailDialogBody {...props} />;
+ * }
+ *
+ * function MyScheduledEmailDialogBody(props: IScheduledEmailDialogProps) {
+ *     const { handleSaveScheduledEmail, isSavingScheduledEmail, savingErrorMessage } =
+ *         useSaveScheduledEmailToBackend(props);
+ *     const submitOnEnter = useScheduledEmailSubmitOnEnter({
+ *         onSubmit: handleSaveScheduledEmail,
+ *         isSaving: isSavingScheduledEmail,
+ *     });
+ *     return (
+ *         <ScheduledEmailDialogShell
+ *             {...props}
+ *             onSubmit={handleSaveScheduledEmail}
+ *             isSaving={isSavingScheduledEmail}
+ *             savingErrorMessage={savingErrorMessage}
+ *         >
+ *             <ScheduledEmailDialogDestination />
+ *             <ScheduledEmailDialogRecipients onKeyDownSubmit={submitOnEnter} />
+ *         </ScheduledEmailDialogShell>
+ *     );
+ * }
+ * ```
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogShell(props: IScheduledEmailDialogShellProps): ReactElement;
+
+/**
+ * The scheduled-export dialog's subject field, connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogSubject} with the props of
+ * {@link useScheduledEmailDialogSubjectProps}; every prop passed here replaces the hook's value for
+ * that prop wholesale. Pass `onKeyDownSubmit` to submit on Enter from the subject input — the
+ * default dialog passes its save action; without it Enter does nothing here. Renders nothing while
+ * `useScheduledEmailDialogContext().isLoading` is true and for an in-platform notification channel
+ * (which has no e-mail subject), the same visibility the default dialog gives the field.
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogSubject(props: Partial<IScheduledEmailDialogSubjectProps>): ReactElement;
+
 /**
  * The scheduled-export dialog's "Time zone" section (the export-content timezone picker), connected
  * to the dialog's state.
@@ -25139,6 +26459,20 @@ export declare function ScheduledEmailDialogTimezone(overrides: Partial<Schedule
  */
 export declare type ScheduledEmailDialogTimezoneDefaultProps = IScheduledEmailDialogTimezoneProps;
 
+/**
+ * The scheduled-export dialog's widget-attachments field, connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogWidgetAttachments} with the props of
+ * {@link useScheduledEmailDialogWidgetAttachmentsProps}; every prop passed here replaces the hook's
+ * value for that prop wholesale. Renders nothing while `useScheduledEmailDialogContext().isLoading`
+ * is true and when the dialog context has no `widget` (a dashboard schedule renders
+ * {@link ScheduledEmailDialogDashboardAttachments} instead), the same visibility the default dialog
+ * gives the field.
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogWidgetAttachments(props: Partial<IScheduledEmailDialogWidgetAttachmentsProps>): ReactElement;
+
 /**
  * @internal
  */
@@ -26816,23 +28150,21 @@ export declare const selectExecutionResultLimitBreaksByRef: (ref: ObjRef | undef
 export declare const selectExecutionTimestamp: DashboardSelector<string | undefined>;
 
 /**
- * Returns the per-tab parameter overrides to send on dashboard tabular export, keyed by
- * tab `localIdentifier`. The shape matches the backend's `dashboardTabsParametersOverrides`
+ * Returns the per-tab parameter overrides to send on dashboard export, keyed by tab
+ * `localIdentifier`. The shape matches the backend's `dashboardTabsParametersOverrides`
  * field directly.
  *
  * @remarks
- * Scope rules:
- * - When `widgetIds` is empty/undefined (whole-dashboard export), every tab in scope contributes
- *   parameter entries with a `runtimeOverride`.
- * - When `widgetIds` is non-empty, each widget's owning tab contributes only entries with a
- *   `runtimeOverride` whose ref is referenced by the widget's insight metrics via the dashboard-wide
- *   metric → parameter dependency map. Multi-widget across distinct owning tabs yields one
- *   map entry per owning tab; entries for the same tab are unioned and deduplicated by ref.
+ * The request sends every `runtimeOverride` entry of each tab in scope; the query drops the
+ * parameters a widget's metrics do not use.
+ * - When `widgetIds` is empty/undefined (whole-dashboard export), every tab is in scope.
+ * - When `widgetIds` is non-empty, only the owning tabs of those widgets are in scope. Send only
+ *   these tabs. A non-empty map tells the backend that the map is complete, and the backend then
+ *   does not resolve pinned values for any tab.
  *
  * Returns `{}` (signalling "omit the field on the wire") when:
  * - `enableParameters` is off,
  * - the workspace catalog parameters are not loaded,
- * - (widget scope only) the `measureParameters` dependency map is not loaded,
  * - or no in-scope parameter has a `runtimeOverride`.
  *
  * @alpha
@@ -30376,6 +31708,39 @@ export declare function useAlertFilters(): IAlertFiltersContextValue;
  */
 export declare function useAlertingDialogActionBarProps({ onCancel, onSubmit, isSaving, onDelete }: IUseAlertingDialogActionBarPropsInput): IAutomationDialogActionBarProps;
 
+/**
+ * The exact props the default alerting dialog renders its attribute field with.
+ *
+ * Throws outside the alerting dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useAlertingDialogAttributeProps(): IAlertingDialogAttributeProps;
+
+/**
+ * The exact props the default alerting dialog renders its comparison-operator field with.
+ *
+ * `enableAnomalyDetectionAlert` is the conjunction of the `enableAnomalyDetectionAlert` and
+ * `canUseAiAssistant` features.
+ *
+ * Throws outside the alerting dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useAlertingDialogComparisonOperatorProps(): IAlertingDialogComparisonOperatorProps;
+
+/**
+ * The exact props the default alerting dialog renders its comparison-period field with.
+ *
+ * `onComparisonChange` closes over the selected measure (and relative operator), so it takes only
+ * the field's value.
+ *
+ * Throws outside the alerting dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useAlertingDialogComparisonPeriodProps(): IAlertingDialogComparisonPeriodProps;
+
 /**
  * Reads the alerting create/edit dialog context.
  *
@@ -30408,6 +31773,18 @@ export declare function useAlertingDialogDestinationProps(): IAutomationDialogDe
  */
 export declare function useAlertingDialogFiltersProps(): IAlertingDialogFiltersProps;
 
+/**
+ * The exact props the default alerting dialog renders its granularity field with.
+ *
+ * `onGranularityChange` closes over the selected measure (and relative operator), so it takes only
+ * the field's value.
+ *
+ * Throws outside the alerting dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useAlertingDialogGranularityProps(): IAlertingDialogGranularityProps;
+
 /**
  * The exact props the default alerting dialog renders its header region with.
  *
@@ -30417,6 +31794,15 @@ export declare function useAlertingDialogFiltersProps(): IAlertingDialogFiltersP
  */
 export declare function useAlertingDialogHeaderProps({ onCancel, ref }: IUseAlertingDialogHeaderPropsInput): AlertingDialogHeaderDefaultProps;
 
+/**
+ * The exact props the default alerting dialog renders its measure field with.
+ *
+ * Throws outside the alerting dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useAlertingDialogMeasureProps(): IAlertingDialogMeasureProps;
+
 /**
  * The exact props the default alerting dialog renders its recipients region with.
  *
@@ -30426,6 +31812,46 @@ export declare function useAlertingDialogHeaderProps({ onCancel, ref }: IUseAler
  */
 export declare function useAlertingDialogRecipientsProps(): IAutomationDialogRecipientsProps;
 
+/**
+ * The exact props the default alerting dialog renders its sensitivity field with.
+ *
+ * Throws outside the alerting dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useAlertingDialogSensitivityProps(): IAlertingDialogSensitivityProps;
+
+/**
+ * The exact props the default alerting dialog renders its threshold field with.
+ *
+ * Owns the field's state: its effect auto-computes the threshold of a new alert from the measure's
+ * current value and clears it for a relative operator, writing the draft. **Call it once per
+ * dialog** — through {@link AlertingDialogThreshold}, which is that mount in the default dialog and
+ * in a shell of blocks, or directly, never both. Throws outside the alerting dialog's state
+ * providers.
+ *
+ * @alpha
+ */
+export declare function useAlertingDialogThresholdProps(): IAlertingDialogThresholdProps;
+
+/**
+ * The exact props the default alerting dialog renders its trigger-interval field with.
+ *
+ * Throws outside the alerting dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useAlertingDialogTriggerIntervalProps(): IAlertingDialogTriggerIntervalProps;
+
+/**
+ * The exact props the default alerting dialog renders its trigger-mode field with.
+ *
+ * Throws outside the alerting dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useAlertingDialogTriggerModeProps(): IAlertingDialogTriggerModeProps;
+
 /**
  * Reads the alerting management dialog context.
  *
@@ -31479,6 +32905,15 @@ export declare function useScheduledEmailDialogActionBarProps({ onCancel, onSubm
  */
 export declare function useScheduledEmailDialogContext(): IScheduledEmailDialogContextValue;
 
+/**
+ * The exact props the default scheduled-email dialog renders its dashboard-attachments field with.
+ *
+ * Throws outside the scheduled-export dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useScheduledEmailDialogDashboardAttachmentsProps(): IScheduledEmailDialogDashboardAttachmentsProps;
+
 /**
  * The exact props the default scheduled-email dialog renders its destination region with.
  *
@@ -31488,6 +32923,15 @@ export declare function useScheduledEmailDialogContext(): IScheduledEmailDialogC
  */
 export declare function useScheduledEmailDialogDestinationProps(): IAutomationDialogDestinationProps;
 
+/**
+ * The exact props the default scheduled-email dialog renders its evaluation-mode checkbox with.
+ *
+ * Throws outside the scheduled-export dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useScheduledEmailDialogEvaluationModeProps(): IScheduledEmailDialogEvaluationModeProps;
+
 /**
  * The exact props the default scheduled-email dialog renders its filters region with.
  *
@@ -31506,6 +32950,15 @@ export declare function useScheduledEmailDialogFiltersProps(): IScheduledEmailDi
  */
 export declare function useScheduledEmailDialogHeaderProps({ onBack, onTitleKeyDown, ref }: IUseScheduledEmailDialogHeaderPropsInput): ScheduledEmailDialogHeaderDefaultProps;
 
+/**
+ * The exact props the default scheduled-email dialog renders its message field with.
+ *
+ * Throws outside the scheduled-export dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useScheduledEmailDialogMessageProps(): IScheduledEmailDialogMessageProps;
+
 /**
  * The exact props the default scheduled-email dialog renders its recipients region with.
  *
@@ -31515,6 +32968,24 @@ export declare function useScheduledEmailDialogHeaderProps({ onBack, onTitleKeyD
  */
 export declare function useScheduledEmailDialogRecipientsProps({ onKeyDownSubmit }: IUseScheduledEmailDialogRecipientsPropsInput): IScheduledEmailDialogRecipientsProps;
 
+/**
+ * The exact props the default scheduled-email dialog renders its recurrence field with.
+ *
+ * Throws outside the scheduled-export dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useScheduledEmailDialogRecurrenceProps({ onKeyDownSubmit }: IUseScheduledEmailDialogRecurrencePropsInput): IScheduledEmailDialogRecurrenceProps;
+
+/**
+ * The exact props the default scheduled-email dialog renders its subject field with.
+ *
+ * Throws outside the scheduled-export dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useScheduledEmailDialogSubjectProps({ onKeyDownSubmit }: IUseScheduledEmailDialogSubjectPropsInput): IScheduledEmailDialogSubjectProps;
+
 /**
  * The exact props the default scheduled-email dialog renders its "Time zone" section with.
  *
@@ -31524,6 +32995,15 @@ export declare function useScheduledEmailDialogRecipientsProps({ onKeyDownSubmit
  */
 export declare function useScheduledEmailDialogTimezoneProps(): ScheduledEmailDialogTimezoneDefaultProps;
 
+/**
+ * The exact props the default scheduled-email dialog renders its widget-attachments field with.
+ *
+ * Throws outside the scheduled-export dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useScheduledEmailDialogWidgetAttachmentsProps(): IScheduledEmailDialogWidgetAttachmentsProps;
+
 /**
  * Reads the scheduled-email management dialog context.
  *
@@ -31538,6 +33018,19 @@ export declare function useScheduledEmailDialogTimezoneProps(): ScheduledEmailDi
  */
 export declare function useScheduledEmailManagementDialogContext(): IScheduledEmailManagementDialogContextValue;
 
+/**
+ * The Enter-to-submit key handler the default scheduled-export dialog attaches to its title, recipients
+ * and recurrence inputs: calls `onSubmit` on Enter unless the submit button would be disabled — the same
+ * guard {@link useScheduledEmailDialogActionBarProps} puts on the button (form validity, a save in
+ * flight, execution-timestamp mode). Pass the result as `onTitleKeyDown` / `onKeyDownSubmit` to the
+ * header and recipients blocks so every Enter path shares the dialog's one save.
+ *
+ * Throws outside the scheduled-export dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useScheduledEmailSubmitOnEnter({ onSubmit, isSaving }: IUseScheduledEmailSubmitOnEnterInput): (event: KeyboardEvent_2) => void;
+
 /**
  * Reads the scheduled-export dialog's draft mutators.
  *
@@ -31683,6 +33176,23 @@ export declare function useWidgetFilters(widget: FilterableDashboardWidget | und
  */
 export declare function useWidgetSelection(widgetRef?: ObjRef): IUseWidgetSelectionResult;
 
+/**
+ * Debounced workspace-user search for a recipients control.
+ *
+ * Queries the first 50 matching workspace users, 300 ms debounced, lazily: no request is made
+ * until {@link IUseWorkspaceUsersSearchResult.onActivate} is called. Requires only the ambient
+ * `BackendProvider` and `WorkspaceProvider` from `@gooddata/sdk-ui` — it reads no automation
+ * context, so a custom recipients control can call it anywhere inside a `Dashboard` (or any
+ * backend/workspace scope). The default recipients select of both automation dialogs is built
+ * on it. Pass `enabled: false` to keep it inert (the default select does so when an external
+ * recipient override or a logged-user-only constraint removes server search).
+ *
+ * @alpha
+ */
+export declare function useWorkspaceUsersSearch({ enabled }: {
+    enabled: boolean;
+}): IUseWorkspaceUsersSearchResult;
+
 /**
  * @internal
  */