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

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 { AI_OPERATOR } from '@gooddata/sdk-ui-ext';
+import { 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,22 @@ import { EntityState } from '@reduxjs/toolkit';
 import { ExecutionResultLimitType } from '@gooddata/sdk-model';
 import { ExplicitDrill } from '@gooddata/sdk-ui';
 import { FilterContextItem } from '@gooddata/sdk-model';
+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 +117,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 +143,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 +201,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 +238,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 +254,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 +528,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 alert condition.
+ *
+ * @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 +560,26 @@ 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;
+
 /**
  * Provides the alerting create/edit dialog context.
  *
@@ -532,6 +591,60 @@ 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 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 +655,18 @@ export declare type AlertingDialogHeaderDefaultProps = IAlertingDialogHeaderProp
     ref?: Ref<HTMLInputElement>;
 };
 
+/**
+ * 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;
+
 /**
  * @internal
  */
@@ -552,6 +677,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 +909,27 @@ 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;
+};
+
 /**
  * @alpha
  */
@@ -3442,6 +3648,8 @@ export declare type DashboardState = {
     accessibleDashboards: IAccessibleDashboardsState;
     /** @alpha */
     inaccessibleDashboards: EntityState<IInaccessibleDashboard, EntityId>;
+    /** @alpha */
+    unavailableObjects: EntityState<IUnavailableDashboardReference, EntityId>;
     dashboardPermissions: DashboardPermissionsState;
     /** @alpha */
     automations: IAutomationsState;
@@ -3966,6 +4174,14 @@ export declare const DEFAULT_TAB_ID = "defaultTabId";
  * that is what lets a wholesale replacement receive the same contexts. Rendering this component
  * outside those providers throws at runtime.
  *
+ * The dialog is composed from the exported region renders — {@link DefaultAlertingDialogHeader},
+ * {@link DefaultAlertingDialogFilters}, {@link DefaultAlertingDialogDestination},
+ * {@link DefaultAlertingDialogRecipients}, {@link DefaultAutomationDialogActionBar} — fed by the
+ * matching `use*Props` hooks ({@link useAlertingDialogFiltersProps} and siblings). A custom
+ * `AlertingDialogComponent` that keeps our regions but owns the markup places the connected blocks
+ * ({@link AlertingDialogFilters} and siblings) instead of this component, and reads or writes the
+ * same draft through {@link useAlertDraft} and {@link useAlertActions}.
+ *
  * 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 +4189,47 @@ export declare const DEFAULT_TAB_ID = "defaultTabId";
  */
 export declare function DefaultAlertingDialog(props: IDefaultAlertingDialogProps): JSX.Element;
 
+/**
+ * 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 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 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;
+
 /**
  * Self-contained version of DefaultAlertingManagementDialogNew that builds the required
  * AutomationsContext and AlertingManagementDialogContext internally from the dashboard
@@ -3983,6 +4240,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 +4494,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}.
@@ -4234,6 +4511,63 @@ 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 DefaultScheduledEmailDialogDestination({ notificationChannels, selectedNotificationChannelId, onChange }: IAutomationDialogDestinationProps): JSX.Element;
+
+/**
+ * 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 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 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
  */
@@ -5813,82 +6147,318 @@ export declare interface IAddVisualizationToVisualizationSwitcherWidgetContentPa
 }
 
 /**
- * @internal
+ * 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 IAlertDialogContext {
+export declare interface IAlertActionsContextValue {
     /**
-     * Widget to create/edit alert for.
+     * Replaces the draft; the change-handlers below are the preferred, field-scoped writes.
      */
-    widgetRef?: ObjRef;
+    setEditedAutomation: Dispatch_2<SetStateAction<IAutomationMetadataObjectDefinition | undefined>>;
     /**
-     * Alert to edit.
+     * Sets the alert title and re-validates its length.
      */
-    alert?: IAutomationMetadataObject;
+    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;
 }
 
 /**
- * Sub-context for the alerting create/edit dialog.
+ * 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.
  *
- * 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`.
+ * Changes when an async load resolves, not per keystroke.
  *
  * @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 IAlertDataContextValue {
     /**
-     * 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).
+     * Measures of the insight an alert can be built on, with their comparisons.
      */
-    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;
+    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;
 }
 
 /**
- * Props of the default alerting dialog's filters region (the filter and parameter chips above
- * the form).
- *
- * @alpha
+ * @internal
  */
-export declare interface IAlertingDialogFiltersProps extends IAutomationDialogFiltersProps {
+export declare interface IAlertDialogContext {
     /**
-     * Disables the date filter chips. The default dialog disables them while the alert uses
-     * anomaly detection.
+     * Widget to create/edit alert for.
      */
-    disableDateFilters: boolean;
+    widgetRef?: ObjRef;
+    /**
+     * Alert to edit.
+     */
+    alert?: IAutomationMetadataObject;
 }
 
 /**
- * Props of the default alerting dialog's header region (the title input row).
+ * The alerting dialog's validity.
  *
  * @alpha
  */
-export declare interface IAlertingDialogHeaderProps extends IAutomationDialogHeaderProps {
+export declare interface IAlertDialogValidity {
     /**
-     * Called when the header's back/close button is pressed. The default dialog closes on it.
+     * Whether submit is disabled: the draft is invalid, incomplete, or unchanged in edit mode.
+     */
+    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;
+}
+
+/**
+ * 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 IAlertDraftContextValue {
+    /**
+     * The alert being edited. Undefined only before the state model has seeded it.
+     */
+    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;
+}
+
+/**
+ * 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 IAlertFiltersContextValue {
+    /**
+     * The filters the alert is saved with.
+     */
+    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 type IAlertingDialogActionBarBlockProps = IUseAlertingDialogActionBarPropsInput & Partial<IAutomationDialogActionBarProps>;
+
+/**
+ * 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 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;
 }
@@ -6125,7 +6695,81 @@ export declare interface IAlertingManagementDialogProps {
 }
 
 /**
- * Command for applying all working filters staged for application.
+ * 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;
+    /**
+     * Creates the alert (no `alertToEdit`) or saves the edited one; a second call while one is in
+     * flight is ignored.
+     */
+    submit: () => Promise<void>;
+}
+
+/**
+ * Command for applying all working filters and working parameter values staged for application.
  * Usually used with setting dashboardApplyFiltersMode: ALL_AT_ONCE
  *
  * @remarks
@@ -12007,6 +12651,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 +13958,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 +14037,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 +16162,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 +17848,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 +18318,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.
  *
@@ -18141,62 +18816,427 @@ export declare interface IScheduledEmailManagementDialogProps {
 }
 
 /**
- * @internal
+ * The scheduled-export dialog's save path.
+ *
+ * @alpha
  */
-export declare interface IScheduleEmailContext {
+export declare interface IScheduledEmailSaveState {
     /**
-     * Widget to schedule email for.
+     * Creates the schedule (draft without an id) or updates it (draft with one), after sanitizing it.
      */
-    widgetRef?: ObjRef | undefined;
+    handleSaveScheduledEmail: () => void;
     /**
-     * Schedule to edit.
+     * Whether a create or update is in flight.
      */
-    schedule?: IAutomationMetadataObject;
+    isSavingScheduledEmail: boolean;
+    /**
+     * A 400 response's detail message, shown in the dialog without closing it; undefined otherwise.
+     */
+    savingErrorMessage: string | undefined;
 }
 
 /**
- * A timezone selection of the schedule dialog's "Time zone" section.
+ * The scheduled-export dialog's mutators: the draft setter, the form change-handlers, the
+ * attachment handlers and the "Time zone" section handlers.
  *
- * `shouldSave` decides whether the value is baked into the export definitions. Values the backend
- * derives itself at run time are displayed but not saved: the Default option of a dashboard
- * schedule (id undefined; persisted dashboard configuration → settings hierarchy) and a widget
- * schedule showing the settings-hierarchy resolution (concrete id). Everything the backend cannot
- * derive is saved: the view-mode override and browser resolution always, the dashboard's stored
- * configuration for widget schedules, and any timezone picked manually in the dropdown.
+ * Changes rarely.
  *
  * @alpha
  */
-export declare interface IScheduleTimezoneSelection {
+export declare interface IScheduledExportActionsContextValue {
     /**
-     * Selected timezone (IANA ID); undefined represents the Default option.
+     * Replaces the draft; the change-handlers below are the preferred, field-scoped writes.
      */
-    id: string | undefined;
+    setEditedAutomation: Dispatch_2<SetStateAction<IAutomationMetadataObjectDefinition>>;
     /**
-     * Whether the selection is baked into the export definitions or left for the backend to
-     * derive at run time.
+     * Sets the schedule title and re-validates its length.
      */
-    shouldSave: boolean;
+    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;
 }
 
 /**
- * Tests whether the provided object is an instance of {@link ICreateAttributeHierarchyRequested}.
- *
- * @param obj - object to test
- * @internal
- */
-export declare const isCreateAttributeHierarchyRequested: (obj: unknown) => obj is ICreateAttributeHierarchyRequested;
-
-/**
- * Tests whether the provided object is an instance of {@link ICreateInsightRequested}.
+ * What the scheduled-export dialog's attachment section displays, derived from the draft's export
+ * definitions with the defaults applied.
  *
- * @param obj - object to test
- * @internal
+ * @alpha
  */
-export declare const isCreateInsightRequested: (obj: unknown) => obj is ICreateInsightRequested;
-
-/**
- * This event is emitted after change of the dashboard layout screen size.
- *
+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.
+     */
+    isParentValid: boolean;
+    /**
+     * 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 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.
+ *
+ * Changes on every keystroke; consumers re-render by design.
+ *
+ * @alpha
+ */
+export declare interface IScheduledExportDraftContextValue {
+    /**
+     * The schedule being edited; seeded from the saved schedule or the defaults for a new one.
+     */
+    editedAutomation: IAutomationMetadataObjectDefinition;
+    /**
+     * The draft as it was when the dialog opened; the dirty check compares against it.
+     */
+    originalAutomation: IAutomationMetadataObjectDefinition;
+    /**
+     * The schedule's first run in the user's timezone, normalized for the recurrence form.
+     */
+    startDate: Date;
+    /**
+     * Whether the recurrence form's cron expression is valid.
+     */
+    isCronValid: boolean;
+    /**
+     * Whether the title passes the length limit.
+     */
+    isTitleValid: boolean;
+    /**
+     * Whether the e-mail subject passes its validation.
+     */
+    isSubjectValid: boolean;
+    /**
+     * Whether the e-mail message passes its validation.
+     */
+    isOnMessageValid: boolean;
+    /**
+     * The enableTimezoneChange setting; timezone-related presentation is gated by it.
+     */
+    isTimezoneFeatureEnabled: boolean;
+    /**
+     * Whether the schedule may define its own export timezone (the "Time zone" section renders).
+     */
+    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 IScheduledExportFiltersContextValue {
+    /**
+     * The filters the schedule is saved with (flat mode).
+     */
+    selectedFilters: FilterContextItem[];
+    /**
+     * The dashboard filters the schedule may use; undefined until resolved.
+     */
+    availableFilters: FilterContextItem[] | undefined;
+    /**
+     * Whether the schedule stores its own filters instead of using the latest saved dashboard filters.
+     */
+    storeFilters: boolean;
+    /**
+     * Filters structured per dashboard tab; present with more than one tab.
+     */
+    filtersByTab: IAutomationFiltersTab[] | undefined;
+    /**
+     * The edited selection per dashboard tab (by-tab mode).
+     */
+    editedFiltersByTab: Record<string, FilterContextItem[]> | undefined;
+    /**
+     * Replaces the selection with the complete updated array and mirrors it into the export
+     * definitions. `storeFiltersParam` overrides the current toggle value for this write.
+     */
+    onFiltersChange: (filters: FilterContextItem[], storeFiltersParam?: boolean) => void;
+    /**
+     * By-tab counterpart of `onFiltersChange`: replaces the per-tab selection wholesale.
+     */
+    onFiltersByTabChange: (newFiltersByTab: Record<string, FilterContextItem[]>, storeFiltersParam?: boolean) => void;
+    /**
+     * Replaces the selection with the dashboard's current filters (the stale-filters repair).
+     */
+    onApplyCurrentFilters: () => void;
+    /**
+     * 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)`.
+     */
+    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;
+}
+
+/**
+ * @internal
+ */
+export declare interface IScheduleEmailContext {
+    /**
+     * Widget to schedule email for.
+     */
+    widgetRef?: ObjRef | undefined;
+    /**
+     * Schedule to edit.
+     */
+    schedule?: IAutomationMetadataObject;
+}
+
+/**
+ * A timezone selection of the schedule dialog's "Time zone" section.
+ *
+ * `shouldSave` decides whether the value is baked into the export definitions. Values the backend
+ * derives itself at run time are displayed but not saved: the Default option of a dashboard
+ * schedule (id undefined; persisted dashboard configuration → settings hierarchy) and a widget
+ * schedule showing the settings-hierarchy resolution (concrete id). Everything the backend cannot
+ * derive is saved: the view-mode override and browser resolution always, the dashboard's stored
+ * configuration for widget schedules, and any timezone picked manually in the dropdown.
+ *
+ * @alpha
+ */
+export declare interface IScheduleTimezoneSelection {
+    /**
+     * Selected timezone (IANA ID); undefined represents the Default option.
+     */
+    id: string | undefined;
+    /**
+     * Whether the selection is baked into the export definitions or left for the backend to
+     * derive at run time.
+     */
+    shouldSave: boolean;
+}
+
+/**
+ * Tests whether the provided object is an instance of {@link ICreateAttributeHierarchyRequested}.
+ *
+ * @param obj - object to test
+ * @internal
+ */
+export declare const isCreateAttributeHierarchyRequested: (obj: unknown) => obj is ICreateAttributeHierarchyRequested;
+
+/**
+ * Tests whether the provided object is an instance of {@link ICreateInsightRequested}.
+ *
+ * @param obj - object to test
+ * @internal
+ */
+export declare const isCreateInsightRequested: (obj: unknown) => obj is ICreateInsightRequested;
+
+/**
+ * This event is emitted after change of the dashboard layout screen size.
+ *
  * @beta
  */
 export declare interface IScreenSizeChanged extends IDashboardEvent {
@@ -19888,6 +20928,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 +22046,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
  */
@@ -21182,17 +22282,81 @@ export declare interface IUserInteractionPayloadWithDataBase<TType extends strin
 }
 
 /**
- * @internal
+ * Lifecycle callbacks of {@link useSaveScheduledEmailToBackend}: `onSubmit`/`onSuccess`/`onError`
+ * (create) and `onSave`/`onSaveSuccess`/`onSaveError` (edit).
+ *
+ * @alpha
  */
-export declare interface IUseWidgetSelectionResult {
+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 {
     /**
-     * Flag indicating the given item can be selected.
+     * Closes the dialog without saving.
      */
-    isSelectable: boolean;
+    onCancel?: () => void;
     /**
-     * Flag indicating the given item is selected.
+     * Submits the automation; the dialog's single save path (see {@link useSaveScheduledEmailToBackend}).
      */
-    isSelected: boolean;
+    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
+ */
+export declare interface IUseWidgetSelectionResult {
+    /**
+     * Flag indicating the given item can be selected.
+     */
+    isSelectable: boolean;
+    /**
+     * Flag indicating the given item is selected.
+     */
+    isSelected: boolean;
     /**
      * Callback to call when an item is selected. Called with the relevant mouse event if originating from a click.
      */
@@ -23849,6 +25013,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 +25050,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 +25104,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 +26607,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 +27315,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 +27370,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
  */
@@ -26710,6 +27978,21 @@ export declare const selectIsWidgetLoadingAdditionalDataByWidgetRef: (refs: ObjR
  */
 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 +28261,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 +28617,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 +29400,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;
@@ -28319,11 +29518,7 @@ readonly setPreloadedAttributesWithReferences: (state: WritableDraft<ITabsState>
 payload: IAttributeWithReferences[];
 type: string;
 }) => void | ITabsState | WritableDraft<ITabsState>;
-readonly applyWorkingSelection: (state: WritableDraft<ITabsState>, action: {
-payload: IApplyWorkingSelectionPayload;
-type: string;
-}) => void | ITabsState | WritableDraft<ITabsState>;
-readonly resetWorkingSelection: (state: WritableDraft<ITabsState>, action: {
+readonly resetWorkingFilterSelection: (state: WritableDraft<ITabsState>, action: {
 payload: void;
 type: string;
 }) => void | ITabsState | WritableDraft<ITabsState>;
@@ -28349,41 +29544,176 @@ readonly title?: string | undefined;
 };
 type: string;
 }) => void | ITabsState | WritableDraft<ITabsState>;
-readonly setLayout: (state: WritableDraft<ITabsState>, action: {
-payload: IDashboardLayout<ExtendedDashboardWidget>;
+readonly addParameter: (state: WritableDraft<ITabsState>, action: {
+payload: IAddParameterPayload;
 type: string;
 }) => void | ITabsState | WritableDraft<ITabsState>;
-readonly setScreen: (state: WritableDraft<ITabsState>, action: {
-payload: {
-screen: ScreenSize;
-};
+readonly setParameterRuntimeValue: (state: WritableDraft<ITabsState>, action: {
+payload: ISetParameterRuntimeValuePayload;
 type: string;
 }) => void | ITabsState | WritableDraft<ITabsState>;
-readonly updateWidgetIdentities: (state: WritableDraft<ITabsState>, action: {
-payload: ObjRefMap<IdentityMapping>;
+readonly setParameterRuntimeValues: (state: WritableDraft<ITabsState>, action: {
+payload: ISetParameterRuntimeValuesPayload;
 type: string;
 }) => void | ITabsState | WritableDraft<ITabsState>;
-readonly updateWidgetIdentitiesForTab: (state: WritableDraft<ITabsState>, action: {
-payload: {
-tabId: string;
-mapping: ObjRefMap<IdentityMapping>;
-};
+readonly setParameterWorkingValue: (state: WritableDraft<ITabsState>, action: {
+payload: ISetParameterWorkingValuePayload;
 type: string;
 }) => void | ITabsState | WritableDraft<ITabsState>;
-readonly removeIgnoredAttributeFilter: (state: WritableDraft<ITabsState>, action: {
-payload: {
-displayFormRefs: ObjRef[];
-};
+readonly removeParameter: (state: WritableDraft<ITabsState>, action: {
+payload: IRemoveParameterPayload;
 type: string;
 }) => void | ITabsState | WritableDraft<ITabsState>;
-readonly removeIgnoredDateFilter: (state: WritableDraft<ITabsState>, action: {
+readonly setTabs: TabsReducer<    {
 payload: {
-dateDataSets: ObjRef[];
+tabs?: ITabState[] | undefined;
+activeTabLocalIdentifier?: string | undefined;
 };
 type: string;
-}) => void | ITabsState | WritableDraft<ITabsState>;
-readonly removeIgnoredMeasureValueFilter: (state: WritableDraft<ITabsState>, action: {
-payload: {
+}>;
+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 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 setLayout: (state: WritableDraft<ITabsState>, action: {
+payload: IDashboardLayout<ExtendedDashboardWidget>;
+type: string;
+}) => void | ITabsState | WritableDraft<ITabsState>;
+readonly setScreen: (state: WritableDraft<ITabsState>, action: {
+payload: {
+screen: ScreenSize;
+};
+type: string;
+}) => void | ITabsState | WritableDraft<ITabsState>;
+readonly updateWidgetIdentities: (state: WritableDraft<ITabsState>, action: {
+payload: ObjRefMap<IdentityMapping>;
+type: string;
+}) => void | ITabsState | WritableDraft<ITabsState>;
+readonly updateWidgetIdentitiesForTab: (state: WritableDraft<ITabsState>, action: {
+payload: {
+tabId: string;
+mapping: ObjRefMap<IdentityMapping>;
+};
+type: string;
+}) => void | ITabsState | WritableDraft<ITabsState>;
+readonly removeIgnoredAttributeFilter: (state: WritableDraft<ITabsState>, action: {
+payload: {
+displayFormRefs: ObjRef[];
+};
+type: string;
+}) => void | ITabsState | WritableDraft<ITabsState>;
+readonly removeIgnoredDateFilter: (state: WritableDraft<ITabsState>, action: {
+payload: {
+dateDataSets: ObjRef[];
+};
+type: string;
+}) => void | ITabsState | WritableDraft<ITabsState>;
+readonly removeIgnoredMeasureValueFilter: (state: WritableDraft<ITabsState>, action: {
+payload: {
 measureRefs: ObjRef[];
 };
 type: string;
@@ -28671,22 +30001,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 +30310,72 @@ 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;
+
 /**
  * Reads the alerting create/edit dialog context.
  *
@@ -29010,6 +30390,42 @@ 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 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 recipients region with.
+ *
+ * Throws outside the alerting dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useAlertingDialogRecipientsProps(): IAutomationDialogRecipientsProps;
+
 /**
  * Reads the alerting management dialog context.
  *
@@ -29024,6 +30440,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 +31445,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 +31479,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 +31538,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
  */