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

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

@@ -13,6 +13,8 @@ import { Action } from '@reduxjs/toolkit';
 import { ActionCreatorWithOptionalPayload } from '@reduxjs/toolkit';
 import { ActionCreatorWithoutPayload } from '@reduxjs/toolkit';
 import { ActionCreatorWithPayload } from '@reduxjs/toolkit';
+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';
@@ -20,6 +22,7 @@ import { ComponentPropsWithRef } from 'react';
 import { ComponentType } from 'react';
 import { Context } from 'react';
 import { CurrentUserPermissions } from '@gooddata/sdk-ui-kit';
+import { DashboardAttachmentType } from '@gooddata/sdk-model';
 import { DashboardAttributeFilterConfigMode } from '@gooddata/sdk-model';
 import { DashboardAttributeFilterItem } from '@gooddata/sdk-model';
 import { DashboardAttributeFilterSelectionMode } from '@gooddata/sdk-model';
@@ -43,14 +46,23 @@ 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';
 import { IAccessControlAware } from '@gooddata/sdk-model';
 import { IAccessGrantee } from '@gooddata/sdk-model';
 import { IActiveCalendars } from '@gooddata/sdk-model';
+import { IAlertAnomalyDetectionGranularity } from '@gooddata/sdk-model';
+import { IAlertAnomalyDetectionSensitivity } from '@gooddata/sdk-model';
+import { IAlertComparisonOperator } from '@gooddata/sdk-model';
+import { IAlertRelativeArithmeticOperator } from '@gooddata/sdk-model';
+import { IAlertRelativeOperator } from '@gooddata/sdk-model';
+import { IAlertTriggerInterval } from '@gooddata/sdk-model';
 import { IAlertTriggerMode } from '@gooddata/sdk-model';
 import { IAnalyticalBackend } from '@gooddata/sdk-backend-spi';
 import { IArbitraryAttributeFilter } from '@gooddata/sdk-model';
+import { IAttribute } from '@gooddata/sdk-model';
 import { IAttributeDescriptorBody } from '@gooddata/sdk-model';
 import { IAttributeDisplayFormMetadataObject } from '@gooddata/sdk-model';
 import { IAttributeElement } from '@gooddata/sdk-model';
@@ -106,6 +118,7 @@ import { IDashboardPermissions } from '@gooddata/sdk-model';
 import { IDashboardReferences } from '@gooddata/sdk-backend-spi';
 import { IDashboardTimezoneConfig } from '@gooddata/sdk-model';
 import { IDashboardWidget } from '@gooddata/sdk-model';
+import { IDataSetMetadataObject } from '@gooddata/sdk-model';
 import { IDataView } from '@gooddata/sdk-backend-spi';
 import { IDateFilter } from '@gooddata/sdk-model';
 import { IDateFilterButtonProps } from '@gooddata/sdk-ui-filters';
@@ -131,6 +144,7 @@ import { IExecutionConfiguration } from '@gooddata/sdk-ui';
 import { IExecutionDefinition } from '@gooddata/sdk-model';
 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 { IFilter } from '@gooddata/sdk-model';
@@ -188,6 +202,7 @@ import { ITableDataAttributeScope } from '@gooddata/sdk-ui';
 import { ITempFilterContext } from '@gooddata/sdk-model';
 import { ITheme } from '@gooddata/sdk-model';
 import type { ITranslations } from '@gooddata/sdk-ui';
+import { IUnavailableDashboardReference } from '@gooddata/sdk-backend-spi';
 import { IUpperBoundedFilter } from '@gooddata/sdk-model';
 import { IUser } from '@gooddata/sdk-model';
 import { IUserWorkspaceSettings } from '@gooddata/sdk-backend-spi';
@@ -224,6 +239,7 @@ import { ReactNode } from 'react';
 import { ReactReduxContextValue } from 'react-redux';
 import { Reducer } from '@reduxjs/toolkit';
 import { Ref } from 'react';
+import { RefAttributes } from 'react';
 import { RefObject } from 'react';
 import { SagaIterator } from 'redux-saga';
 import { ScreenSize } from '@gooddata/sdk-model';
@@ -239,6 +255,7 @@ import { UseCancelablePromiseState } from '@gooddata/sdk-ui';
 import { VisualizationProperties } from '@gooddata/sdk-model';
 import { weakMapMemoize } from '@reduxjs/toolkit';
 import { WeekStart } from '@gooddata/sdk-model';
+import { WidgetAttachmentType } from '@gooddata/sdk-model';
 import { WritableDraft } from 'immer';
 
 /**
@@ -512,6 +529,29 @@ 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 condition (`"AI.ANOMALY_DETECTION"`).
+ *
+ * @alpha
+ */
+export declare type AlertAiOperator = `${typeof AI_OPERATOR}.${typeof AI_OPERATORS.ANOMALY_DETECTION}`;
+
+/**
+ * An attribute of the insight the alert can be sliced by (the "for" row of the condition).
+ *
+ * @alpha
+ */
+export declare type AlertAttribute = {
+    /**
+     * The insight attribute.
+     */
+    attribute: IAttribute;
+    /**
+     * Whether the attribute is a date attribute.
+     */
+    type: "dateAttribute" | "attribute";
+};
+
 /**
  * Resolves the dialog component from DashboardComponentsContext and mounts it under the
  * alerting dialog's state contexts, inside the resolved context decorator — so a decorated
@@ -521,6 +561,76 @@ export declare function addVisualizationToSwitcherWidgetContent(ref: ObjRef, vis
  */
 export declare function AlertingDialog(props: IAlertingDialogProps): ReactElement;
 
+/**
+ * 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): 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.
  *
@@ -532,6 +642,73 @@ export declare function AlertingDialog(props: IAlertingDialogProps): ReactElemen
  */
 export declare const AlertingDialogContextProvider: Provider<IAlertingDialogContextValue | undefined>;
 
+/**
+ * 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>): JSX.Element;
+
+/**
+ * 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>): JSX.Element;
+
+/**
+ * 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.
+ *
+ * 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: ForwardRefExoticComponent<Partial<IAlertingDialogHeaderProps> & RefAttributes<HTMLInputElement>>;
+
 /**
  * The exact props the default dialog renders its header with, including the dialog's
  * initial-focus ref.
@@ -542,6 +719,104 @@ 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.
+ *
+ * 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>): 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 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
  */
@@ -552,6 +827,66 @@ export declare type AlertingDisabledReason = "noDestinations" | "oldWidget" | "d
  */
 export declare function AlertingManagementDialog(props: IAlertingManagementDialogProps): ReactElement;
 
+/**
+ * A measure of the insight the alerting dialog can build a condition on, with the comparisons
+ * available for it.
+ *
+ * @alpha
+ */
+export declare type AlertMetric = {
+    /**
+     * The insight measure.
+     */
+    measure: IMeasure;
+    /**
+     * Whether the measure is a primary (non-derived) measure of the insight.
+     */
+    isPrimary: boolean;
+    /**
+     * The period-over-period comparisons the dialog offers for this measure; empty when none apply.
+     */
+    comparators: AlertMetricComparator[];
+};
+
+/**
+ * A comparison the alerting dialog can offer for a measure: the derived period-over-period measure
+ * and the date dataset and granularity it is computed over.
+ *
+ * @alpha
+ */
+export declare type AlertMetricComparator = {
+    /**
+     * The derived measure (previous period / same period previous year) the condition compares against.
+     */
+    measure: IMeasure;
+    /**
+     * Whether the derived measure is itself a primary measure of the insight.
+     */
+    isPrimary: boolean;
+    /**
+     * Which period the derived measure shifts by.
+     */
+    comparator: AlertMetricComparatorType;
+    /**
+     * The date dataset the period shift is computed over, when the insight resolves one.
+     */
+    dataset?: IDataSetMetadataObject;
+    /**
+     * The granularity of the period shift, when the insight resolves one.
+     */
+    granularity?: DateAttributeGranularity;
+};
+
+/**
+ * The period a relative alert condition compares the measure against.
+ *
+ * @alpha
+ */
+export declare enum AlertMetricComparatorType {
+    PreviousPeriod = 0,
+    SamePeriodPreviousYear = 1
+}
+
 /**
  * This defines all possible reducers for the cache slice.
  *
@@ -724,6 +1059,38 @@ export declare function attributeHierarchyModified(correlationId?: string): IAtt
  */
 export declare function AttributesDropdown({ id, className, bodyClassName, onClose, onOpen, onSelect, attributes, dateDatasets, measures, openOnInit, DropdownButtonComponent, DropdownTitleComponent, renderNoData, overlayPositionType, getCustomItemTitle, accessibilityConfig, returnFocusTo, parameters, onParameterSelect }: IAttributesDropdownProps): JSX.Element;
 
+/**
+ * One distinct value of an attribute in the widget's execution result, as offered by the alert's
+ * attribute-value picker.
+ *
+ * @alpha
+ */
+export declare type AttributeValue = {
+    /**
+     * Display title: the formatted element name when the result has one, the raw name otherwise.
+     */
+    title: string;
+    /**
+     * The element URI; this is what the alert stores.
+     */
+    value: string;
+    /**
+     * The raw element name.
+     */
+    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
  */
@@ -3442,6 +3809,8 @@ export declare type DashboardState = {
     accessibleDashboards: IAccessibleDashboardsState;
     /** @alpha */
     inaccessibleDashboards: EntityState<IInaccessibleDashboard, EntityId>;
+    /** @alpha */
+    unavailableObjects: EntityState<IUnavailableDashboardReference, EntityId>;
     dashboardPermissions: DashboardPermissionsState;
     /** @alpha */
     automations: IAutomationsState;
@@ -3966,6 +4335,21 @@ 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), and from the
+ * connected field blocks — {@link AlertingDialogMeasure}, {@link AlertingDialogAttribute},
+ * {@link AlertingDialogComparisonOperator}, {@link AlertingDialogThreshold},
+ * {@link AlertingDialogComparisonPeriod}, {@link AlertingDialogSensitivity},
+ * {@link AlertingDialogGranularity}, {@link AlertingDialogTriggerMode},
+ * {@link AlertingDialogTriggerInterval} — each a labelled {@link AutomationDialogFormField} row; the
+ * conditional ones (Attribute, Threshold, ComparisonPeriod, Sensitivity, Granularity, TriggerInterval)
+ * gate themselves on the draft. A custom `AlertingDialogComponent` that keeps our regions and fields
+ * but owns the markup places the connected blocks ({@link AlertingDialogFilters},
+ * {@link AlertingDialogThreshold} and siblings) instead of this component, 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.
  *
@@ -3973,6 +4357,142 @@ export declare const DEFAULT_TAB_ID = "defaultTabId";
  */
 export declare function DefaultAlertingDialog(props: IDefaultAlertingDialogProps): JSX.Element;
 
+/**
+ * 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
+ * notification channel. Props-driven — reads no context. The default dialog and
+ * {@link AlertingDialogDestination} render it with {@link useAlertingDialogDestinationProps}; a
+ * `slots.Destination` slot receives it as `Default`.
+ *
+ * @alpha
+ */
+export declare function DefaultAlertingDialogDestination({ notificationChannels, selectedNotificationChannelId, onChange }: IAutomationDialogDestinationProps): JSX.Element;
+
+/**
+ * Default render of the alerting dialog's filters region: the filter and parameter chips above the
+ * form. Props-driven — reads no context. The default dialog and {@link AlertingDialogFilters} render
+ * it with {@link useAlertingDialogFiltersProps}; a `slots.Filters` slot receives it as `Default`.
+ * Alert automations always store their filters and never target the whole dashboard, so the
+ * store-filters contract is fixed here instead of being carried on the region props.
+ *
+ * @alpha
+ */
+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
+ * {@link AlertingDialogHeader} render it with {@link useAlertingDialogHeaderProps}; a `slots.Header`
+ * slot receives it as `Default`.
+ *
+ * @alpha
+ */
+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.
+ * The default dialog and {@link AlertingDialogRecipients} render it with
+ * {@link useAlertingDialogRecipientsProps}; a `slots.Recipients` slot receives it as `Default`.
+ *
+ * @alpha
+ */
+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
@@ -3983,6 +4503,17 @@ export declare function DefaultAlertingDialog(props: IDefaultAlertingDialogProps
  */
 export declare function DefaultAlertingManagementDialogNew(props: IAlertingManagementDialogProps): JSX.Element;
 
+/**
+ * Default render of both automation dialogs' action bar: the documentation link and Delete on the
+ * left, Cancel and the submit button on the right. Props-driven — reads no context; every value it
+ * renders arrives through {@link IAutomationDialogActionBarProps}. The default dialogs,
+ * {@link AlertingDialogActionBar} and {@link ScheduledEmailDialogActionBar} render it with the
+ * tree's action-bar props hook; a `slots.ActionBar` slot receives it as `Default`.
+ *
+ * @alpha
+ */
+export declare function DefaultAutomationDialogActionBar({ cancelButtonText, submitButtonText, onCancel, onSubmit, isSubmitDisabled, isSaving, submitButtonTooltipText, helpLinkText, helpLinkHref, onDelete, deleteButtonText }: IAutomationDialogActionBarProps): JSX.Element;
+
 /**
  * @alpha
  */
@@ -4226,6 +4757,15 @@ 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}.
+ *
  * 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
  * renders only while the Filters tab is selected — see {@link IScheduledEmailDialogSlots.Filters}.
@@ -4235,19 +4775,76 @@ export declare function DefaultSaveButton({ isVisible, isEnabled, isSaving, butt
 export declare function DefaultScheduledEmailDialog(props: IDefaultScheduledEmailDialogProps): JSX.Element;
 
 /**
+ * Default render of the scheduled-export dialog's destination region: the notification-channel
+ * select. Props-driven — reads no context. The default dialog and
+ * {@link ScheduledEmailDialogDestination} render it with
+ * {@link useScheduledEmailDialogDestinationProps}; a `slots.Destination` slot receives it as `Default`.
+ *
  * @alpha
  */
-export declare function DefaultScheduledEmailManagementDialog({ onAdd, onEdit, onClose }: IScheduledEmailManagementDialogProps): JSX.Element;
+export declare function DefaultScheduledEmailDialogDestination({ notificationChannels, selectedNotificationChannelId, onChange }: IAutomationDialogDestinationProps): JSX.Element;
 
 /**
- * @internal
+ * 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
+ * because the tab itself provides both. Props-driven — reads no context. The default dialog and
+ * {@link ScheduledEmailDialogFilters} render it with {@link useScheduledEmailDialogFiltersProps}; a
+ * `slots.Filters` slot receives it as `Default`.
+ *
+ * @alpha
  */
-export declare function DefaultSettingButton({ isVisible, isEnabled, isSaving, buttonTitle, buttonValue, onSettingClick }: ISettingButtonProps): JSX.Element | null;
+export declare function DefaultScheduledEmailDialogFilters(props: IScheduledEmailDialogFiltersProps): JSX.Element;
 
 /**
+ * Default render of the scheduled-export dialog's header region: the back button and the title input
+ * with its length validation. Props-driven — reads no scheduled-email dialog state. The default dialog and
+ * {@link ScheduledEmailDialogHeader} render it with {@link useScheduledEmailDialogHeaderProps}; a
+ * `slots.Header` slot receives it as `Default`.
+ *
  * @alpha
  */
-export declare function DefaultShareButton({ isVisible, isEnabled, onShareButtonClick }: IShareButtonProps): ReactElement | null;
+export declare const DefaultScheduledEmailDialogHeader: ForwardRefExoticComponent<IScheduledEmailDialogHeaderProps & RefAttributes<HTMLInputElement>>;
+
+/**
+ * Default render of the scheduled-export dialog's recipients region: the recipients select.
+ * Props-driven — reads no context. The default dialog and {@link ScheduledEmailDialogRecipients}
+ * render it with {@link useScheduledEmailDialogRecipientsProps}; a `slots.Recipients` slot receives
+ * it as `Default`.
+ *
+ * @alpha
+ */
+export declare function DefaultScheduledEmailDialogRecipients(props: IScheduledEmailDialogRecipientsProps): JSX.Element;
+
+/**
+ * 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
+ * schedule runs without a browser. Dashboard schedules offer a Default option (the backend
+ * derives the persisted dashboard/settings timezone at run time); widget schedules always show
+ * a concrete timezone.
+ *
+ * Default render of that section; its props are the slot contract
+ * ({@link IScheduledEmailDialogTimezoneProps}). Props-driven — reads no scheduled-email dialog state. The default dialog
+ * and {@link ScheduledEmailDialogTimezone} render it with {@link useScheduledEmailDialogTimezoneProps};
+ * a `slots.Timezone` slot receives it as `Default`.
+ *
+ * @alpha
+ */
+export declare function DefaultScheduledEmailDialogTimezone({ isWidget, selection, defaultResolvedTimezone, onTimezoneChange }: IScheduledEmailDialogTimezoneProps): JSX.Element;
+
+/**
+ * @alpha
+ */
+export declare function DefaultScheduledEmailManagementDialog({ onAdd, onEdit, onClose }: IScheduledEmailManagementDialogProps): JSX.Element;
+
+/**
+ * @internal
+ */
+export declare function DefaultSettingButton({ isVisible, isEnabled, isSaving, buttonTitle, buttonValue, onSettingClick }: ISettingButtonProps): JSX.Element | null;
+
+/**
+ * @alpha
+ */
+export declare function DefaultShareButton({ isVisible, isEnabled, onShareButtonClick }: IShareButtonProps): ReactElement | null;
 
 /**
  * @alpha
@@ -5812,6 +6409,117 @@ export declare interface IAddVisualizationToVisualizationSwitcherWidgetContentPa
     readonly sizeInfo: IVisualizationSizeInfo;
 }
 
+/**
+ * The alerting dialog's mutators: the draft setter and every form change-handler.
+ *
+ * Changes rarely: `onGranularityChange` is re-created when `triggerIntervalDirty` toggles or the
+ * supported measures load.
+ *
+ * @alpha
+ */
+export declare interface IAlertActionsContextValue {
+    /**
+     * Replaces the draft; the change-handlers below are the preferred, field-scoped writes.
+     */
+    setEditedAutomation: Dispatch_2<SetStateAction<IAutomationMetadataObjectDefinition | undefined>>;
+    /**
+     * Sets the alert title and re-validates its length.
+     */
+    onTitleChange: (value: string) => void;
+    /**
+     * Selects the measure the condition targets; resets the comparison to the measure's defaults.
+     */
+    onMeasureChange: (measure: AlertMetric) => void;
+    /**
+     * Slices the condition by an attribute value; `undefined` clears the slice.
+     */
+    onAttributeChange: (attribute: AlertAttribute | undefined, value: AttributeValue | undefined) => void;
+    /**
+     * Switches the condition to a comparison against a fixed threshold.
+     */
+    onComparisonOperatorChange: (measure: AlertMetric, comparisonOperator: IAlertComparisonOperator) => void;
+    /**
+     * Switches the condition to a relative (change / difference) comparison with the given operators.
+     */
+    onRelativeOperatorChange: (measure: AlertMetric, relativeOperator: IAlertRelativeOperator, arithmeticOperator: IAlertRelativeArithmeticOperator) => void;
+    /**
+     * Switches the condition to anomaly detection on the measure.
+     */
+    onAnomalyDetectionChange: (measure: AlertMetric) => void;
+    /**
+     * Sets the period a relative condition compares against (and its granularity when given).
+     */
+    onComparisonTypeChange: (measure: AlertMetric | undefined, relativeOperator: [IAlertRelativeOperator, IAlertRelativeArithmeticOperator] | undefined, comparisonType: AlertMetricComparatorType, granularity?: DateAttributeGranularity) => void;
+    /**
+     * Sets the anomaly-detection sensitivity.
+     */
+    onSensitivityChange: (sensitivity: IAlertAnomalyDetectionSensitivity) => void;
+    /**
+     * Sets the trigger interval. `dirty` defaults to true; the granularity handler passes false when it
+     * derives the interval.
+     */
+    onTriggerIntervalChange: (triggerInterval: IAlertTriggerInterval, dirty?: boolean) => void;
+    /**
+     * Sets the anomaly-detection granularity; derives the trigger interval unless the user edited it.
+     */
+    onGranularityChange: (measure: AlertMetric | undefined, granularity: IAlertAnomalyDetectionGranularity) => void;
+    /**
+     * Selects the notification channel; recipients incompatible with it are dropped.
+     */
+    onDestinationChange: (destinationId: string) => void;
+    /**
+     * Sets when the alert fires: every evaluation or once per interval.
+     */
+    onTriggerModeChange: (triggerMode: IAlertTriggerMode) => void;
+    /**
+     * Replaces the recipients with the complete updated array.
+     */
+    onRecipientsChange: (recipients: IAutomationRecipient[]) => void;
+}
+
+/**
+ * The data the alerting dialog loads asynchronously: the supported measures and attributes with
+ * their formats, the execution-result readers, and the current user's default recipients.
+ *
+ * Changes when an async load resolves, not per keystroke.
+ *
+ * @alpha
+ */
+export declare interface IAlertDataContextValue {
+    /**
+     * Measures of the insight an alert can be built on, with their comparisons.
+     */
+    supportedMeasures: AlertMetric[];
+    /**
+     * Attributes of the insight an alert can be sliced by.
+     */
+    supportedAttributes: AlertAttribute[];
+    /**
+     * Number formats of the insight's measures, by local identifier.
+     */
+    measureFormatMap: IMeasureFormatMap;
+    /**
+     * Whether the widget's execution result is still loading.
+     */
+    isResultLoading: boolean;
+    /**
+     * Distinct values of an attribute in the widget's execution result.
+     */
+    getAttributeValues: (attribute: IAttributeMetadataObject) => AttributeValue[];
+    /**
+     * The measure's current value, optionally sliced by an attribute value; undefined while loading.
+     */
+    getMetricValue: (measure?: IMeasure, attribute?: IAttribute, value?: string | null) => number | undefined;
+    /**
+     * The logged-in user as a recipient.
+     */
+    defaultUser: IAutomationRecipient;
+    /**
+     * The recipient a new alert is seeded with; an external-recipient override replaces the user.
+     */
+    defaultRecipient: IAutomationRecipient;
+}
+
 /**
  * @internal
  */
@@ -5827,184 +6535,557 @@ export declare interface IAlertDialogContext {
 }
 
 /**
- * Sub-context for the alerting create/edit dialog.
- *
- * The connector hydrates this from dashboard state and provides the CRUD callbacks; the dialog and its
- * hooks read it instead of reaching into the dashboard store. That direction is enforced by the
- * `no-model-imports-in-clean-alerting` rule in `.dependency-cruiser.js`.
+ * The alerting dialog's validity.
  *
  * @alpha
  */
-export declare interface IAlertingDialogContextValue {
-    mode: "create" | "edit";
-    widget?: IWidget;
-    insight?: IInsight;
-    widgetTitle?: string;
-    dashboardId?: string;
-    dashboardFilters: FilterContextItem[];
-    hiddenFilters: FilterContextItem[];
-    executionResultByRef: (ref: ObjRef | undefined) => {
-        executionResult?: IExecutionResult;
-    } | undefined;
-    /** Effective widget parameter values for the dialog's widget (replaces direct selectEffectiveParameterValuesForWidget read) */
-    parameterValues: IInsightParameterValue[];
+export declare interface IAlertDialogValidity {
     /**
-     * Effective dashboard parameters for the dialog's widget — the owning tab's parameters with any
-     * runtime override folded in (replaces the direct selectEffectiveDashboardParametersForWidget
-     * read in useAutomationAlertParameters).
+     * Whether submit is disabled: the draft is invalid, incomplete, or unchanged in edit mode.
      */
-    dashboardParameters: IDashboardParameter[];
-    commonDateFilterId?: string;
-    dashboardEvaluationFrequency?: string;
-    createAlert(alert: IAutomationMetadataObjectDefinition): Promise<IAutomationMetadataObject>;
-    saveAlert(alert: IAutomationMetadataObject): Promise<IAutomationMetadataObject>;
-    deleteAlert(alert: IAutomationMetadataObject): Promise<void>;
-    /** The alert being edited; undefined when creating a new one. */
-    alertToEdit?: IAutomationMetadataObject;
-    /** Notification channels available as alert destinations. */
-    notificationChannels: INotificationChannelIdentifier[] | INotificationChannelMetadataObject[];
-    /** True while the dialog's initial data (automations) is still loading. */
-    isLoading: boolean;
+    isSubmitDisabled: boolean;
+    /**
+     * The validation message to show; undefined when there is none.
+     */
+    validationErrorMessage: string | undefined;
+    /**
+     * Whether the widget the alert is attached to still exists and supports the alert's measure.
+     */
+    isParentValid: boolean;
+    /**
+     * Whether the measure may be changed — false when the dialog has no insight.
+     */
+    canChangeMeasure: boolean;
+    /**
+     * Whether the saved alert points at a widget whose insight is gone.
+     */
+    isInvalidConnectionToInsight: boolean;
 }
 
 /**
- * Props of the default alerting dialog's filters region (the filter and parameter chips above
- * the form).
+ * The alerting dialog's edit draft: the automation being edited, the baseline it is compared
+ * against, and the form-level warning and title-validity flag that move with it.
+ *
+ * Changes on every keystroke; consumers re-render by design.
  *
  * @alpha
  */
-export declare interface IAlertingDialogFiltersProps extends IAutomationDialogFiltersProps {
+export declare interface IAlertDraftContextValue {
     /**
-     * Disables the date filter chips. The default dialog disables them while the alert uses
-     * anomaly detection.
+     * The alert being edited. Undefined only before the state model has seeded it.
      */
-    disableDateFilters: boolean;
+    editedAutomation: IAutomationMetadataObjectDefinition | undefined;
+    /**
+     * The draft as it was when the dialog opened; the dirty check compares against it.
+     */
+    originalAutomation: IAutomationMetadataObjectDefinition | undefined;
+    /**
+     * Form-level warning shown below the form, e.g. after switching to a creator-only channel.
+     */
+    warningMessage: string | undefined;
+    /**
+     * Whether the current title passes the length limit.
+     */
+    isTitleValid: boolean;
 }
 
 /**
- * Props of the default alerting dialog's header region (the title input row).
+ * The alerting dialog's filter and export-parameter model: the current selection, the available
+ * filters, the two filter mutators and the staleness flags, plus the automation's execution
+ * parameters and their mutators.
+ *
+ * Changes when a filter or a parameter is edited.
  *
  * @alpha
  */
-export declare interface IAlertingDialogHeaderProps extends IAutomationDialogHeaderProps {
+export declare interface IAlertFiltersContextValue {
     /**
-     * Called when the header's back/close button is pressed. The default dialog closes on it.
+     * The filters the alert is saved with.
      */
-    onCancel?: () => void;
+    selectedFilters: FilterContextItem[];
+    /**
+     * The dashboard filters the alert may use; undefined until resolved.
+     */
+    availableFilters: FilterContextItem[] | undefined;
+    /**
+     * Replaces the selection with the complete updated array and mirrors it into the draft.
+     */
+    onFiltersChange: (filters: FilterContextItem[]) => void;
+    /**
+     * Replaces the selection with the dashboard's current filters (the stale-filters repair).
+     */
+    onApplyCurrentFilters: () => void;
+    /**
+     * False when the saved filters or the saved parameters no longer match the dashboard; gates the
+     * stale-filters confirmation.
+     */
+    automationIsValid: boolean;
+    /**
+     * Whether the saved filters alone no longer match the dashboard.
+     */
+    filtersAreStale: boolean;
+    /**
+     * The parameter chips to render. Empty when the `enableParameters` feature is off.
+     */
+    automationParameters: IAutomationParameter[];
+    /**
+     * Workspace parameters addable via the "+" menu. Empty when the feature is off.
+     */
+    availableParameters: IAutomationParameter[];
+    /**
+     * Sets a parameter's value.
+     */
+    onParameterChange: (ref: IdentifierRef, value: ParameterValue) => void;
+    /**
+     * Removes a parameter override.
+     */
+    onParameterDelete: (ref: IdentifierRef) => void;
+    /**
+     * Adds a workspace parameter with its default value.
+     */
+    onParameterAdd: (ref: IdentifierRef) => void;
+    /**
+     * Drops stored parameters whose `ref` left the workspace catalog, keeping every other override.
+     */
+    dropStaleParameters: () => void;
 }
 
 /**
+ * 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 declare interface IAlertingDialogProps {
+export declare type IAlertingDialogActionBarBlockProps = IUseAlertingDialogActionBarPropsInput & Partial<IAutomationDialogActionBarProps>;
+
+/**
+ * Props of the default alerting dialog's attribute field (the "For" row).
+ *
+ * @alpha
+ */
+export declare interface IAlertingDialogAttributeProps {
     /**
-     * In case, we are not creating new alert, but editing existing one, this is the active alert to be edited.
-     *
-     * @deprecated has no effect since 11.51 — the dialog reads `alertToEdit` from
-     *     `useAlertingDialogContext()`. To adjust what it reads, use the
-     *     `AlertingDialogContextDecoratorComponent` dashboard prop. Prop will be removed.
+     * Id of the dropdown button; the form row's label points at it.
      */
-    alertToEdit?: IAutomationMetadataObject;
+    id: string;
     /**
-     * Notification channels in organization
-     *
-     * @deprecated has no effect since 11.51 — the dialog reads `notificationChannels` from
-     *     `useAlertingDialogContext()`. To adjust what it reads, use the
-     *     `AlertingDialogContextDecoratorComponent` dashboard prop. Prop will be removed.
+     * Disables the select. The default dialog disables it when the dialog has no insight to pick measures from.
      */
-    notificationChannels?: INotificationChannelIdentifier[] | INotificationChannelMetadataObject[];
+    disabled?: boolean;
     /**
-     * Widget to be used for alert.
-     *
-     * Note: this is available only when alerting for widget, not dashboard.
-     * Typed as IWidget (not ExtendedDashboardWidget) because the dialog only
-     * supports insight widgets; custom widgets and nested layouts are not valid
-     * alert targets and were silently discarded at the connector boundary anyway.
-     *
-     * @deprecated has no effect since 11.51 — the dialog reads `widget` from
-     *     `useAlertingDialogContext()`. To adjust what it reads, use the
-     *     `AlertingDialogContextDecoratorComponent` dashboard prop. Prop will be removed.
+     * The attribute the condition is sliced by; undefined for the whole measure.
      */
-    widget?: IWidget;
+    selectedAttribute: AlertAttribute | undefined;
     /**
-     * Insight to be used for alert.
-     *
-     * Note: this is available only when alerting for widget, not dashboard.
-     *
-     * @deprecated has no effect since 11.51 — the dialog reads `insight` from
-     *     `useAlertingDialogContext()`. To adjust what it reads, use the
-     *     `AlertingDialogContextDecoratorComponent` dashboard prop (e.g. so an alert follows a
-     *     widget's date-granularity selection). Prop will be removed.
+     * The attribute element the condition is sliced to; null for the empty value, undefined for all values.
      */
-    insight?: IInsight;
+    selectedValue: string | null | undefined;
     /**
-     * Is alert dialog loading initial data, before it can be rendered?
-     *
-     * @deprecated has no effect since 11.51 — the dialog reads `isLoading` from
-     *     `useAlertingDialogContext()`. Prop will be removed.
+     * Called with the picked attribute and value; `(undefined, undefined)` clears the slice.
      */
-    isLoading?: boolean;
+    onAttributeChange: (attribute: AlertAttribute | undefined, value: AttributeValue | undefined) => void;
     /**
-     * Callback to be called, when user closes the alert dialog.
+     * The insight's attributes; the select offers the non-date ones and renders nothing when there is none.
      */
-    onCancel?: () => void;
+    attributes: AlertAttribute[];
     /**
-     * Callback to be called, when error occurs.
+     * The workspace catalog's attributes, to resolve titles and display forms.
      */
-    onError?: (error: GoodDataSdkError) => void;
+    catalogAttributes: ICatalogAttribute[];
     /**
-     * Callback to be called, when alerting finishes successfully.
+     * The workspace catalog's date datasets, to resolve date attributes.
      */
-    onSuccess?: (alertDefinition: IAutomationMetadataObject) => void;
+    catalogDateDatasets: ICatalogDateDataset[];
     /**
-     * Callback to be called, when error occurs.
+     * Distinct values of an attribute in the widget's execution result.
      */
-    onSaveError?: (error: GoodDataSdkError) => void;
+    getAttributeValues: (attribute: IAttributeMetadataObject) => AttributeValue[];
     /**
-     * Callback to be called, when alerting finishes successfully.
+     * Disables the select while the execution result is loading.
      */
-    onSaveSuccess?: (alert: IAutomationMetadataObject) => void;
+    isResultLoading?: boolean;
     /**
-     * Callback to be called, when alert is deleted.
+     * Renders the select's own "For" label above the control. The default dialog passes false — the
+     * form row carries the label.
      */
-    onDeleteSuccess?: (alert: IAutomationMetadataObject) => void;
+    showLabel?: boolean;
     /**
-     * Callback to be called, when alert fails to delete.
+     * Closes the dropdown when an ancestor scrolls; the default dialog sets it.
      */
-    onDeleteError?: (error: GoodDataSdkError) => void;
+    closeOnParentScroll?: boolean;
 }
 
 /**
- * Section-level overrides of the default alerting dialog.
+ * Props of the default alerting dialog's comparison-operator field (the "Condition" row).
  *
  * @alpha
  */
-export declare interface IAlertingDialogSlots {
+export declare interface IAlertingDialogComparisonOperatorProps {
     /**
-     * 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.
+     * The measure the condition targets; the select renders nothing without one.
      */
-    Filters?: ComponentType<ISlotProps<IAlertingDialogFiltersProps>>;
+    measure: AlertMetric | undefined;
     /**
-     * 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.
+     * 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.
+ *
+ * The connector hydrates this from dashboard state and provides the CRUD callbacks; the dialog and its
+ * hooks read it instead of reaching into the dashboard store. That direction is enforced by the
+ * `no-model-imports-in-clean-alerting` rule in `.dependency-cruiser.js`.
+ *
+ * @alpha
+ */
+export declare interface IAlertingDialogContextValue {
+    mode: "create" | "edit";
+    widget?: IWidget;
+    insight?: IInsight;
+    widgetTitle?: string;
+    dashboardId?: string;
+    dashboardFilters: FilterContextItem[];
+    hiddenFilters: FilterContextItem[];
+    executionResultByRef: (ref: ObjRef | undefined) => {
+        executionResult?: IExecutionResult;
+    } | undefined;
+    /** Effective widget parameter values for the dialog's widget (replaces direct selectEffectiveParameterValuesForWidget read) */
+    parameterValues: IInsightParameterValue[];
+    /**
+     * Effective dashboard parameters for the dialog's widget — the owning tab's parameters with any
+     * runtime override folded in (replaces the direct selectEffectiveDashboardParametersForWidget
+     * read in useAutomationAlertParameters).
+     */
+    dashboardParameters: IDashboardParameter[];
+    commonDateFilterId?: string;
+    dashboardEvaluationFrequency?: string;
+    createAlert(alert: IAutomationMetadataObjectDefinition): Promise<IAutomationMetadataObject>;
+    saveAlert(alert: IAutomationMetadataObject): Promise<IAutomationMetadataObject>;
+    deleteAlert(alert: IAutomationMetadataObject): Promise<void>;
+    /** The alert being edited; undefined when creating a new one. */
+    alertToEdit?: IAutomationMetadataObject;
+    /** Notification channels available as alert destinations. */
+    notificationChannels: INotificationChannelIdentifier[] | INotificationChannelMetadataObject[];
+    /** True while the dialog's initial data (automations) is still loading. */
+    isLoading: boolean;
+}
+
+/**
+ * Props of the default alerting dialog's filters region (the filter and parameter chips above
+ * the form).
+ *
+ * @alpha
+ */
+export declare interface IAlertingDialogFiltersProps extends IAutomationDialogFiltersProps {
+    /**
+     * Disables the date filter chips. The default dialog disables them while the alert uses
+     * anomaly detection.
+     */
+    disableDateFilters: boolean;
+}
+
+/**
+ * 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).
+ *
+ * @alpha
+ */
+export declare interface IAlertingDialogHeaderProps extends IAutomationDialogHeaderProps {
+    /**
+     * Called when the header's back/close button is pressed. The default dialog closes on it.
+     */
+    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
+ */
+export declare interface IAlertingDialogProps {
+    /**
+     * In case, we are not creating new alert, but editing existing one, this is the active alert to be edited.
+     *
+     * @deprecated has no effect since 11.51 — the dialog reads `alertToEdit` from
+     *     `useAlertingDialogContext()`. To adjust what it reads, use the
+     *     `AlertingDialogContextDecoratorComponent` dashboard prop. Prop will be removed.
+     */
+    alertToEdit?: IAutomationMetadataObject;
+    /**
+     * Notification channels in organization
+     *
+     * @deprecated has no effect since 11.51 — the dialog reads `notificationChannels` from
+     *     `useAlertingDialogContext()`. To adjust what it reads, use the
+     *     `AlertingDialogContextDecoratorComponent` dashboard prop. Prop will be removed.
+     */
+    notificationChannels?: INotificationChannelIdentifier[] | INotificationChannelMetadataObject[];
+    /**
+     * Widget to be used for alert.
+     *
+     * Note: this is available only when alerting for widget, not dashboard.
+     * Typed as IWidget (not ExtendedDashboardWidget) because the dialog only
+     * supports insight widgets; custom widgets and nested layouts are not valid
+     * alert targets and were silently discarded at the connector boundary anyway.
+     *
+     * @deprecated has no effect since 11.51 — the dialog reads `widget` from
+     *     `useAlertingDialogContext()`. To adjust what it reads, use the
+     *     `AlertingDialogContextDecoratorComponent` dashboard prop. Prop will be removed.
+     */
+    widget?: IWidget;
+    /**
+     * Insight to be used for alert.
+     *
+     * Note: this is available only when alerting for widget, not dashboard.
+     *
+     * @deprecated has no effect since 11.51 — the dialog reads `insight` from
+     *     `useAlertingDialogContext()`. To adjust what it reads, use the
+     *     `AlertingDialogContextDecoratorComponent` dashboard prop (e.g. so an alert follows a
+     *     widget's date-granularity selection). Prop will be removed.
+     */
+    insight?: IInsight;
+    /**
+     * Is alert dialog loading initial data, before it can be rendered?
+     *
+     * @deprecated has no effect since 11.51 — the dialog reads `isLoading` from
+     *     `useAlertingDialogContext()`. Prop will be removed.
+     */
+    isLoading?: boolean;
+    /**
+     * Callback to be called, when user closes the alert dialog.
+     */
+    onCancel?: () => void;
+    /**
+     * Callback to be called, when error occurs.
+     */
+    onError?: (error: GoodDataSdkError) => void;
+    /**
+     * Callback to be called, when alerting finishes successfully.
+     */
+    onSuccess?: (alertDefinition: IAutomationMetadataObject) => void;
+    /**
+     * Callback to be called, when error occurs.
+     */
+    onSaveError?: (error: GoodDataSdkError) => void;
+    /**
+     * Callback to be called, when alerting finishes successfully.
+     */
+    onSaveSuccess?: (alert: IAutomationMetadataObject) => void;
+    /**
+     * Callback to be called, when alert is deleted.
+     */
+    onDeleteSuccess?: (alert: IAutomationMetadataObject) => void;
+    /**
+     * Callback to be called, when alert fails to delete.
+     */
+    onDeleteError?: (error: GoodDataSdkError) => void;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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>>;
     /**
@@ -6033,6 +7114,98 @@ export declare interface IAlertingDialogSlots {
     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 IAlertingDialogTriggerModeProps {
+    /**
+     * Id of the dropdown button; the form row's label points at it.
+     */
+    id: string;
+    /**
+     * When the alert fires: `"ALWAYS"`, `"ONCE"` or `"ONCE_PER_INTERVAL"`.
+     */
+    selectedTriggerMode: IAlertTriggerMode;
+    /**
+     * Called with the picked mode.
+     */
+    onTriggerModeChange: (triggerMode: IAlertTriggerMode) => 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;
+    /**
+     * Offers `"ONCE_PER_INTERVAL"`; the default dialog passes the feature flag.
+     */
+    enableAlertOncePerInterval?: boolean;
+}
+
 /**
  * Sub-context for the alerting management dialog.
  * The connector hydrates this from dashboard state.
@@ -6115,17 +7288,91 @@ export declare interface IAlertingManagementDialogProps {
      * @param alert - alert that was paused
      * @param pause - true if alert was paused, false if it was resumed
      */
-    onPauseSuccess: (alert: IAutomationMetadataObject, pause: boolean) => void;
+    onPauseSuccess: (alert: IAutomationMetadataObject, pause: boolean) => void;
+    /**
+     * Callback to be called, when alert fails to pause.
+     * @param error - error that occurred
+     * @param pause - true if alert was paused, false if it was resumed
+     */
+    onPauseError: (error: GoodDataSdkError, pause: boolean) => void;
+}
+
+/**
+ * The alerting dialog's currently selected form values, derived from the draft and the supported
+ * measures and attributes.
+ *
+ * @alpha
+ */
+export declare interface IAlertSelectedValues {
+    /**
+     * The measure the condition targets; undefined until the draft names one the insight supports.
+     */
+    selectedMeasure: AlertMetric | undefined;
+    /**
+     * The operator of a fixed-threshold comparison condition.
+     */
+    selectedComparisonOperator: IAlertComparisonOperator | undefined;
+    /**
+     * The relative and arithmetic operators of a relative condition.
+     */
+    selectedRelativeOperator: [IAlertRelativeOperator, IAlertRelativeArithmeticOperator] | undefined;
+    /**
+     * The operator id of an anomaly-detection condition.
+     */
+    selectedAiOperator: AlertAiOperator | undefined;
+    /**
+     * The period comparison a relative condition uses.
+     */
+    selectedComparator: AlertMetricComparator | undefined;
+    /**
+     * The sensitivity of an anomaly-detection condition.
+     */
+    selectedSensitivity: IAlertAnomalyDetectionSensitivity | undefined;
+    /**
+     * The granularity of an anomaly-detection condition.
+     */
+    selectedGranularity: IAlertAnomalyDetectionGranularity | undefined;
+    /**
+     * The attribute the condition is sliced by.
+     */
+    selectedAttribute: AlertAttribute | undefined;
+    /**
+     * The attribute element URI the condition is sliced to; null for the empty value.
+     */
+    selectedValue: string | null | undefined;
+    /**
+     * The notification channel the draft targets, resolved against the available channels.
+     */
+    selectedNotificationChannel: INotificationChannelIdentifier | INotificationChannelMetadataObject | undefined;
+    /**
+     * Whether the selected channel accepts external (e-mail only) recipients.
+     */
+    allowExternalRecipients: boolean;
+    /**
+     * Whether the selected channel accepts only the creator as recipient.
+     */
+    allowOnlyLoggedUserRecipients: boolean;
+}
+
+/**
+ * The alerting dialog's submit path.
+ *
+ * @alpha
+ */
+export declare interface IAlertSubmitState {
+    /**
+     * Whether a create or save is in flight.
+     */
+    isSaving: boolean;
     /**
-     * Callback to be called, when alert fails to pause.
-     * @param error - error that occurred
-     * @param pause - true if alert was paused, false if it was resumed
+     * Creates the alert (no `alertToEdit`) or saves the edited one; a second call while one is in
+     * flight is ignored.
      */
-    onPauseError: (error: GoodDataSdkError, pause: boolean) => void;
+    submit: () => Promise<void>;
 }
 
 /**
- * Command for applying all working filters staged for application.
+ * Command for applying all working filters and working parameter values staged for application.
  * Usually used with setting dashboardApplyFiltersMode: ALL_AT_ONCE
  *
  * @remarks
@@ -6385,6 +7632,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.
  *
@@ -12007,6 +13278,13 @@ export declare interface IDashboardParameterEntry {
      * execution overrides so the backend keeps using the parameter's own default.
      */
     runtimeOverride: ParameterValue | undefined;
+    /**
+     * Staged (not yet applied) value under the apply-all-at-once mode. Presence means the entry
+     * is dirty: staging a value equal to `runtimeOverride` deletes the field instead of storing
+     * it, and every direct runtime write deletes it too. Executions read `runtimeOverride` only;
+     * "Apply All" folds this into `runtimeOverride`.
+     */
+    workingOverride?: ParameterValue;
 }
 
 /**
@@ -13307,8 +14585,10 @@ export declare interface IDateFiltersCustomizer {
  */
 export declare interface IDefaultAlertingDialogProps extends IAlertingDialogProps {
     /**
-     * Section-level overrides. Each slot receives `{ Default, defaultProps }` and may render its own
-     * content (replace) or `<Default {...defaultProps} />` inside its own markup (wrap).
+     * Section-level overrides. Each slot receives `{ Default, defaultProps }` — `Default` is the region's
+     * exported render component ({@link DefaultAlertingDialogHeader} for `Header`, and so on) and `defaultProps` the
+     * return of the region's props hook ({@link useAlertingDialogHeaderProps}) — and may render its own content
+     * (replace) or `<Default {...defaultProps} />` inside its own markup (wrap).
      *
      * @example
      * The dialog is reached through the `Dashboard` component override; define slot components at
@@ -13384,8 +14664,10 @@ export declare interface IDefaultDashboardToolbarGroupProps {
  */
 export declare interface IDefaultScheduledEmailDialogProps extends IScheduledEmailDialogProps {
     /**
-     * Section-level overrides. Each slot receives `{ Default, defaultProps }` and may render its own
-     * content (replace) or `<Default {...defaultProps} />` inside its own markup (wrap).
+     * Section-level overrides. Each slot receives `{ Default, defaultProps }` — `Default` is the region's
+     * exported render component ({@link DefaultScheduledEmailDialogHeader} for `Header`, and so on) and `defaultProps` the
+     * return of the region's props hook ({@link useScheduledEmailDialogHeaderProps}) — and may render its own content
+     * (replace) or `<Default {...defaultProps} />` inside its own markup (wrap).
      *
      * @example
      * The dialog is reached through the `Dashboard` component override; define slot components at
@@ -15507,6 +16789,16 @@ export declare interface IMeasureDateDatasets {
     readonly dateDatasetDisplayNames: Record<string, string>;
 }
 
+/**
+ * Number formats of the widget's measures keyed by measure local identifier, read from the
+ * execution result.
+ *
+ * @alpha
+ */
+export declare type IMeasureFormatMap = {
+    [key: string]: string;
+};
+
 /**
  * @alpha
  */
@@ -17183,8 +18475,8 @@ export declare interface IResetDashboard extends IDashboardCommand {
 }
 
 /**
- * Command for resetting all working filters.
- * It resets the working filters in to  same state as applied filters.
+ * Command for resetting all working filters and working parameter values.
+ * It resets the working filters and parameters to the same state as the applied ones.
  *
  * @remarks
  * This command ot usually used with setting dashboardApplyFiltersMode: ALL_AT_ONCE
@@ -17653,6 +18945,16 @@ export declare function isBrokenAlertAttributeFilterInfo(item: IBrokenAlertFilte
  */
 export declare function isBrokenAlertDateFilterInfo(item: IBrokenAlertFilterBasicInfo): item is BrokenAlertDateFilterInfo;
 
+/**
+ * Props of {@link ScheduledEmailDialogActionBar}: the dialog inputs
+ * {@link useScheduledEmailDialogActionBarProps} needs (`onSubmit` and `isSaving` from
+ * {@link useSaveScheduledEmailToBackend}, the dialog's `onCancel`, `onDelete` for edit mode) plus any
+ * {@link IAutomationDialogActionBarProps} member to override.
+ *
+ * @alpha
+ */
+export declare type IScheduledEmailDialogActionBarBlockProps = IUseScheduledEmailDialogActionBarPropsInput & Partial<IAutomationDialogActionBarProps>;
+
 /**
  * Sub-context for the scheduled-email create/edit dialog.
  *
@@ -18016,128 +19318,493 @@ export declare interface IScheduledEmailDialogTimezoneProps {
      */
     isWidget: boolean;
     /**
-     * Current selection; an undefined id is the Default option (dashboard schedules only).
+     * 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;
+}
+
+/**
+ * Sub-context for the scheduled-email management dialog.
+ * The connector hydrates this from dashboard state.
+ *
+ * Values already available on AutomationsContext (locale, currentUser, timezone,
+ * isWhiteLabeled, isExecutionTimestampMode, externalRecipient, features.*) are NOT
+ * duplicated here — consumers read those from useAutomationsContext().
+ *
+ * @alpha
+ */
+export declare interface IScheduledEmailManagementDialogContextValue {
+    /**
+     * Whether the scheduled-email create/edit dialog is currently open (from store UI slice).
+     * Used by the management dialog tree's focus-return logic (refocus when the edit dialog closes).
+     */
+    isScheduleEmailDialogOpen: boolean;
+    /**
+     * Monotonic counter that increments whenever the automation list is invalidated.
+     * Consumers can use this as a cache-bust key for re-fetching.
+     */
+    automationsInvalidationId?: number;
+    /**
+     * Whether accessibility mode is active (for aria/keyboard focus management).
+     */
+    enableAccessibilityMode: boolean;
+    /**
+     * Whether the dashboard is rendered in an embedded (iframe) context.
+     */
+    isEmbedded: boolean;
+    /**
+     * Id of the dashboard the management dialog is rendered on (mirrors alerting management ctx).
+     * Used to preselect the dashboard filter in the enhanced automations list.
+     */
+    dashboardId?: string;
+    /**
+     * Title of the dashboard the management dialog is rendered on (mirrors alerting management ctx).
+     * Used as the label of the preselected dashboard filter in the enhanced automations list.
+     */
+    dashboardTitle?: string;
+    /**
+     * Maximum number of automations allowed (derived connector-side from the
+     * max-automations entitlement, falling back to DEFAULT_MAX_AUTOMATIONS).
+     * Combined with the dialog's automations count to gate the create button.
+     */
+    maxAutomations: number;
+    /**
+     * Whether the unlimited-automations entitlement is present. When true the
+     * max-automations limit is not enforced.
+     */
+    unlimitedAutomations: boolean;
+    /**
+     * Scheduled exports visible in the management dialog, scoped to the current dashboard context.
+     */
+    automations: IAutomationMetadataObject[];
+    /** True while the automation list is still loading. */
+    isLoading: boolean;
+}
+
+/**
+ *
+ * @alpha
+ */
+export declare interface IScheduledEmailManagementDialogProps {
+    /**
+     * Is loading schedule data?
+     *
+     * @deprecated read `isLoading` from `useScheduledEmailManagementDialogContext()` instead. Prop will
+     *     be removed.
+     */
+    isLoadingScheduleData?: boolean;
+    /**
+     * Error occurred while loading schedule data?
+     *
+     * @deprecated not read by the default dialog. Prop will be removed.
+     */
+    scheduleDataError?: GoodDataSdkError;
+    /**
+     * Notification channels in organization
+     *
+     * @deprecated not read by the default dialog. Prop will be removed.
+     */
+    notificationChannels?: INotificationChannelIdentifier[] | INotificationChannelMetadataObject[];
+    /**
+     * Automations in workspace
+     *
+     * @deprecated read `automations` from `useScheduledEmailManagementDialogContext()` instead. Prop
+     *     will be removed.
+     */
+    automations?: IAutomationMetadataObject[];
+    /**
+     * Callback to be called, when user adds new scheduled email item.
+     */
+    onAdd?: () => void;
+    /**
+     * Callback to be called, when user clicks scheduled email item for editing.
+     */
+    onEdit?: (scheduledMail: IAutomationMetadataObject) => void;
+    /**
+     * Callback to be called, when user closes the scheduled email management dialog.
+     */
+    onClose?: () => void;
+    /**
+     * Callback to be called, when scheduled email is deleted.
+     */
+    onDeleteSuccess?: () => void;
+    /**
+     * Callback to be called, when schedule fails to delete.
+     */
+    onDeleteError?: (error: GoodDataSdkError) => void;
+}
+
+/**
+ * The scheduled-export dialog's save path.
+ *
+ * @alpha
+ */
+export declare interface IScheduledEmailSaveState {
+    /**
+     * Creates the schedule (draft without an id) or updates it (draft with one), after sanitizing it.
+     */
+    handleSaveScheduledEmail: () => void;
+    /**
+     * Whether a create or update is in flight.
+     */
+    isSavingScheduledEmail: boolean;
+    /**
+     * A 400 response's detail message, shown in the dialog without closing it; undefined otherwise.
+     */
+    savingErrorMessage: string | undefined;
+}
+
+/**
+ * The scheduled-export dialog's mutators: the draft setter, the form change-handlers, the
+ * attachment handlers and the "Time zone" section handlers.
+ *
+ * Changes rarely.
+ *
+ * @alpha
+ */
+export declare interface IScheduledExportActionsContextValue {
+    /**
+     * Replaces the draft; the change-handlers below are the preferred, field-scoped writes.
+     */
+    setEditedAutomation: Dispatch_2<SetStateAction<IAutomationMetadataObjectDefinition>>;
+    /**
+     * Sets the schedule title and re-validates its length.
+     */
+    onTitleChange: (value: string) => void;
+    /**
+     * Sets the cron expression and first run; `isValid` is the recurrence form's own verdict.
+     */
+    onRecurrenceChange: (cronExpression: string, startDate: Date | null, isValid: boolean) => void;
+    /**
+     * Switches between a shared and a per-recipient evaluation of the export.
+     */
+    onEvaluationModeChange: (isShared: boolean) => void;
+    /**
+     * Selects the notification channel; recipients incompatible with it are dropped.
+     */
+    onDestinationChange: (notificationChannelId: string) => void;
+    /**
+     * Replaces the recipients with the complete updated array.
+     */
+    onRecipientsChange: (recipients: IAutomationRecipient[]) => void;
+    /**
+     * Sets the e-mail subject; `isValid` is the subject field's own verdict.
+     */
+    onSubjectChange: (value: string | number, isValid: boolean) => void;
+    /**
+     * Sets the e-mail message; `isValid` is the message field's own verdict.
+     */
+    onMessageChange: (value: string, isValid: boolean) => void;
+    /**
+     * Replaces the dashboard export formats; new definitions inherit the current filters and timezone.
+     */
+    onDashboardAttachmentsChange: (formats: DashboardAttachmentType[]) => void;
+    /**
+     * Replaces the widget export formats; throws when the dialog has no widget.
+     */
+    onWidgetAttachmentsChange: (formats: WidgetAttachmentType[]) => void;
+    /**
+     * Sets the XLSX export settings (merge headers, export info).
+     */
+    onXlsxSettingsChange: (settings: IExportDefinitionVisualizationObjectSettings) => void;
+    /**
+     * Sets the tabular-PDF export settings (page size, orientation, export info).
+     */
+    onPdfSettingsChange: (settings: IExportDefinitionVisualizationObjectSettings) => void;
+    /**
+     * Sets the CSV export settings (delimiter).
+     */
+    onCsvSettingsChange: (settings: IExportDefinitionVisualizationObjectSettings) => void;
+    /**
+     * Sets the raw-CSV export settings (delimiter).
+     */
+    onCsvRawSettingsChange: (settings: IExportDefinitionVisualizationObjectSettings) => void;
+    /**
+     * Sets the slides template of one slides format; undefined restores the default template.
+     */
+    onSlidesTemplateIdChange: (templateId: string | undefined, format: "PPTX" | "PDF_SLIDES" | "PDF") => void;
+    /**
+     * Picks the export-content timezone; undefined selects the Default option.
+     */
+    onScheduleTimezoneChange: (timezoneId: string | undefined) => void;
+    /**
+     * Repairs a stale schedule timezone with the currently effective one.
+     */
+    applyCurrentScheduleTimezone: () => void;
+}
+
+/**
+ * What the scheduled-export dialog's attachment section displays, derived from the draft's export
+ * definitions with the defaults applied.
+ *
+ * @alpha
+ */
+export declare interface IScheduledExportAttachments {
+    /**
+     * The formats of the draft's export definitions, in definition order.
+     */
+    selectedAttachments: Array<DashboardAttachmentType | WidgetAttachmentType>;
+    /**
+     * Whether the draft holds a whole-dashboard export definition (true for a draft with none yet).
+     */
+    isDashboardExportSelected: boolean;
+    /**
+     * Whether the draft holds a widget CSV export definition.
+     */
+    isCsvExportSelected: boolean;
+    /**
+     * Whether the draft holds a widget XLSX export definition.
+     */
+    isXlsxExportSelected: boolean;
+    /**
+     * XLSX settings; `mergeHeaders` and `exportInfo` default to true.
+     */
+    xlsxSettings: IExportDefinitionVisualizationObjectSettings;
+    /**
+     * Tabular-PDF settings; page size defaults from the workspace locale, orientation to portrait,
+     * `exportInfo` to true.
+     */
+    pdfSettings: IExportDefinitionVisualizationObjectSettings;
+    /**
+     * CSV settings; an undefined `delimiter` is the backend default.
+     */
+    csvSettings: IExportDefinitionVisualizationObjectSettings;
+    /**
+     * Raw-CSV settings; an undefined `delimiter` is the backend default.
+     */
+    csvRawSettings: IExportDefinitionVisualizationObjectSettings;
+    /**
+     * The slides template chosen per slides format; undefined where the default template applies.
+     */
+    slidesTemplateIds: {
+        PPTX: string | undefined;
+        PDF_SLIDES: string | undefined;
+        PDF: string | undefined;
+    };
+}
+
+/**
+ * The scheduled-export dialog's recipient defaults: the logged-in user as a recipient, and the
+ * recipient a new schedule is seeded with, which an external-recipient override replaces.
+ *
+ * Changes when the current user or the override changes, so not while the draft is edited.
+ *
+ * @alpha
+ */
+export declare interface IScheduledExportDataContextValue {
+    /**
+     * The logged-in user as a recipient.
+     */
+    defaultUser: IAutomationRecipient;
+    /**
+     * The recipient a new schedule is seeded with; an external-recipient override replaces the user.
+     */
+    defaultRecipient: IAutomationRecipient;
+}
+
+/**
+ * The scheduled-export dialog's validity.
+ *
+ * @alpha
+ */
+export declare interface IScheduledExportDialogValidity {
+    /**
+     * Whether submit is disabled: the draft is invalid, incomplete, or unchanged in edit mode.
+     * Undefined (falsy) in create mode when nothing else disables it.
+     */
+    isSubmitDisabled: boolean | undefined;
+    /**
+     * The validation message to show; undefined when there is none.
+     */
+    validationErrorMessage: string | undefined;
+    /**
+     * Whether the schedule's source (widget or dashboard) still exists.
      */
-    selection: IScheduleTimezoneSelection;
+    isParentValid: boolean;
     /**
-     * Concrete timezone the Default option currently resolves to (display only).
+     * Whether the selected channel accepts external (e-mail only) recipients.
      */
-    defaultResolvedTimezone: string | undefined;
+    allowExternalRecipients: boolean;
     /**
-     * Called with the picked timezone; undefined selects the Default option.
+     * Whether the selected channel accepts only the creator as recipient.
      */
-    onTimezoneChange: (timezoneId: string | undefined) => void;
+    allowOnlyLoggedUserRecipients: boolean;
 }
 
 /**
- * Sub-context for the scheduled-email management dialog.
- * The connector hydrates this from dashboard state.
+ * The scheduled-export dialog's edit draft: the automation being edited, its baseline, the derived
+ * start date, the per-field validity flags, and the "Time zone" section's state.
  *
- * Values already available on AutomationsContext (locale, currentUser, timezone,
- * isWhiteLabeled, isExecutionTimestampMode, externalRecipient, features.*) are NOT
- * duplicated here — consumers read those from useAutomationsContext().
+ * Changes on every keystroke; consumers re-render by design.
  *
  * @alpha
  */
-export declare interface IScheduledEmailManagementDialogContextValue {
+export declare interface IScheduledExportDraftContextValue {
     /**
-     * Whether the scheduled-email create/edit dialog is currently open (from store UI slice).
-     * Used by the management dialog tree's focus-return logic (refocus when the edit dialog closes).
+     * The schedule being edited; seeded from the saved schedule or the defaults for a new one.
      */
-    isScheduleEmailDialogOpen: boolean;
+    editedAutomation: IAutomationMetadataObjectDefinition;
     /**
-     * Monotonic counter that increments whenever the automation list is invalidated.
-     * Consumers can use this as a cache-bust key for re-fetching.
+     * The draft as it was when the dialog opened; the dirty check compares against it.
      */
-    automationsInvalidationId?: number;
+    originalAutomation: IAutomationMetadataObjectDefinition;
     /**
-     * Whether accessibility mode is active (for aria/keyboard focus management).
+     * The schedule's first run in the user's timezone, normalized for the recurrence form.
      */
-    enableAccessibilityMode: boolean;
+    startDate: Date;
     /**
-     * Whether the dashboard is rendered in an embedded (iframe) context.
+     * Whether the recurrence form's cron expression is valid.
      */
-    isEmbedded: boolean;
+    isCronValid: boolean;
     /**
-     * Id of the dashboard the management dialog is rendered on (mirrors alerting management ctx).
-     * Used to preselect the dashboard filter in the enhanced automations list.
+     * Whether the title passes the length limit.
      */
-    dashboardId?: string;
+    isTitleValid: boolean;
     /**
-     * Title of the dashboard the management dialog is rendered on (mirrors alerting management ctx).
-     * Used as the label of the preselected dashboard filter in the enhanced automations list.
+     * Whether the e-mail subject passes its validation.
      */
-    dashboardTitle?: string;
+    isSubjectValid: boolean;
     /**
-     * Maximum number of automations allowed (derived connector-side from the
-     * max-automations entitlement, falling back to DEFAULT_MAX_AUTOMATIONS).
-     * Combined with the dialog's automations count to gate the create button.
+     * Whether the e-mail message passes its validation.
      */
-    maxAutomations: number;
+    isOnMessageValid: boolean;
     /**
-     * Whether the unlimited-automations entitlement is present. When true the
-     * max-automations limit is not enforced.
+     * The enableTimezoneChange setting; timezone-related presentation is gated by it.
      */
-    unlimitedAutomations: boolean;
+    isTimezoneFeatureEnabled: boolean;
     /**
-     * Scheduled exports visible in the management dialog, scoped to the current dashboard context.
+     * Whether the schedule may define its own export timezone (the "Time zone" section renders).
      */
-    automations: IAutomationMetadataObject[];
-    /** True while the automation list is still loading. */
-    isLoading: boolean;
+    canSelectScheduleTimezone: boolean;
+    /**
+     * The "Time zone" section's current selection (the Default option or a concrete timezone).
+     */
+    scheduleTimezoneSelection: IScheduleTimezoneSelection;
+    /**
+     * Concrete timezone the dashboard-schedule Default option currently resolves to (display only).
+     */
+    defaultResolvedTimezone: string | undefined;
+    /**
+     * True when the edited schedule cannot behave correctly as stored (widget schedule missing a
+     * dashboard-scoped timezone); feeds the apply-current-state confirmation.
+     */
+    scheduleTimezoneIsStale: boolean;
 }
 
 /**
+ * The scheduled-export dialog's filter and export-parameter model: the current selection and
+ * available filters (flat and per tab), the handlers that mutate them, the staleness gate, and the
+ * export-parameter chips with their handlers.
+ *
+ * Changes when a filter, a parameter or the store-filters toggle is edited; never per keystroke.
  *
  * @alpha
  */
-export declare interface IScheduledEmailManagementDialogProps {
+export declare interface IScheduledExportFiltersContextValue {
     /**
-     * Is loading schedule data?
-     *
-     * @deprecated read `isLoading` from `useScheduledEmailManagementDialogContext()` instead. Prop will
-     *     be removed.
+     * The filters the schedule is saved with (flat mode).
      */
-    isLoadingScheduleData?: boolean;
+    selectedFilters: FilterContextItem[];
     /**
-     * Error occurred while loading schedule data?
-     *
-     * @deprecated not read by the default dialog. Prop will be removed.
+     * The dashboard filters the schedule may use; undefined until resolved.
      */
-    scheduleDataError?: GoodDataSdkError;
+    availableFilters: FilterContextItem[] | undefined;
     /**
-     * Notification channels in organization
-     *
-     * @deprecated not read by the default dialog. Prop will be removed.
+     * Whether the schedule stores its own filters instead of using the latest saved dashboard filters.
      */
-    notificationChannels?: INotificationChannelIdentifier[] | INotificationChannelMetadataObject[];
+    storeFilters: boolean;
     /**
-     * Automations in workspace
-     *
-     * @deprecated read `automations` from `useScheduledEmailManagementDialogContext()` instead. Prop
-     *     will be removed.
+     * Filters structured per dashboard tab; present with more than one tab.
      */
-    automations?: IAutomationMetadataObject[];
+    filtersByTab: IAutomationFiltersTab[] | undefined;
     /**
-     * Callback to be called, when user adds new scheduled email item.
+     * The edited selection per dashboard tab (by-tab mode).
      */
-    onAdd?: () => void;
+    editedFiltersByTab: Record<string, FilterContextItem[]> | undefined;
     /**
-     * Callback to be called, when user clicks scheduled email item for editing.
+     * Replaces the selection with the complete updated array and mirrors it into the export
+     * definitions. `storeFiltersParam` overrides the current toggle value for this write.
      */
-    onEdit?: (scheduledMail: IAutomationMetadataObject) => void;
+    onFiltersChange: (filters: FilterContextItem[], storeFiltersParam?: boolean) => void;
     /**
-     * Callback to be called, when user closes the scheduled email management dialog.
+     * By-tab counterpart of `onFiltersChange`: replaces the per-tab selection wholesale.
      */
-    onClose?: () => void;
+    onFiltersByTabChange: (newFiltersByTab: Record<string, FilterContextItem[]>, storeFiltersParam?: boolean) => void;
     /**
-     * Callback to be called, when scheduled email is deleted.
+     * Replaces the selection with the dashboard's current filters (the stale-filters repair).
      */
-    onDeleteSuccess?: () => void;
+    onApplyCurrentFilters: () => void;
     /**
-     * Callback to be called, when schedule fails to delete.
+     * Toggles filter and parameter persistence. The current filters must be passed back — flat mode
+     * as `(value, filters, undefined)`, by-tab mode as `(value, undefined, filtersByTab)`.
      */
-    onDeleteError?: (error: GoodDataSdkError) => void;
+    onStoreFiltersChange: (value: boolean, filters?: FilterContextItem[], filtersByTabParam?: Record<string, FilterContextItem[]>) => void;
+    /**
+     * False when the saved filters or the saved parameters no longer match the dashboard; gates the
+     * stale-filters confirmation.
+     */
+    automationIsValid: boolean;
+    /**
+     * Whether the saved filters alone no longer match the dashboard.
+     */
+    filtersAreStale: boolean;
+    /**
+     * Whether the export-parameters feature is on; the parameter members below are empty when off.
+     */
+    parametersEnabled: boolean;
+    /**
+     * Per-tab visible parameters to render as chips.
+     */
+    visibleParametersByTab: Record<string, IAutomationParameter[]>;
+    /**
+     * Per-tab workspace parameters addable via the "+" menu.
+     */
+    availableParametersByTab: Record<string, IAutomationParameter[]>;
+    /**
+     * The tab the flat (non-tabbed) UI edits; undefined for multi-tab dashboards or when no
+     * parameter context applies.
+     */
+    flatTabId: string | undefined;
+    /**
+     * Adds a workspace parameter with its default value on the flat tab.
+     */
+    onParameterAdd: (ref: IdentifierRef) => void;
+    /**
+     * Sets a parameter's value on the flat tab.
+     */
+    onParameterChange: (ref: IdentifierRef, value: ParameterValue) => void;
+    /**
+     * Removes a parameter override on the flat tab.
+     */
+    onParameterDelete: (ref: IdentifierRef) => void;
+    /**
+     * Adds a workspace parameter with its default value on the given tab.
+     */
+    onParameterAddByTab: (tabId: string, ref: IdentifierRef) => void;
+    /**
+     * Sets a parameter's value on the given tab.
+     */
+    onParameterChangeByTab: (tabId: string, ref: IdentifierRef, value: ParameterValue) => void;
+    /**
+     * Removes a parameter override on the given tab.
+     */
+    onParameterDeleteByTab: (tabId: string, ref: IdentifierRef) => void;
+    /**
+     * Resets the parameters to the dashboard's current effective values (the "apply latest" flow).
+     */
+    applyLatest: () => void;
+    /**
+     * Re-encodes the parameters onto the automation with the new persistence value.
+     */
+    onStoreParametersChange: (storeParameters: boolean) => void;
 }
 
 /**
@@ -19888,6 +21555,18 @@ export declare interface ISetParameterRuntimeValuesPayload {
     tabLocalIdentifier?: string;
 }
 
+/**
+ * Stage a parameter value under the apply-all-at-once mode. The value is always concrete: the
+ * parameter control does not render for unresolved parameters, so staged `undefined` is
+ * unreachable.
+ *
+ * @alpha
+ */
+export declare interface ISetParameterWorkingValuePayload {
+    ref: ObjRef;
+    value: ParameterValue;
+}
+
 /**
  * @internal
  */
@@ -20994,6 +22673,54 @@ export declare interface IUpsertExecutionResult extends IDashboardCommand {
     readonly payload: IExecutionResultEnvelope;
 }
 
+/**
+ * Inputs of {@link useAlertingDialogActionBarProps} that come from the dialog rather than its state.
+ *
+ * @alpha
+ */
+export declare interface IUseAlertingDialogActionBarPropsInput {
+    /**
+     * Closes the dialog without saving.
+     */
+    onCancel?: () => void;
+    /**
+     * Submits the automation; the dialog's single submit path (see {@link useAlertSubmit}).
+     */
+    onSubmit: () => void;
+    /**
+     * Whether a save is in flight.
+     */
+    isSaving: boolean;
+    /**
+     * Opens the delete confirmation. Rendered only when an existing alert is being edited.
+     */
+    onDelete?: () => void;
+}
+
+/**
+ * Inputs of {@link useAlertingDialogHeaderProps} that come from the dialog rather than its state.
+ *
+ * @alpha
+ */
+export declare interface IUseAlertingDialogHeaderPropsInput {
+    /**
+     * Closes the dialog; the header's back/close button calls it.
+     */
+    onCancel?: () => void;
+    /**
+     * The dialog's initial-focus ref, attached to the title input.
+     */
+    ref?: Ref<HTMLInputElement>;
+}
+
+/**
+ * Lifecycle callbacks of {@link useAlertSubmit}: the dialog's own `onSuccess`/`onError` (create) and
+ * `onSaveSuccess`/`onSaveError` (edit).
+ *
+ * @alpha
+ */
+export declare type IUseAlertSubmitCallbacks = Pick<IAlertingDialogProps, "onSuccess" | "onError" | "onSaveSuccess" | "onSaveError">;
+
 /**
  * @internal
  */
@@ -21181,6 +22908,70 @@ export declare interface IUserInteractionPayloadWithDataBase<TType extends strin
     data: TData;
 }
 
+/**
+ * Lifecycle callbacks of {@link useSaveScheduledEmailToBackend}: `onSubmit`/`onSuccess`/`onError`
+ * (create) and `onSave`/`onSaveSuccess`/`onSaveError` (edit).
+ *
+ * @alpha
+ */
+export declare type IUseSaveScheduledEmailCallbacks = Pick<IScheduledEmailDialogProps, "onSuccess" | "onError" | "onSubmit" | "onSaveSuccess" | "onSaveError" | "onSave">;
+
+/**
+ * Inputs of {@link useScheduledEmailDialogActionBarProps} that come from the dialog rather than its state.
+ *
+ * @alpha
+ */
+export declare interface IUseScheduledEmailDialogActionBarPropsInput {
+    /**
+     * Closes the dialog without saving.
+     */
+    onCancel?: () => void;
+    /**
+     * Submits the automation; the dialog's single save path (see {@link useSaveScheduledEmailToBackend}).
+     */
+    onSubmit: () => void;
+    /**
+     * Whether a save is in flight.
+     */
+    isSaving: boolean;
+    /**
+     * Opens the delete confirmation. Rendered only when an existing schedule is being edited.
+     */
+    onDelete?: () => void;
+}
+
+/**
+ * Inputs of {@link useScheduledEmailDialogHeaderProps} that come from the dialog rather than its state.
+ *
+ * @alpha
+ */
+export declare interface IUseScheduledEmailDialogHeaderPropsInput {
+    /**
+     * Returns to the management dialog; the header's back button calls it.
+     */
+    onBack?: () => void;
+    /**
+     * Key-down handler of the title input; the dialog submits on Enter through it.
+     */
+    onTitleKeyDown: (event: KeyboardEvent_2) => void;
+    /**
+     * The dialog's initial-focus ref, attached to the title input.
+     */
+    ref?: Ref<HTMLInputElement>;
+}
+
+/**
+ * Inputs of {@link useScheduledEmailDialogRecipientsProps} that come from the dialog rather than its state.
+ *
+ * @alpha
+ */
+export declare interface IUseScheduledEmailDialogRecipientsPropsInput {
+    /**
+     * Key-down handler of the recipients input; the dialog submits on Enter through it.
+     */
+    onKeyDownSubmit: (event: KeyboardEvent_2) => void;
+}
+
 /**
  * @internal
  */
@@ -23849,6 +25640,31 @@ export declare type SavingState = {
  */
 export declare function ScheduledEmailDialog(props: IScheduledEmailDialogProps): ReactElement;
 
+/**
+ * The scheduled-export 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 useScheduledEmailDialogActionBarProps}; every override prop replaces the hook's value
+ * wholesale. The block does not own the save: pass `handleSaveScheduledEmail` and
+ * `isSavingScheduledEmail` from one {@link useSaveScheduledEmailToBackend} instance, so an Enter
+ * handler elsewhere in the shell shares it. Renders nothing while
+ * `useScheduledEmailDialogContext().isLoading` is true.
+ *
+ * @example
+ * ```tsx
+ * const { handleSaveScheduledEmail, isSavingScheduledEmail } = useSaveScheduledEmailToBackend(props);
+ * <ScheduledEmailDialogActionBar
+ *     onCancel={props.onCancel}
+ *     onSubmit={handleSaveScheduledEmail}
+ *     isSaving={isSavingScheduledEmail}
+ * />;
+ * ```
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogActionBar(props: IScheduledEmailDialogActionBarBlockProps): JSX.Element;
+
 /**
  * Provides the scheduled-email create/edit dialog context.
  *
@@ -23861,6 +25677,50 @@ export declare function ScheduledEmailDialog(props: IScheduledEmailDialogProps):
  */
 export declare const ScheduledEmailDialogContextProvider: Provider<IScheduledEmailDialogContextValue | undefined>;
 
+/**
+ * The scheduled-export dialog's destination region (the notification-channel select), connected to
+ * the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogDestination} with the props of
+ * {@link useScheduledEmailDialogDestinationProps}; every prop passed here replaces the hook's value
+ * for that prop wholesale. Renders nothing while `useScheduledEmailDialogContext().isLoading` is true.
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogDestination(overrides: Partial<IAutomationDialogDestinationProps>): JSX.Element;
+
+/**
+ * The scheduled-export dialog's filters region (the filter and parameter chips, flat or per tab),
+ * connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogFilters} with the props of
+ * {@link useScheduledEmailDialogFiltersProps}; every prop passed here replaces the hook's value for
+ * that prop wholesale (`onFiltersChange` / `onFiltersByTabChange` overrides take over the write and
+ * must submit the complete selection). Renders nothing while
+ * `useScheduledEmailDialogContext().isLoading` is true. The default dialog renders this region on its
+ * Filters tab only and hides it behind its stale-filters confirmation step; the block renders wherever
+ * it is placed — a shell that wants either builds it from {@link useScheduledExportFilters}.
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogFilters(overrides: Partial<IScheduledEmailDialogFiltersProps>): JSX.Element;
+
+/**
+ * The scheduled-export dialog's header region (the back button and the title input), connected to the
+ * dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogHeader} with the props of
+ * {@link useScheduledEmailDialogHeaderProps}; every prop passed here replaces the hook's value for that
+ * prop wholesale. Pass `onBack` to get the back button, `ref` to receive the title input, and
+ * `onTitleKeyDown` to submit on Enter — the default dialog passes a handler over its single
+ * {@link useSaveScheduledEmailToBackend} instance; without it Enter does nothing here. Renders
+ * nothing while `useScheduledEmailDialogContext().isLoading` is true, which on scheduled email is
+ * the ordinary path while a widget export's filters load.
+ *
+ * @alpha
+ */
+export declare const ScheduledEmailDialogHeader: ForwardRefExoticComponent<Partial<IScheduledEmailDialogHeaderProps> & RefAttributes<HTMLInputElement>>;
+
 /**
  * The exact props the default dialog renders its header with, including the dialog's
  * initial-focus ref.
@@ -23871,6 +25731,34 @@ export declare type ScheduledEmailDialogHeaderDefaultProps = IScheduledEmailDial
     ref?: Ref<HTMLInputElement>;
 };
 
+/**
+ * The scheduled-export dialog's recipients region, connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogRecipients} with the props of
+ * {@link useScheduledEmailDialogRecipientsProps}; every prop passed here replaces the hook's value
+ * for that prop wholesale, e.g. `<ScheduledEmailDialogRecipients maxRecipients={3} />`. Pass
+ * `onKeyDownSubmit` to submit on Enter from the recipients input — the default dialog passes a
+ * handler over its single {@link useSaveScheduledEmailToBackend} instance; without it Enter does
+ * nothing here. Renders nothing while `useScheduledEmailDialogContext().isLoading` is true.
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogRecipients(props: Partial<IScheduledEmailDialogRecipientsProps>): JSX.Element;
+
+/**
+ * The scheduled-export dialog's "Time zone" section (the export-content timezone picker), connected
+ * to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogTimezone} with the props of
+ * {@link useScheduledEmailDialogTimezoneProps}; every prop passed here replaces the hook's value
+ * wholesale. Renders nothing while `useScheduledEmailDialogContext().isLoading` is true, and nothing
+ * when `useScheduledExportDraft().canSelectScheduleTimezone` is false — the schedule may not define
+ * its own timezone then, exactly as in the default dialog.
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogTimezone(overrides: Partial<ScheduledEmailDialogTimezoneDefaultProps>): JSX.Element;
+
 /**
  * The exact props the default dialog renders its "Time zone" section with.
  *
@@ -25346,6 +27234,13 @@ export declare const selectEnableDashboardDescriptionDynamicHeight: DashboardSel
  */
 export declare const selectEnableDashboardFilterGroups: DashboardSelector<boolean>;
 
+/**
+ * Selector for the dashboard object availability (OLP partial rendering) feature flag
+ *
+ * @internal
+ */
+export declare const selectEnableDashboardPartialRendering: DashboardSelector<boolean>;
+
 /**
  * Returns whether dashboard-level date dataset configuration for section headers is enabled.
  *
@@ -26047,7 +27942,7 @@ export declare const selectFiltersWithInvalidSelection: DashboardSelector<string
 export declare const selectFilterValidationIncompatibleDefaultFiltersOverride: DashboardSelector<boolean>;
 
 /**
- * Returns the active tab's parameters in the shape persisted by a filter view.
+ * Returns the active tab's applied parameters in the shape persisted by a filter view.
  * Runtime overrides become persisted `value`; existing parameter values are kept when no runtime value exists.
  *
  * @internal
@@ -26102,8 +27997,8 @@ export declare const selectGlobalDrillsDownAttributeHierarchyByWidgetRef: (ref:
 export declare const selectHasAnyExecutionResultLimitBreaks: DashboardSelector<boolean>;
 
 /**
- * True when the active tab has at least one parameter whose `runtimeOverride` differs from
- * the value it would be reset to (per `computeParameterResetValue`).
+ * True when the active tab has at least one parameter whose display value (staged, else applied)
+ * or applied value differs from the value it would be reset to (per `computeParameterResetValue`).
  *
  * @alpha
  */
@@ -26708,7 +28603,22 @@ export declare const selectIsWidgetLoadingAdditionalDataByWidgetRef: (refs: ObjR
  *
  * @alpha
  */
-export declare const selectIsWorkingFilterContextChanged: DashboardSelector<boolean | undefined>;
+export declare const selectIsWorkingFilterContextChanged: DashboardSelector<boolean | undefined>;
+
+/**
+ * True when the active tab has at least one staged parameter value.
+ *
+ * @alpha
+ */
+export declare const selectIsWorkingParametersChanged: DashboardSelector<boolean>;
+
+/**
+ * True when the active tab has staged filters or staged parameter values that "Apply All" has not
+ * applied yet.
+ *
+ * @alpha
+ */
+export declare const selectIsWorkingSelectionChanged: DashboardSelector<boolean>;
 
 /**
  * @internal
@@ -26978,6 +28888,14 @@ export declare const selectOtherContextAttributeFilterItems: (ref?: ObjRef) => D
  */
 export declare const selectOtherContextAttributeFilters: (ref?: ObjRef) => DashboardSelector<IDashboardAttributeFilter[]>;
 
+/**
+ * Returns a selector that yields the value shown for a given parameter ref on the active tab: the
+ * staged one when the entry has it, otherwise the applied `runtimeOverride`.
+ *
+ * @alpha
+ */
+export declare const selectParameterDisplayValueByRef: (ref: ObjRef) => DashboardSelector<ParameterValue | undefined>;
+
 /**
  * Returns a selector that yields the current `runtimeOverride` for a given parameter ref on the
  * active tab, or `undefined` if the active tab does not hold an entry for that ref.
@@ -27326,6 +29244,21 @@ export declare const selectTimezone: DashboardSelector<string | undefined>;
  */
 export declare const selectTimezoneOverride: DashboardSelector<string | undefined>;
 
+/**
+ * Selects all references of the current dashboard that are unavailable to the current user.
+ *
+ * @alpha
+ */
+export declare const selectUnavailableObjects: DashboardSelector<IUnavailableDashboardReference[]>;
+
+/**
+ * Selects the unavailable dashboard references of the given object type in a mapping of obj ref to the
+ * unavailability entry. Objects of different types may share an identifier, hence the per-type maps.
+ *
+ * @alpha
+ */
+export declare const selectUnavailableObjectsMapByType: (type: ObjectType) => DashboardSelector<ObjRefMap<IUnavailableDashboardReference>>;
+
 /**
  * @internal
  */
@@ -28094,113 +30027,6 @@ export declare function switchToEditRenderMode(correlationId?: string): IChangeR
  * @internal
  */
 export declare const tabsActions: CaseReducerActions<    {
-readonly setTabs: TabsReducer<    {
-payload: {
-tabs?: ITabState[] | undefined;
-activeTabLocalIdentifier?: string | undefined;
-};
-type: string;
-}>;
-readonly setActiveTabLocalIdentifier: TabsReducer<    {
-payload: string | undefined;
-type: string;
-}>;
-readonly updateTab: TabsReducer<    {
-payload: ITabState;
-type: string;
-}>;
-readonly removeTabById: TabsReducer<    {
-payload: string;
-type: string;
-}>;
-readonly clearTabs: TabsReducer<    {
-payload: void;
-type: string;
-}>;
-readonly setTabIsRenaming: TabsReducer<    {
-payload: {
-tabId: string;
-isRenaming: boolean;
-};
-type: string;
-}>;
-readonly renameTab: TabsReducer<    {
-payload: {
-tabId: string;
-title: string;
-};
-type: string;
-}>;
-readonly resolveDefaultTab: TabsReducer<    {
-payload: {
-newLocalIdentifier: string;
-};
-type: string;
-}>;
-readonly changeAttributeFilterConfigMode: (state: WritableDraft<ITabsState>, action: {
-payload: ISetDashboardAttributeFilterConfigModePayload;
-type: string;
-}) => void | ITabsState | WritableDraft<ITabsState>;
-readonly changeAttributeFilterSelectionType: (state: WritableDraft<ITabsState>, action: {
-payload: ISetDashboardAttributeFilterSelectionTypePayload;
-type: string;
-}) => void | ITabsState | WritableDraft<ITabsState>;
-readonly setAttributeFilterConfigs: (state: WritableDraft<ITabsState>, action: {
-payload: any;
-type: string;
-}) => void | ITabsState | WritableDraft<ITabsState>;
-readonly removeAttributeFilterConfig: TabsReducer<    {
-payload: string;
-type: string;
-}>;
-readonly changeDisplayAsLabel: (state: WritableDraft<ITabsState>, action: {
-payload: ISetDashboardAttributeFilterConfigDisplayAsLabelPayload;
-type: string;
-}) => void | ITabsState | WritableDraft<ITabsState>;
-readonly setDateFilterConfig: (state: WritableDraft<ITabsState>, action: {
-payload: {
-dateFilterConfig?: IDashboardDateFilterConfig_2 | undefined;
-effectiveDateFilterConfig: IDateFilterConfig;
-isUsingDashboardOverrides: boolean;
-};
-type: string;
-}) => void | ITabsState | WritableDraft<ITabsState>;
-readonly setDateFilterConfigMode: (state: WritableDraft<ITabsState>, action: {
-payload: DashboardDateFilterConfigMode;
-type: string;
-}) => void | ITabsState | WritableDraft<ITabsState>;
-readonly setDateFilterConfigTitle: (state: WritableDraft<ITabsState>, action: {
-payload: string | undefined;
-type: string;
-}) => void | ITabsState | WritableDraft<ITabsState>;
-readonly updateDateFilterConfig: (state: WritableDraft<ITabsState>, action: {
-payload: IDashboardDateFilterConfig_2;
-type: string;
-}) => void | ITabsState | WritableDraft<ITabsState>;
-readonly addDateFilterConfigValidationWarning: (state: WritableDraft<ITabsState>, action: {
-payload: DateFilterValidationResult;
-type: string;
-}) => void | ITabsState | WritableDraft<ITabsState>;
-readonly clearDateFilterConfigValidationWarning: (state: WritableDraft<ITabsState>, action: {
-payload: void;
-type: string;
-}) => void | ITabsState | WritableDraft<ITabsState>;
-readonly changeDateFilterConfigsMode: (state: WritableDraft<ITabsState>, action: {
-payload: ISetDashboardDateFilterWithDimensionConfigModePayload;
-type: string;
-}) => void | ITabsState | WritableDraft<ITabsState>;
-readonly setDateFilterConfigs: (state: WritableDraft<ITabsState>, action: {
-payload: any;
-type: string;
-}) => void | ITabsState | WritableDraft<ITabsState>;
-readonly removeDateFilterConfigs: (state: WritableDraft<ITabsState>, action: {
-payload: ObjRef;
-type: string;
-}) => void | ITabsState | WritableDraft<ITabsState>;
-readonly changeDateFilterConfigsTitle: (state: WritableDraft<ITabsState>, action: {
-payload: ISetDateFilterConfigTitlePayload;
-type: string;
-}) => void | ITabsState | WritableDraft<ITabsState>;
 readonly setFilterContext: (state: WritableDraft<ITabsState>, action: {
 payload: {
 filterContextDefinition: IFilterContextDefinition;
@@ -28311,42 +30137,173 @@ readonly changeSelectionMode: (state: WritableDraft<ITabsState>, action: {
 payload: IChangeAttributeSelectionModePayload;
 type: string;
 }) => void | ITabsState | WritableDraft<ITabsState>;
-readonly changeLimitingItems: (state: WritableDraft<ITabsState>, action: {
-payload: IChangeAttributeLimitingItemsPayload;
+readonly changeLimitingItems: (state: WritableDraft<ITabsState>, action: {
+payload: IChangeAttributeLimitingItemsPayload;
+type: string;
+}) => void | ITabsState | WritableDraft<ITabsState>;
+readonly setPreloadedAttributesWithReferences: (state: WritableDraft<ITabsState>, action: {
+payload: IAttributeWithReferences[];
+type: string;
+}) => void | ITabsState | WritableDraft<ITabsState>;
+readonly resetWorkingFilterSelection: (state: WritableDraft<ITabsState>, action: {
+payload: void;
+type: string;
+}) => void | ITabsState | WritableDraft<ITabsState>;
+readonly setDefaultFilterOverrides: (state: WritableDraft<ITabsState>, action: {
+payload: FilterContextItem[];
+type: string;
+}) => void | ITabsState | WritableDraft<ITabsState>;
+readonly changeMeasureValueFilterCondition: (state: WritableDraft<ITabsState>, action: {
+payload: IChangeMeasureValueFilterConditionReducerPayload;
+type: string;
+}) => void | ITabsState | WritableDraft<ITabsState>;
+readonly setMeasureValueFilterDimensionality: (state: WritableDraft<ITabsState>, action: {
+payload: {
+readonly localIdentifier: string;
+readonly dimensionality?: ObjRef[] | undefined;
+};
+type: string;
+}) => void | ITabsState | WritableDraft<ITabsState>;
+readonly changeMeasureValueFilterTitle: (state: WritableDraft<ITabsState>, action: {
+payload: {
+readonly filterLocalId: string;
+readonly title?: string | undefined;
+};
+type: string;
+}) => void | ITabsState | WritableDraft<ITabsState>;
+readonly addParameter: (state: WritableDraft<ITabsState>, action: {
+payload: IAddParameterPayload;
+type: string;
+}) => void | ITabsState | WritableDraft<ITabsState>;
+readonly setParameterRuntimeValue: (state: WritableDraft<ITabsState>, action: {
+payload: ISetParameterRuntimeValuePayload;
+type: string;
+}) => void | ITabsState | WritableDraft<ITabsState>;
+readonly setParameterRuntimeValues: (state: WritableDraft<ITabsState>, action: {
+payload: ISetParameterRuntimeValuesPayload;
+type: string;
+}) => void | ITabsState | WritableDraft<ITabsState>;
+readonly setParameterWorkingValue: (state: WritableDraft<ITabsState>, action: {
+payload: ISetParameterWorkingValuePayload;
+type: string;
+}) => void | ITabsState | WritableDraft<ITabsState>;
+readonly removeParameter: (state: WritableDraft<ITabsState>, action: {
+payload: IRemoveParameterPayload;
+type: string;
+}) => void | ITabsState | WritableDraft<ITabsState>;
+readonly setTabs: TabsReducer<    {
+payload: {
+tabs?: ITabState[] | undefined;
+activeTabLocalIdentifier?: string | undefined;
+};
+type: string;
+}>;
+readonly setActiveTabLocalIdentifier: TabsReducer<    {
+payload: string | undefined;
+type: string;
+}>;
+readonly updateTab: TabsReducer<    {
+payload: ITabState;
+type: string;
+}>;
+readonly removeTabById: TabsReducer<    {
+payload: string;
+type: string;
+}>;
+readonly clearTabs: TabsReducer<    {
+payload: void;
+type: string;
+}>;
+readonly setTabIsRenaming: TabsReducer<    {
+payload: {
+tabId: string;
+isRenaming: boolean;
+};
+type: string;
+}>;
+readonly renameTab: TabsReducer<    {
+payload: {
+tabId: string;
+title: string;
+};
+type: string;
+}>;
+readonly resolveDefaultTab: TabsReducer<    {
+payload: {
+newLocalIdentifier: string;
+};
+type: string;
+}>;
+readonly applyWorkingSelection: TabsReducer<    {
+payload: IApplyWorkingSelectionPayload;
+type: string;
+}>;
+readonly resetWorkingSelection: TabsReducer<    {
+payload: void;
+type: string;
+}>;
+readonly changeAttributeFilterConfigMode: (state: WritableDraft<ITabsState>, action: {
+payload: ISetDashboardAttributeFilterConfigModePayload;
+type: string;
+}) => void | ITabsState | WritableDraft<ITabsState>;
+readonly changeAttributeFilterSelectionType: (state: WritableDraft<ITabsState>, action: {
+payload: ISetDashboardAttributeFilterSelectionTypePayload;
+type: string;
+}) => void | ITabsState | WritableDraft<ITabsState>;
+readonly setAttributeFilterConfigs: (state: WritableDraft<ITabsState>, action: {
+payload: any;
+type: string;
+}) => void | ITabsState | WritableDraft<ITabsState>;
+readonly removeAttributeFilterConfig: TabsReducer<    {
+payload: string;
+type: string;
+}>;
+readonly changeDisplayAsLabel: (state: WritableDraft<ITabsState>, action: {
+payload: ISetDashboardAttributeFilterConfigDisplayAsLabelPayload;
+type: string;
+}) => void | ITabsState | WritableDraft<ITabsState>;
+readonly setDateFilterConfig: (state: WritableDraft<ITabsState>, action: {
+payload: {
+dateFilterConfig?: IDashboardDateFilterConfig_2 | undefined;
+effectiveDateFilterConfig: IDateFilterConfig;
+isUsingDashboardOverrides: boolean;
+};
+type: string;
+}) => void | ITabsState | WritableDraft<ITabsState>;
+readonly setDateFilterConfigMode: (state: WritableDraft<ITabsState>, action: {
+payload: DashboardDateFilterConfigMode;
+type: string;
+}) => void | ITabsState | WritableDraft<ITabsState>;
+readonly setDateFilterConfigTitle: (state: WritableDraft<ITabsState>, action: {
+payload: string | undefined;
 type: string;
 }) => void | ITabsState | WritableDraft<ITabsState>;
-readonly setPreloadedAttributesWithReferences: (state: WritableDraft<ITabsState>, action: {
-payload: IAttributeWithReferences[];
+readonly updateDateFilterConfig: (state: WritableDraft<ITabsState>, action: {
+payload: IDashboardDateFilterConfig_2;
 type: string;
 }) => void | ITabsState | WritableDraft<ITabsState>;
-readonly applyWorkingSelection: (state: WritableDraft<ITabsState>, action: {
-payload: IApplyWorkingSelectionPayload;
+readonly addDateFilterConfigValidationWarning: (state: WritableDraft<ITabsState>, action: {
+payload: DateFilterValidationResult;
 type: string;
 }) => void | ITabsState | WritableDraft<ITabsState>;
-readonly resetWorkingSelection: (state: WritableDraft<ITabsState>, action: {
+readonly clearDateFilterConfigValidationWarning: (state: WritableDraft<ITabsState>, action: {
 payload: void;
 type: string;
 }) => void | ITabsState | WritableDraft<ITabsState>;
-readonly setDefaultFilterOverrides: (state: WritableDraft<ITabsState>, action: {
-payload: FilterContextItem[];
+readonly changeDateFilterConfigsMode: (state: WritableDraft<ITabsState>, action: {
+payload: ISetDashboardDateFilterWithDimensionConfigModePayload;
 type: string;
 }) => void | ITabsState | WritableDraft<ITabsState>;
-readonly changeMeasureValueFilterCondition: (state: WritableDraft<ITabsState>, action: {
-payload: IChangeMeasureValueFilterConditionReducerPayload;
+readonly setDateFilterConfigs: (state: WritableDraft<ITabsState>, action: {
+payload: any;
 type: string;
 }) => void | ITabsState | WritableDraft<ITabsState>;
-readonly setMeasureValueFilterDimensionality: (state: WritableDraft<ITabsState>, action: {
-payload: {
-readonly localIdentifier: string;
-readonly dimensionality?: ObjRef[] | undefined;
-};
+readonly removeDateFilterConfigs: (state: WritableDraft<ITabsState>, action: {
+payload: ObjRef;
 type: string;
 }) => void | ITabsState | WritableDraft<ITabsState>;
-readonly changeMeasureValueFilterTitle: (state: WritableDraft<ITabsState>, action: {
-payload: {
-readonly filterLocalId: string;
-readonly title?: string | undefined;
-};
+readonly changeDateFilterConfigsTitle: (state: WritableDraft<ITabsState>, action: {
+payload: ISetDateFilterConfigTitlePayload;
 type: string;
 }) => void | ITabsState | WritableDraft<ITabsState>;
 readonly setLayout: (state: WritableDraft<ITabsState>, action: {
@@ -28671,22 +30628,6 @@ readonly removeMeasureValueFilterConfig: (state: WritableDraft<ITabsState>, acti
 payload: string;
 type: string;
 }) => void | ITabsState | WritableDraft<ITabsState>;
-readonly addParameter: (state: WritableDraft<ITabsState>, action: {
-payload: IAddParameterPayload;
-type: string;
-}) => void | ITabsState | WritableDraft<ITabsState>;
-readonly setParameterRuntimeValue: (state: WritableDraft<ITabsState>, action: {
-payload: ISetParameterRuntimeValuePayload;
-type: string;
-}) => void | ITabsState | WritableDraft<ITabsState>;
-readonly setParameterRuntimeValues: (state: WritableDraft<ITabsState>, action: {
-payload: ISetParameterRuntimeValuesPayload;
-type: string;
-}) => void | ITabsState | WritableDraft<ITabsState>;
-readonly removeParameter: (state: WritableDraft<ITabsState>, action: {
-payload: IRemoveParameterPayload;
-type: string;
-}) => void | ITabsState | WritableDraft<ITabsState>;
 }, "tabs">;
 
 /**
@@ -28996,6 +30937,105 @@ export declare function unignoreFilterOnRichTextWidget(ref: ObjRef, oneOrMoreDis
  */
 export declare function updateVisualizationsFromSwitcherWidgetContent(ref: ObjRef, visualizations: IInsightWidget[], correlationId?: string): IUpdateVisualizationsFromVisualizationSwitcherWidgetContent;
 
+/**
+ * Reads the alerting dialog's mutators.
+ *
+ * Throws outside the alerting dialog's state providers, which mount only once
+ * `useAlertingDialogContext().isLoading` is false — a replacement for `AlertingDialogComponent`
+ * must check that flag before calling this. On the alerting side that state is reached only by an
+ * automations refresh while the dialog is open, so it will not appear in manual testing.
+ *
+ * @alpha
+ */
+export declare function useAlertActions(): IAlertActionsContextValue;
+
+/**
+ * Reads the data the alerting dialog loads asynchronously.
+ *
+ * Throws outside the alerting dialog's state providers, which mount only once
+ * `useAlertingDialogContext().isLoading` is false — a replacement for `AlertingDialogComponent`
+ * must check that flag before calling this. On the alerting side that state is reached only by an
+ * automations refresh while the dialog is open, so it will not appear in manual testing.
+ *
+ * @alpha
+ */
+export declare function useAlertData(): IAlertDataContextValue;
+
+/**
+ * Reads the alerting dialog's validity: whether submit is enabled, the validation message to show,
+ * whether the parent widget is still valid, whether the measure may be changed, and whether the
+ * saved alert points at a widget whose insight is gone.
+ *
+ * @alpha
+ */
+export declare function useAlertDialogValidity(): IAlertDialogValidity;
+
+/**
+ * Reads the alerting dialog's edit draft.
+ *
+ * Throws outside the alerting dialog's state providers, which mount only once
+ * `useAlertingDialogContext().isLoading` is false — a replacement for `AlertingDialogComponent`
+ * must check that flag before calling this. On the alerting side that state is reached only by an
+ * automations refresh while the dialog is open, so it will not appear in manual testing.
+ *
+ * @alpha
+ */
+export declare function useAlertDraft(): IAlertDraftContextValue;
+
+/**
+ * Reads the alerting dialog's filter and export-parameter model.
+ *
+ * Throws outside the alerting dialog's state providers, which mount only once
+ * `useAlertingDialogContext().isLoading` is false — a replacement for `AlertingDialogComponent`
+ * must check that flag before calling this. On the alerting side that state is reached only by an
+ * automations refresh while the dialog is open, so it will not appear in manual testing.
+ *
+ * @alpha
+ */
+export declare function useAlertFilters(): IAlertFiltersContextValue;
+
+/**
+ * The exact props the default alerting dialog renders its action bar with.
+ *
+ * Throws outside the alerting dialog's state providers.
+ *
+ * @alpha
+ */
+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.
  *
@@ -29010,6 +31050,103 @@ export declare function updateVisualizationsFromSwitcherWidgetContent(ref: ObjRe
  */
 export declare function useAlertingDialogContext(): IAlertingDialogContextValue;
 
+/**
+ * The exact props the default alerting dialog renders its destination region with.
+ *
+ * Throws outside the alerting dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useAlertingDialogDestinationProps(): IAutomationDialogDestinationProps;
+
+/**
+ * The exact props the default alerting dialog renders its filters region with.
+ *
+ * Throws outside the alerting dialog's state providers.
+ *
+ * @alpha
+ */
+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.
+ *
+ * Throws outside the alerting dialog's state providers.
+ *
+ * @alpha
+ */
+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.
+ *
+ * Throws outside the alerting dialog's state providers.
+ *
+ * @alpha
+ */
+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.
  *
@@ -29024,6 +31161,29 @@ export declare function useAlertingDialogContext(): IAlertingDialogContextValue;
  */
 export declare function useAlertingManagementDialogContext(): IAlertingManagementDialogContextValue;
 
+/**
+ * Reads the currently-selected form values for the alerting dialog.
+ *
+ * Derived per consumer rather than published on a context: the returned objects flow into
+ * `useCallback` dependency arrays and `useAlertThreshold` arguments, so recomputing them every
+ * render is what keeps those consumers behaving correctly.
+ *
+ * @alpha
+ */
+export declare function useAlertSelectedValues(): IAlertSelectedValues;
+
+/**
+ * Submits the alerting dialog's draft: creates a new alert or saves the edited one, deriving a title
+ * when the draft has none, and routes the result to the matching callback. Guards against a second
+ * submit while one is in flight.
+ *
+ * Reads the draft, the supported measures, the edited alert and the separators from the alerting
+ * contexts, so it throws outside the alerting dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useAlertSubmit({ onSuccess, onError, onSaveSuccess, onSaveError }: IUseAlertSubmitCallbacks): IAlertSubmitState;
+
 /**
  * Reads the automation dialogs' shared context.
  *
@@ -30006,6 +32166,26 @@ export declare function useSaveAsNewButtonProps(): ISaveAsNewButtonProps;
  */
 export declare function useSaveButtonProps(): ISaveButtonProps;
 
+/**
+ * Saves the scheduled-export dialog's draft: creates a new schedule or updates the edited one after
+ * sanitizing it, keeps a 400 response's detail as an in-dialog error message, and routes everything
+ * else to the matching callback.
+ *
+ * Reads the draft from the scheduled-export state contexts, so it throws outside them.
+ *
+ * @alpha
+ */
+export declare function useSaveScheduledEmailToBackend({ onSuccess, onError, onSubmit, onSaveSuccess, onSaveError, onSave }: IUseSaveScheduledEmailCallbacks): IScheduledEmailSaveState;
+
+/**
+ * The exact props the default scheduled-email dialog renders its action bar with.
+ *
+ * Throws outside the scheduled-export dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useScheduledEmailDialogActionBarProps({ onCancel, onSubmit, isSaving, onDelete }: IUseScheduledEmailDialogActionBarPropsInput): IAutomationDialogActionBarProps;
+
 /**
  * Reads the scheduled-email create/edit dialog context.
  *
@@ -30020,6 +32200,51 @@ export declare function useSaveButtonProps(): ISaveButtonProps;
  */
 export declare function useScheduledEmailDialogContext(): IScheduledEmailDialogContextValue;
 
+/**
+ * The exact props the default scheduled-email dialog renders its destination region with.
+ *
+ * Throws outside the scheduled-export dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useScheduledEmailDialogDestinationProps(): IAutomationDialogDestinationProps;
+
+/**
+ * The exact props the default scheduled-email dialog renders its filters region with.
+ *
+ * Throws outside the scheduled-export dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useScheduledEmailDialogFiltersProps(): IScheduledEmailDialogFiltersProps;
+
+/**
+ * The exact props the default scheduled-email dialog renders its header region with.
+ *
+ * Throws outside the scheduled-export dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useScheduledEmailDialogHeaderProps({ onBack, onTitleKeyDown, ref }: IUseScheduledEmailDialogHeaderPropsInput): ScheduledEmailDialogHeaderDefaultProps;
+
+/**
+ * The exact props the default scheduled-email dialog renders its recipients region with.
+ *
+ * Throws outside the scheduled-export dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useScheduledEmailDialogRecipientsProps({ onKeyDownSubmit }: IUseScheduledEmailDialogRecipientsPropsInput): IScheduledEmailDialogRecipientsProps;
+
+/**
+ * The exact props the default scheduled-email dialog renders its "Time zone" section with.
+ *
+ * Throws outside the scheduled-export dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useScheduledEmailDialogTimezoneProps(): ScheduledEmailDialogTimezoneDefaultProps;
+
 /**
  * Reads the scheduled-email management dialog context.
  *
@@ -30034,6 +32259,80 @@ export declare function useScheduledEmailDialogContext(): IScheduledEmailDialogC
  */
 export declare function useScheduledEmailManagementDialogContext(): IScheduledEmailManagementDialogContextValue;
 
+/**
+ * Reads the scheduled-export dialog's draft mutators.
+ *
+ * Throws outside the scheduled-export dialog's state providers, which mount only once
+ * `useScheduledEmailDialogContext().isLoading` is false — a replacement for
+ * `ScheduledEmailDialogComponent` must check that flag before calling this. That state is on the
+ * ordinary path here: a widget export renders while its filters load.
+ *
+ * @alpha
+ */
+export declare function useScheduledExportActions(): IScheduledExportActionsContextValue;
+
+/**
+ * Reads what the scheduled-export dialog's attachment section displays: the selected formats, which
+ * export kinds are present, the per-format settings with their fallbacks, and the slides template
+ * chosen per format.
+ *
+ * Derived per consumer rather than published on a context: every value is a pure function of the
+ * draft and of workspace settings, and no consumer observes their identity. The handlers that
+ * *change* attachments are on {@link useScheduledExportActions}, because they capture the stored
+ * export-parameter wire, which must exist once per dialog.
+ *
+ * @alpha
+ */
+export declare function useScheduledExportAttachments(): IScheduledExportAttachments;
+
+/**
+ * Reads the scheduled-export dialog's recipient defaults.
+ *
+ * Throws outside the scheduled-export dialog's state providers, which mount only once
+ * `useScheduledEmailDialogContext().isLoading` is false — a replacement for
+ * `ScheduledEmailDialogComponent` must check that flag before calling this. That state is on the
+ * ordinary path here: a widget export renders while its filters load.
+ *
+ * @alpha
+ */
+export declare function useScheduledExportData(): IScheduledExportDataContextValue;
+
+/**
+ * Reads the scheduled-export dialog's validity: whether submit is enabled, the validation message to
+ * show, whether the schedule's source widget still exists, and which recipient kinds the selected
+ * notification channel permits.
+ *
+ * Derived per consumer rather than published on a context: it is a pure function of the draft, the
+ * recipient defaults and the dialog's own context, and no consumer observes its identity.
+ *
+ * @alpha
+ */
+export declare function useScheduledExportDialogValidity(): IScheduledExportDialogValidity;
+
+/**
+ * Reads the scheduled-export dialog's edit draft.
+ *
+ * Throws outside the scheduled-export dialog's state providers, which mount only once
+ * `useScheduledEmailDialogContext().isLoading` is false — a replacement for
+ * `ScheduledEmailDialogComponent` must check that flag before calling this. That state is on the
+ * ordinary path here: a widget export renders while its filters load.
+ *
+ * @alpha
+ */
+export declare function useScheduledExportDraft(): IScheduledExportDraftContextValue;
+
+/**
+ * Reads the scheduled-export dialog's filter and export-parameter model.
+ *
+ * Throws outside the scheduled-export dialog's state providers, which mount only once
+ * `useScheduledEmailDialogContext().isLoading` is false — a replacement for
+ * `ScheduledEmailDialogComponent` must check that flag before calling this. That state is on the
+ * ordinary path here: a widget export renders while its filters load.
+ *
+ * @alpha
+ */
+export declare function useScheduledExportFilters(): IScheduledExportFiltersContextValue;
+
 /**
  * @alpha
  */