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

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

@@ -25,9 +25,13 @@ 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 { dashboardAttributeFilterItemToAttributeFilter } from '@gooddata/sdk-model';
 import { DashboardAttributeFilterSelectionMode } from '@gooddata/sdk-model';
 import { DashboardAttributeFilterSelectionType } from '@gooddata/sdk-model';
+import { dashboardAttributeFilterToAttributeFilter } from '@gooddata/sdk-model';
 import { DashboardDateFilterConfigMode } from '@gooddata/sdk-model';
+import { dashboardDateFilterToDateFilterByDateDataSet } from '@gooddata/sdk-model';
+import { dashboardDateFilterToDateFilterByWidget } from '@gooddata/sdk-model';
 import { DashboardFiltersApplyMode } from '@gooddata/sdk-model';
 import { DashboardParameterMode } from '@gooddata/sdk-model';
 import { DashboardSummaryWorkflowStatus } from '@gooddata/sdk-backend-spi';
@@ -46,10 +50,14 @@ import { EntityState } from '@reduxjs/toolkit';
 import { ExecutionResultLimitType } from '@gooddata/sdk-model';
 import { ExplicitDrill } from '@gooddata/sdk-ui';
 import { FilterContextItem } from '@gooddata/sdk-model';
+import { filterContextItemsToDashboardFiltersByDateDataSet } from '@gooddata/sdk-model';
+import { filterContextItemsToDashboardFiltersByRichTextWidget } from '@gooddata/sdk-model';
+import { filterContextItemsToDashboardFiltersByWidget } from '@gooddata/sdk-model';
+import { filterContextToDashboardFiltersByDateDataSet } from '@gooddata/sdk-model';
+import { filterContextToDashboardFiltersByWidget } from '@gooddata/sdk-model';
 import { FocusEvent as FocusEvent_2 } from 'react';
 import { ForwardRefExoticComponent } from 'react';
 import { GoodDataSdkError } from '@gooddata/sdk-ui';
-import { IAbsoluteDateFilter } from '@gooddata/sdk-model';
 import { IAccessControlAware } from '@gooddata/sdk-model';
 import { IAccessGrantee } from '@gooddata/sdk-model';
 import { IActiveCalendars } from '@gooddata/sdk-model';
@@ -61,7 +69,6 @@ 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';
@@ -100,6 +107,7 @@ import { IDashboardDefinition } from '@gooddata/sdk-model';
 import { IDashboardExportParameter } from '@gooddata/sdk-model';
 import { IDashboardExportPresentationOptions } from '@gooddata/sdk-backend-spi';
 import { IDashboardExportRawOptions } from '@gooddata/sdk-backend-spi';
+import { IDashboardFilter as IDashboardFilter_2 } from '@gooddata/sdk-model';
 import { IDashboardFilterGroup } from '@gooddata/sdk-model';
 import { IDashboardFilterGroupsConfig } from '@gooddata/sdk-model';
 import { IDashboardFilterReference } from '@gooddata/sdk-model';
@@ -146,10 +154,9 @@ import { IExecutionResult } from '@gooddata/sdk-backend-spi';
 import { IExecutionResultLimitBreak } from '@gooddata/sdk-model';
 import { IExportDefinitionVisualizationObjectSettings } from '@gooddata/sdk-model';
 import { IExportResult } from '@gooddata/sdk-backend-spi';
-import type { IExportTemplate } from '@gooddata/sdk-model';
+import { IExportTemplate } from '@gooddata/sdk-model';
 import { IFilter } from '@gooddata/sdk-model';
 import { IFilterableWidget } from '@gooddata/sdk-model';
-import { IFilterContext } from '@gooddata/sdk-model';
 import { IFilterContextDefinition } from '@gooddata/sdk-model';
 import { IHeaderPredicate } from '@gooddata/sdk-ui';
 import { IInsight } from '@gooddata/sdk-model';
@@ -170,13 +177,11 @@ import { IListedDashboard } from '@gooddata/sdk-model';
 import { ILoadingProps } from '@gooddata/sdk-ui';
 import { ILocale } from '@gooddata/sdk-ui';
 import { ILowerBoundedFilter } from '@gooddata/sdk-model';
-import { IMatchAttributeFilter } from '@gooddata/sdk-model';
 import { IMeasure } from '@gooddata/sdk-model';
 import { IMeasureDescriptor } from '@gooddata/sdk-model';
 import { IMeasureMetadataObject } from '@gooddata/sdk-model';
 import { IMeasureValueFilter } from '@gooddata/sdk-model';
 import { IMeasureValueFilterProps } from '@gooddata/sdk-ui-filters';
-import { INegativeAttributeFilter } from '@gooddata/sdk-model';
 import { INotificationChannelIdentifier } from '@gooddata/sdk-model';
 import { INotificationChannelMetadataObject } from '@gooddata/sdk-model';
 import { INotificationChannelMetadataObjectBase } from '@gooddata/sdk-model';
@@ -185,13 +190,12 @@ import { InsightDrillDefinition } from '@gooddata/sdk-model';
 import { IntlShape } from 'react-intl';
 import { IParameterDefinition } from '@gooddata/sdk-model';
 import { IParameterMetadataObject } from '@gooddata/sdk-model';
-import { IPositiveAttributeFilter } from '@gooddata/sdk-model';
 import { IPushData } from '@gooddata/sdk-ui';
 import { IRawExportCustomOverrides } from '@gooddata/sdk-backend-spi';
-import { IRelativeDateFilter } from '@gooddata/sdk-model';
 import { IRenderListItemProps } from '@gooddata/sdk-ui-kit';
 import { IResultWarning } from '@gooddata/sdk-model';
 import { IRichTextWidget } from '@gooddata/sdk-model';
+import { isDashboardFilter as isDashboardFilter_2 } from '@gooddata/sdk-model';
 import { ISeparators } from '@gooddata/sdk-model';
 import { ISettings } from '@gooddata/sdk-model';
 import { IShareDialogInteractionData } from '@gooddata/sdk-ui-kit';
@@ -199,7 +203,6 @@ import { ISharedObject } from '@gooddata/sdk-ui-kit';
 import { ISharingApplyPayload as ISharingApplyPayload_2 } from '@gooddata/sdk-ui-kit';
 import { ISlotProps } from '@gooddata/sdk-ui-kit';
 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';
@@ -212,6 +215,7 @@ import { IVisualizationSwitcherWidget } from '@gooddata/sdk-model';
 import { IWidget } from '@gooddata/sdk-model';
 import { IWidgetDefinition } from '@gooddata/sdk-model';
 import { IWorkspacePermissions } from '@gooddata/sdk-model';
+import { IWorkspaceUser } from '@gooddata/sdk-model';
 import { JSX } from 'react/jsx-runtime';
 import { KeyboardEvent as KeyboardEvent_2 } from 'react';
 import { LocalIdRef } from '@gooddata/sdk-model';
@@ -671,6 +675,14 @@ export declare function AlertingDialogDestination(overrides: Partial<IAutomation
  */
 export declare function AlertingDialogFilters(overrides: Partial<IAlertingDialogFiltersProps>): JSX.Element;
 
+/**
+ * A heading with a column of field rows under it — the default alerting dialog's "When" (the condition
+ * fields) and "Do" (the action fields) groups. Layout only; reads no dialog context.
+ *
+ * @alpha
+ */
+export declare function AlertingDialogFormFieldGroup({ label, children }: IAlertingDialogFormFieldGroupProps): ReactElement;
+
 /**
  * The alerting dialog's granularity field (the period anomaly detection evaluates over), connected
  * to the dialog's state and rendered as a labelled form row.
@@ -772,6 +784,53 @@ export declare function AlertingDialogRecipients(overrides: Partial<IAutomationD
  */
 export declare function AlertingDialogSensitivity(overrides: Partial<IAlertingDialogSensitivityProps>): ReactElement;
 
+/**
+ * The alerting dialog's chrome, connected to the dialog's state: the modal overlay, the dialog frame
+ * with the header row (the title input) and the action bar, the scrollable content area around
+ * `children`, the dialog's warning and validation messages, the stale-filters confirmation step shown
+ * before the dialog when the saved filters no longer match the dashboard, and the delete confirmation
+ * reached from the action bar in edit mode. While `useAlertingDialogContext().isLoading` is true it
+ * renders the loading skeleton and none of its children.
+ *
+ * The default dialog is `<AlertingDialogShell>` around the region and field blocks; a custom
+ * `AlertingDialogComponent` that keeps this chrome and arranges the blocks differently renders the shell
+ * itself. The shell does not own the submit: call {@link useAlertSubmit} and pass its `submit` and
+ * `isSaving`, so the footer button and any Enter handler in the body share one instance. Call that hook
+ * only once `useAlertingDialogContext().isLoading` is false — the state hooks throw while the dialog
+ * loads — and render the shell alone (any `onSubmit`, `isSaving: false`) until then, as the example does.
+ *
+ * Needs an ambient `IntlProvider`; inside a `Dashboard` the dashboard's provider covers it.
+ *
+ * @example
+ * ```tsx
+ * function MyAlertingDialog(props: IAlertingDialogProps) {
+ *     const { isLoading } = useAlertingDialogContext();
+ *     // the state hooks throw while the dialog loads; the shell renders the loading skeleton
+ *     if (isLoading) {
+ *         return <AlertingDialogShell {...props} onSubmit={() => {}} isSaving={false} />;
+ *     }
+ *     return <MyAlertingDialogBody {...props} />;
+ * }
+ *
+ * function MyAlertingDialogBody(props: IAlertingDialogProps) {
+ *     const { isSaving, submit } = useAlertSubmit(props);
+ *     return (
+ *         <AlertingDialogShell {...props} onSubmit={() => void submit()} isSaving={isSaving}>
+ *             <AlertingDialogFormFieldGroup label="When">
+ *                 <AlertingDialogMeasure />
+ *                 <AlertingDialogComparisonOperator />
+ *                 <AlertingDialogThreshold />
+ *             </AlertingDialogFormFieldGroup>
+ *             <AlertingDialogRecipients />
+ *         </AlertingDialogShell>
+ *     );
+ * }
+ * ```
+ *
+ * @alpha
+ */
+export declare function AlertingDialogShell(props: IAlertingDialogShellProps): ReactElement;
+
 /**
  * The alerting dialog's threshold field (the value a fixed-threshold, change or difference
  * condition is compared against), connected to the dialog's state and rendered as a labelled form
@@ -823,10 +882,26 @@ export declare function AlertingDialogTriggerMode(overrides: Partial<IAlertingDi
 export declare type AlertingDisabledReason = "noDestinations" | "oldWidget" | "disabledOnInsight";
 
 /**
+ * Resolves the management dialog component from DashboardComponentsContext and mounts it inside
+ * the resolved context decorator — so a decorated management context is what the dialog (default
+ * or replacement) reads.
+ *
  * @internal
  */
 export declare function AlertingManagementDialog(props: IAlertingManagementDialogProps): ReactElement;
 
+/**
+ * Provides the alerting management dialog context.
+ *
+ * The dashboard's connector mounts the original value. Exported so a context-decorator
+ * component (`CustomAlertingManagementDialogContextDecoratorComponent`) can re-provide a decorated
+ * value read from `useAlertingManagementDialogContext()`; it is not a way to run the management
+ * dialog outside a dashboard.
+ *
+ * @alpha
+ */
+export declare const AlertingManagementDialogContextProvider: Provider<IAlertingManagementDialogContextValue | undefined>;
+
 /**
  * A measure of the insight the alerting dialog can build a condition on, with the comparisons
  * available for it.
@@ -933,7 +1008,7 @@ export declare function anyEventHandler(handler: DashboardEventHandler["handler"
  * The {@link ChangeAttributeFilterSelectionPayload}'s `selectionType` and `elements` are derived from the
  * provided attribute filter.
  *
- * To convert {@link IDashboardFilter} to {@link @gooddata/sdk-model#IFilter} use {@link dashboardAttributeFilterToAttributeFilter}.
+ * To convert {@link IDashboardFilter} to {@link @gooddata/sdk-model#IFilter} use {@link @gooddata/sdk-model#dashboardAttributeFilterToAttributeFilter}.
  * Converted filter can be used within the command's payload.
  *
  * @param filterLocalId - dashboard attribute filter's local id
@@ -1116,6 +1191,18 @@ export declare type AutomationInteractionPayload = IUserInteractionPayloadWithDa
  */
 export declare type AutomationInteractionType = "scheduledExportInitialized" | "scheduledExportCreated" | "alertInitialized" | "alertCreated";
 
+/**
+ * Provides the automation dialogs' shared context.
+ *
+ * The dashboard's connectors mount the original value once per tree. Exported so a
+ * context-decorator component (`CustomAutomationsContextDecoratorComponent`) can re-provide a
+ * decorated value read from `useAutomationsContext()`; it is not a way to run the dialogs outside
+ * a dashboard.
+ *
+ * @alpha
+ */
+export declare const AutomationsContextProvider: Provider<IAutomationsContextValue | undefined>;
+
 /**
  * @public
  */
@@ -2210,6 +2297,12 @@ export declare type CustomAlertingDialogComponent = ComponentType<IAlertingDialo
  * false, and a decorator that overrides it corrupts the draft seed. Define the decorator
  * outside render, or the dialog remounts (and reseeds) on every parent render.
  *
+ * The contract: change the data, not what it means — every member keeps its documented meaning.
+ * The dialog does not check the decorated value; when you override a member, everything that
+ * reads it is your responsibility. Spread the value you read (`{ ...ctx, member }`) so the other
+ * members pass through. Wrap functions instead of replacing them. Do not touch members marked as
+ * internal machinery.
+ *
  * @alpha
  */
 export declare type CustomAlertingDialogContextDecoratorComponent = ComponentType<{
@@ -2221,6 +2314,106 @@ export declare type CustomAlertingDialogContextDecoratorComponent = ComponentTyp
  */
 export declare type CustomAlertingManagementDialogComponent = ComponentType<IAlertingManagementDialogProps>;
 
+/**
+ * Decorates the data the alerting management dialog reads.
+ *
+ * The dashboard mounts this component between the connector-provided management dialog context and
+ * the resolved management dialog component (default or replacement), so the value it re-provides is
+ * what the dialog reads. Read the current value with `useAlertingManagementDialogContext()`,
+ * decorate the members to adjust, and re-provide via `AlertingManagementDialogContextProvider`:
+ *
+ * @example
+ * ```tsx
+ * function AlertsListDecorator({ children }: { children?: ReactNode }) {
+ *     const ctx = useAlertingManagementDialogContext();
+ *     const { alerts, loading } = useMySelfFetchedAlerts(ctx.automations);
+ *     const decorated = useMemo(
+ *         () => ({ ...ctx, automations: alerts, isLoading: ctx.isLoading || loading }),
+ *         [ctx, alerts, loading],
+ *     );
+ *     return (
+ *         <AlertingManagementDialogContextProvider value={decorated}>
+ *             {children}
+ *         </AlertingManagementDialogContextProvider>
+ *     );
+ * }
+ * // <Dashboard AlertingManagementDialogContextDecoratorComponent={AlertsListDecorator} />
+ * ```
+ *
+ * The management dialog has no state seeding — it renders from the context on every change, so a
+ * decorator may replace `automations` or extend `isLoading` (as above). Extend `isLoading` only
+ * as `ctx.isLoading || yourOwnLoading`, never force it: forced false shows the list before its
+ * data arrives, forced true hides it forever. `isLoading` here covers the automations load only —
+ * deliberately narrower than the scheduled-email management context's flag. Define the decorator
+ * outside render, or the dialog remounts on every parent render.
+ *
+ * The contract: change the data, not what it means — every member keeps its documented meaning.
+ * The dialog does not check the decorated value; when you override a member, everything that
+ * reads it is your responsibility. Spread the value you read (`{ ...ctx, member }`) so the other
+ * members pass through. Wrap functions instead of replacing them. Do not touch members marked as
+ * internal machinery.
+ *
+ * @alpha
+ */
+export declare type CustomAlertingManagementDialogContextDecoratorComponent = ComponentType<{
+    children?: ReactNode;
+}>;
+
+/**
+ * Decorates the data the automation dialogs' shared context carries.
+ *
+ * The dashboard mounts this component directly inside each connector-provided automations context
+ * — once in the alerting tree and once in the scheduled-email tree — so the value it re-provides
+ * is what everything in both trees reads: the default dialogs, wholesale replacements, exported
+ * blocks and hooks, and the dialogs' state seeding. A decorator must therefore be tree-agnostic.
+ * Read the current value with `useAutomationsContext()`, decorate the members to adjust, and
+ * re-provide via `AutomationsContextProvider`:
+ *
+ * @example
+ * ```tsx
+ * function GranularityDecorator({ children }: { children?: ReactNode }) {
+ *     const ctx = useAutomationsContext();
+ *     const decorated = useMemo(
+ *         () => ({
+ *             ...ctx,
+ *             dateFilterConfig: {
+ *                 ...ctx.dateFilterConfig,
+ *                 availableGranularities: ctx.dateFilterConfig.availableGranularities.filter(
+ *                     (g) => g !== "GDC.time.hour",
+ *                 ),
+ *                 getGranularitiesForTab: (tabId: string) =>
+ *                     ctx.dateFilterConfig
+ *                         .getGranularitiesForTab(tabId)
+ *                         .filter((g) => g !== "GDC.time.hour"),
+ *             },
+ *         }),
+ *         [ctx],
+ *     );
+ *     return <AutomationsContextProvider value={decorated}>{children}</AutomationsContextProvider>;
+ * }
+ * // <Dashboard AutomationsContextDecoratorComponent={GranularityDecorator} />
+ * ```
+ *
+ * To constrain the date-filter granularities the dialogs offer, override
+ * `dateFilterConfig.availableGranularities` and `dateFilterConfig.getGranularitiesForTab`
+ * together, as above — the date filter falls back per tab. Components that build this context
+ * themselves (the standalone connected dialogs, the widget-panel alerts list) are not decorated.
+ * Define the decorator outside render, or both dialog trees remount on every parent render.
+ * Both instances mount with the dashboard, not only while a dialog is open — a decorator that
+ * fetches data runs on every dashboard.
+ *
+ * The contract: change the data, not what it means — every member keeps its documented meaning.
+ * The dialog does not check the decorated value; when you override a member, everything that
+ * reads it is your responsibility. Spread the value you read (`{ ...ctx, member }`) so the other
+ * members pass through. Wrap functions instead of replacing them. Do not touch members marked as
+ * internal machinery.
+ *
+ * @alpha
+ */
+export declare type CustomAutomationsContextDecoratorComponent = ComponentType<{
+    children?: ReactNode;
+}>;
+
 /**
  * @beta
  */
@@ -2454,6 +2647,12 @@ export declare type CustomScheduledEmailDialogComponent = ComponentType<ISchedul
  * corrupts the draft seed on every such open, not in an edge case. Define the decorator outside
  * render, or the dialog remounts (and reseeds) on every parent render.
  *
+ * The contract: change the data, not what it means — every member keeps its documented meaning.
+ * The dialog does not check the decorated value; when you override a member, everything that
+ * reads it is your responsibility. Spread the value you read (`{ ...ctx, member }`) so the other
+ * members pass through. Wrap functions instead of replacing them. Do not touch members marked as
+ * internal machinery.
+ *
  * @alpha
  */
 export declare type CustomScheduledEmailDialogContextDecoratorComponent = ComponentType<{
@@ -2465,6 +2664,53 @@ export declare type CustomScheduledEmailDialogContextDecoratorComponent = Compon
  */
 export declare type CustomScheduledEmailManagementDialogComponent = ComponentType<IScheduledEmailManagementDialogProps>;
 
+/**
+ * Decorates the data the scheduled email management dialog reads.
+ *
+ * The dashboard mounts this component between the connector-provided management dialog context and
+ * the resolved management dialog component (default or replacement), so the value it re-provides is
+ * what the dialog reads. Read the current value with `useScheduledEmailManagementDialogContext()`,
+ * decorate the members to adjust, and re-provide via
+ * `ScheduledEmailManagementDialogContextProvider`:
+ *
+ * @example
+ * ```tsx
+ * function SchedulesListDecorator({ children }: { children?: ReactNode }) {
+ *     const ctx = useScheduledEmailManagementDialogContext();
+ *     const { schedules, loading } = useMySelfFetchedSchedules(ctx.automations);
+ *     const decorated = useMemo(
+ *         () => ({ ...ctx, automations: schedules, isLoading: ctx.isLoading || loading }),
+ *         [ctx, schedules, loading],
+ *     );
+ *     return (
+ *         <ScheduledEmailManagementDialogContextProvider value={decorated}>
+ *             {children}
+ *         </ScheduledEmailManagementDialogContextProvider>
+ *     );
+ * }
+ * // <Dashboard ScheduledEmailManagementDialogContextDecoratorComponent={SchedulesListDecorator} />
+ * ```
+ *
+ * The management dialog has no state seeding — it renders from the context on every change, so a
+ * decorator may replace `automations` or extend `isLoading` (as above). Extend `isLoading` only
+ * as `ctx.isLoading || yourOwnLoading`, never force it: forced false shows the list before its
+ * data arrives, forced true hides it forever. `isLoading` here may also cover a widget-filters
+ * load while a widget-scoped create/edit dialog is open — deliberately broader than the alerting
+ * management context's automations-only flag. Define the decorator outside render, or the dialog
+ * remounts on every parent render.
+ *
+ * The contract: change the data, not what it means — every member keeps its documented meaning.
+ * The dialog does not check the decorated value; when you override a member, everything that
+ * reads it is your responsibility. Spread the value you read (`{ ...ctx, member }`) so the other
+ * members pass through. Wrap functions instead of replacing them. Do not touch members marked as
+ * internal machinery.
+ *
+ * @alpha
+ */
+export declare type CustomScheduledEmailManagementDialogContextDecoratorComponent = ComponentType<{
+    children?: ReactNode;
+}>;
+
 /**
  * @beta
  */
@@ -2619,24 +2865,14 @@ export declare type DashboardAttributeFilterItemSelectionReplacedPayload = {
     readonly filter: DashboardAttributeFilterItem;
 };
 
-/**
- * Converts any {@link @gooddata/sdk-model#DashboardAttributeFilterItem} to {@link @gooddata/sdk-model#IAttributeFilter} instance.
- *
- * @remarks
- * Handles all attribute filter types: element-based (positive/negative selection),
- * arbitrary value filters, and match (text) filters.
- *
- * @param filter - dashboard attribute filter item to convert
- * @public
- */
-export declare function dashboardAttributeFilterItemToAttributeFilter(filter: DashboardAttributeFilterItem): IAttributeFilter;
+export { dashboardAttributeFilterItemToAttributeFilter }
 
 /**
  * This event is emitted after new elements are selected and applied in an attribute filter.
  *
  * @remarks
  *
- * See also {@link dashboardAttributeFilterToAttributeFilter} convertor – this allows you to convert the `filter`
+ * See also {@link @gooddata/sdk-model#dashboardAttributeFilterToAttributeFilter} convertor – this allows you to convert the `filter`
  * in the event payload to an {@link @gooddata/sdk-model#IAttributeFilter} instance you can use with visualizations,
  * filter UI components and so on.
  *
@@ -2652,7 +2888,7 @@ export declare type DashboardAttributeFilterSelectionChanged = IDashboardEvent &
  *
  * @remarks
  *
- * See also {@link dashboardAttributeFilterToAttributeFilter} convertor – this allows you to convert the `filter`
+ * See also {@link @gooddata/sdk-model#dashboardAttributeFilterToAttributeFilter} convertor – this allows you to convert the `filter`
  * object to an {@link @gooddata/sdk-model#IAttributeFilter} instance you can use with visualizations,
  * filter UI components and so on.
  *
@@ -2667,15 +2903,7 @@ export declare type DashboardAttributeFilterSelectionChangedPayload = {
     readonly filter: IDashboardAttributeFilter;
 };
 
-/**
- * Converts {@link @gooddata/sdk-backend-spi#IDashboardAttributeFilter} to {@link @gooddata/sdk-model#IAttributeFilter} instance.
- *
- * @param filter - filter context attribute filter to convert
- * @deprecated Use {@link dashboardAttributeFilterItemToAttributeFilter} instead,
- * which supports all attribute filter types including text filters.
- * @public
- */
-export declare function dashboardAttributeFilterToAttributeFilter(filter: IDashboardAttributeFilter): IAttributeFilter;
+export { dashboardAttributeFilterToAttributeFilter }
 
 /**
  * Union type that contains all available built-in dashboard commands.
@@ -3121,7 +3349,7 @@ export declare type DashboardCopySavedPayload = {
  *
  * @remarks
  *
- * See also {@link dashboardDateFilterToDateFilterByWidget} and {@link dashboardDateFilterToDateFilterByDateDataSet} convertors
+ * See also {@link @gooddata/sdk-model#dashboardDateFilterToDateFilterByWidget} and {@link @gooddata/sdk-model#dashboardDateFilterToDateFilterByDateDataSet} convertors
  * – those allow you to convert the `filter` in the event payload to an {@link @gooddata/sdk-model#IDateFilter} instance you can use
  * with visualizations, filter UI components and so on.
  *
@@ -3137,7 +3365,7 @@ export declare type DashboardDateFilterSelectionChanged = IDashboardEvent & {
  *
  * @remarks
  *
- * See also {@link dashboardDateFilterToDateFilterByWidget} and {@link dashboardDateFilterToDateFilterByDateDataSet} convertors
+ * See also {@link @gooddata/sdk-model#dashboardDateFilterToDateFilterByWidget} and {@link @gooddata/sdk-model#dashboardDateFilterToDateFilterByDateDataSet} convertors
  * – those allow you to convert the `filter` object to an {@link @gooddata/sdk-model#IDateFilter} instance you can use
  * with visualizations, filter UI components and so on.
  *
@@ -3154,23 +3382,9 @@ export declare type DashboardDateFilterSelectionChangedPayload = {
     readonly dateFilterOptionLocalId?: string;
 };
 
-/**
- * Converts {@link @gooddata/sdk-backend-spi#IDashboardDateFilter} to {@link @gooddata/sdk-model#IDateFilter} instance.
- *
- * @param filter - filter context attribute filter to convert
- * @param dateDataSet - date data set to define {@link @gooddata/sdk-model#IDateFilter}
- * @public
- */
-export declare function dashboardDateFilterToDateFilterByDateDataSet(filter: IDashboardDateFilter, dateDataSet: ObjRef): IDateFilter;
+export { dashboardDateFilterToDateFilterByDateDataSet }
 
-/**
- * Converts {@link @gooddata/sdk-backend-spi#IDashboardDateFilter} to {@link @gooddata/sdk-model#IDateFilter} instance.
- *
- * @param filter - filter context attribute filter to convert
- * @param widget - widget to use to get dateDataSet for date filters
- * @public
- */
-export declare function dashboardDateFilterToDateFilterByWidget(filter: IDashboardDateFilter, widget?: Partial<IFilterableWidget>): IDateFilter;
+export { dashboardDateFilterToDateFilterByWidget }
 
 /**
  * This event is emitted when a dashboard is deinitialized. The event contains contextual information such as
@@ -3319,7 +3533,7 @@ export declare type DashboardEventType = "GDC.DASH/EVT.COMMAND.FAILED" | "GDC.DA
  * This event is emitted as convenience - more granular events describe all the possible
  * changes to the dashboard filters and can be used to even source the state of filter context.
  *
- * See also {@link filterContextToDashboardFiltersByWidget} and {@link filterContextToDashboardFiltersByDateDataSet} convertors
+ * See also {@link @gooddata/sdk-model#filterContextToDashboardFiltersByWidget} and {@link @gooddata/sdk-model#filterContextToDashboardFiltersByDateDataSet} convertors
  * – those allow you to convert the `filterContext` in the event payload to array of {@link @gooddata/sdk-model#IFilter} instances you can use
  * with visualizations, filter UI components and so on.
  *
@@ -3335,7 +3549,7 @@ export declare type DashboardFilterContextChanged = IDashboardEvent & {
  *
  * @remarks
  *
- * See also {@link filterContextToDashboardFiltersByWidget} and {@link filterContextToDashboardFiltersByDateDataSet} convertors
+ * See also {@link @gooddata/sdk-model#filterContextToDashboardFiltersByWidget} and {@link @gooddata/sdk-model#filterContextToDashboardFiltersByDateDataSet} convertors
  * – those allow you to convert the `filterContext` object to array of {@link @gooddata/sdk-model#IFilter} instances you can use
  * with visualizations, filter UI components and so on.
  *
@@ -4335,27 +4549,27 @@ export declare const DEFAULT_TAB_ID = "defaultTabId";
  * that is what lets a wholesale replacement receive the same contexts. Rendering this component
  * outside those providers throws at runtime.
  *
- * The dialog is composed from the exported region renders — {@link DefaultAlertingDialogHeader},
- * {@link DefaultAlertingDialogFilters}, {@link DefaultAlertingDialogDestination},
- * {@link DefaultAlertingDialogRecipients}, {@link DefaultAutomationDialogActionBar} — fed by the
- * matching `use*Props` hooks ({@link useAlertingDialogFiltersProps} and siblings), and from the
- * connected field blocks — {@link AlertingDialogMeasure}, {@link AlertingDialogAttribute},
- * {@link AlertingDialogComparisonOperator}, {@link AlertingDialogThreshold},
- * {@link AlertingDialogComparisonPeriod}, {@link AlertingDialogSensitivity},
- * {@link AlertingDialogGranularity}, {@link AlertingDialogTriggerMode},
- * {@link AlertingDialogTriggerInterval} — each a labelled {@link AutomationDialogFormField} row; the
- * conditional ones (Attribute, Threshold, ComparisonPeriod, Sensitivity, Granularity, TriggerInterval)
- * gate themselves on the draft. A custom `AlertingDialogComponent` that keeps our regions and fields
- * but owns the markup places the connected blocks ({@link AlertingDialogFilters},
- * {@link AlertingDialogThreshold} and siblings) instead of this component, and reads or writes the
- * same draft through {@link useAlertDraft} and {@link useAlertActions}.
+ * The dialog is {@link AlertingDialogShell} — the chrome: overlay, frame, header row, action bar, the
+ * dialog's messages, the stale-filters and delete confirmation steps, the loading skeleton — around the
+ * exported region renders ({@link DefaultAlertingDialogFilters}, {@link DefaultAlertingDialogDestination},
+ * {@link DefaultAlertingDialogRecipients}, fed by {@link useAlertingDialogFiltersProps} and siblings; the
+ * header and action bar are the shell's) and the connected field blocks — {@link AlertingDialogMeasure},
+ * {@link AlertingDialogAttribute}, {@link AlertingDialogComparisonOperator}, {@link AlertingDialogThreshold},
+ * {@link AlertingDialogComparisonPeriod}, {@link AlertingDialogSensitivity}, {@link AlertingDialogGranularity},
+ * {@link AlertingDialogTriggerMode}, {@link AlertingDialogTriggerInterval} — grouped under the "When" and
+ * "Do" headings by {@link AlertingDialogFormFieldGroup}; each field is a labelled
+ * {@link AutomationDialogFormField} row and the conditional ones gate themselves on the draft. A custom
+ * `AlertingDialogComponent` that keeps this chrome but owns the arrangement renders
+ * {@link AlertingDialogShell} around the blocks it wants (see its example); one that owns the chrome too
+ * places the blocks in its own markup and reads or writes the same draft through {@link useAlertDraft} and
+ * {@link useAlertActions}.
  *
  * Slots render only in the fully rendered dialog: not while the dialog context reports loading,
  * and not while the stale-filters confirmation step is shown.
  *
  * @alpha
  */
-export declare function DefaultAlertingDialog(props: IDefaultAlertingDialogProps): JSX.Element;
+export declare function DefaultAlertingDialog(props: IDefaultAlertingDialogProps): ReactElement;
 
 /**
  * Default render of the alerting dialog's attribute field: the dropdown slicing the condition by an
@@ -4757,14 +4971,19 @@ export declare function DefaultSaveButton({ isVisible, isEnabled, isSaving, butt
  * that is what lets a wholesale replacement receive the same contexts. Rendering this component
  * outside those providers throws at runtime.
  *
- * The dialog is composed from the exported region renders — {@link DefaultScheduledEmailDialogHeader},
- * {@link DefaultScheduledEmailDialogFilters}, {@link DefaultScheduledEmailDialogDestination},
- * {@link DefaultScheduledEmailDialogRecipients}, {@link DefaultScheduledEmailDialogTimezone},
- * {@link DefaultAutomationDialogActionBar} — fed by the matching `use*Props` hooks
- * ({@link useScheduledEmailDialogFiltersProps} and siblings). A custom `ScheduledEmailDialogComponent`
- * that keeps our regions but owns the markup places the connected blocks
- * ({@link ScheduledEmailDialogFilters} and siblings) instead of this component, and reads or writes
- * the same draft through {@link useScheduledExportDraft} and {@link useScheduledExportActions}.
+ * The dialog is {@link ScheduledEmailDialogShell} — the chrome: overlay, frame, header row, action bar, the
+ * General/Filters tabs, the body's messages, the stale-filters and delete confirmation steps, the loading
+ * skeleton — around the exported region renders ({@link DefaultScheduledEmailDialogDestination},
+ * {@link DefaultScheduledEmailDialogRecipients}, {@link DefaultScheduledEmailDialogTimezone}, fed by
+ * {@link useScheduledEmailDialogDestinationProps} and siblings; the header, action bar and the Filters tab's
+ * {@link DefaultScheduledEmailDialogFilters} are the shell's) and the General-tab field blocks
+ * ({@link ScheduledEmailDialogRecurrence}, {@link ScheduledEmailDialogSubject}, {@link ScheduledEmailDialogMessage},
+ * {@link ScheduledEmailDialogWidgetAttachments}, {@link ScheduledEmailDialogDashboardAttachments},
+ * {@link ScheduledEmailDialogEvaluationMode}). A custom `ScheduledEmailDialogComponent` that keeps this chrome
+ * but owns the arrangement renders {@link ScheduledEmailDialogShell} around the blocks it wants (see its
+ * example); one that owns the chrome too places the blocks ({@link ScheduledEmailDialogFilters} and
+ * siblings) in its own markup and reads or writes the same draft through {@link useScheduledExportDraft}
+ * and {@link useScheduledExportActions}.
  *
  * Slots render only in the fully rendered dialog: not while the dialog context reports loading,
  * and not while the stale-filters confirmation step is shown. The Filters slot additionally
@@ -4772,7 +4991,16 @@ export declare function DefaultSaveButton({ isVisible, isEnabled, isSaving, butt
  *
  * @alpha
  */
-export declare function DefaultScheduledEmailDialog(props: IDefaultScheduledEmailDialogProps): JSX.Element;
+export declare function DefaultScheduledEmailDialog(props: IDefaultScheduledEmailDialogProps): ReactElement;
+
+/**
+ * Default render of the scheduled-export dialog's dashboard-attachments field.
+ * Props-driven — reads no context. The default dialog and {@link ScheduledEmailDialogDashboardAttachments}
+ * render it with {@link useScheduledEmailDialogDashboardAttachmentsProps}.
+ *
+ * @alpha
+ */
+export declare function DefaultScheduledEmailDialogDashboardAttachments(props: IScheduledEmailDialogDashboardAttachmentsProps): ReactElement;
 
 /**
  * Default render of the scheduled-export dialog's destination region: the notification-channel
@@ -4784,6 +5012,15 @@ export declare function DefaultScheduledEmailDialog(props: IDefaultScheduledEmai
  */
 export declare function DefaultScheduledEmailDialogDestination({ notificationChannels, selectedNotificationChannelId, onChange }: IAutomationDialogDestinationProps): JSX.Element;
 
+/**
+ * Default render of the scheduled-export dialog's evaluation-mode field.
+ * Props-driven — reads no context. The default dialog and {@link ScheduledEmailDialogEvaluationMode}
+ * render it with {@link useScheduledEmailDialogEvaluationModeProps}.
+ *
+ * @alpha
+ */
+export declare function DefaultScheduledEmailDialogEvaluationMode(props: IScheduledEmailDialogEvaluationModeProps): ReactElement;
+
 /**
  * Default render of the scheduled-export dialog's filters region: the filter and parameter chips of
  * the Filters tab, flat or per dashboard tab. The title is hidden and the list always expanded
@@ -4805,6 +5042,15 @@ export declare function DefaultScheduledEmailDialogFilters(props: IScheduledEmai
  */
 export declare const DefaultScheduledEmailDialogHeader: ForwardRefExoticComponent<IScheduledEmailDialogHeaderProps & RefAttributes<HTMLInputElement>>;
 
+/**
+ * Default render of the scheduled-export dialog's message field.
+ * Props-driven — reads no context. The default dialog and {@link ScheduledEmailDialogMessage}
+ * render it with {@link useScheduledEmailDialogMessageProps}.
+ *
+ * @alpha
+ */
+export declare function DefaultScheduledEmailDialogMessage(props: IScheduledEmailDialogMessageProps): ReactElement;
+
 /**
  * Default render of the scheduled-export dialog's recipients region: the recipients select.
  * Props-driven — reads no context. The default dialog and {@link ScheduledEmailDialogRecipients}
@@ -4815,6 +5061,24 @@ export declare const DefaultScheduledEmailDialogHeader: ForwardRefExoticComponen
  */
 export declare function DefaultScheduledEmailDialogRecipients(props: IScheduledEmailDialogRecipientsProps): JSX.Element;
 
+/**
+ * Default render of the scheduled-export dialog's recurrence field: the recurrence form.
+ * Props-driven — reads no context. The default dialog and {@link ScheduledEmailDialogRecurrence}
+ * render it with {@link useScheduledEmailDialogRecurrenceProps}.
+ *
+ * @alpha
+ */
+export declare function DefaultScheduledEmailDialogRecurrence(props: IScheduledEmailDialogRecurrenceProps): ReactElement;
+
+/**
+ * Default render of the scheduled-export dialog's subject field.
+ * Props-driven — reads no context. The default dialog and {@link ScheduledEmailDialogSubject}
+ * render it with {@link useScheduledEmailDialogSubjectProps}.
+ *
+ * @alpha
+ */
+export declare function DefaultScheduledEmailDialogSubject(props: IScheduledEmailDialogSubjectProps): ReactElement;
+
 /**
  * The "Time zone" section of the scheduled-email dialog's General tab. Unlike the
  * dashboard-settings timezone picker, the dropdown offers no browser-detected option — the
@@ -4831,6 +5095,15 @@ export declare function DefaultScheduledEmailDialogRecipients(props: IScheduledE
  */
 export declare function DefaultScheduledEmailDialogTimezone({ isWidget, selection, defaultResolvedTimezone, onTimezoneChange }: IScheduledEmailDialogTimezoneProps): JSX.Element;
 
+/**
+ * Default render of the scheduled-export dialog's widget-attachments field.
+ * Props-driven — reads no context. The default dialog and {@link ScheduledEmailDialogWidgetAttachments}
+ * render it with {@link useScheduledEmailDialogWidgetAttachmentsProps}.
+ *
+ * @alpha
+ */
+export declare function DefaultScheduledEmailDialogWidgetAttachments(props: IScheduledEmailDialogWidgetAttachmentsProps): ReactElement;
+
 /**
  * @alpha
  */
@@ -5691,32 +5964,11 @@ export declare type FilterBarMeasureValueFilterIndexed = {
  */
 export declare type FilterBarRenderingMode = "default" | "hidden";
 
-/**
- * Gets {@link IDashboardFilter} items for filters specified as {@link @gooddata/sdk-backend-spi#FilterContextItem} instances.
- *
- * @param filterContextItems - filter context items to get filters for
- * @param dateDataSet - date data set to define {@link @gooddata/sdk-model#IDateFilter}
- * @public
- */
-export declare function filterContextItemsToDashboardFiltersByDateDataSet(filterContextItems: FilterContextItem[], dateDataSet: ObjRef): IDashboardFilter[];
+export { filterContextItemsToDashboardFiltersByDateDataSet }
 
-/**
- * Gets {@link IDashboardFilter} items for filters specified as {@link @gooddata/sdk-backend-spi#FilterContextItem} instances.
- *
- * @param filterContextItems - filter context items to get filters for
- * @param widget - widget to use to get dateDataSet for date filters
- * @public
- */
-export declare function filterContextItemsToDashboardFiltersByRichTextWidget(filterContextItems: FilterContextItem[], widget?: Partial<IFilterableWidget>): IDashboardFilter[];
+export { filterContextItemsToDashboardFiltersByRichTextWidget }
 
-/**
- * Gets {@link IDashboardFilter} items for filters specified as {@link @gooddata/sdk-backend-spi#FilterContextItem} instances.
- *
- * @param filterContextItems - filter context items to get filters for
- * @param widget - widget to use to get dateDataSet for date filters
- * @public
- */
-export declare function filterContextItemsToDashboardFiltersByWidget(filterContextItems: FilterContextItem[], widget?: Partial<IFilterableWidget>): IDashboardFilter[];
+export { filterContextItemsToDashboardFiltersByWidget }
 
 /**
  * @alpha
@@ -5795,24 +6047,9 @@ export declare type FilterContextState = {
     defaultFilterOverrides?: FilterContextItem[];
 };
 
-/**
- * Gets {@link IDashboardFilter} items for filters specified in given filterContext in relation to the
- * given dateDataSet.
- *
- * @param filterContext - filter context to get filters for
- * @param dateDataSet - widget to use to get dateDataSet for date filters
- * @public
- */
-export declare function filterContextToDashboardFiltersByDateDataSet(filterContext: IFilterContextDefinition | IFilterContext | ITempFilterContext | undefined, dateDataSet: ObjRef): IDashboardFilter[];
+export { filterContextToDashboardFiltersByDateDataSet }
 
-/**
- * Gets {@link IDashboardFilter} items for filters specified in given filterContext in relation to the given widget.
- *
- * @param filterContext - filter context to get filters for
- * @param widget - widget to use to get dateDataSet for date filters
- * @public
- */
-export declare function filterContextToDashboardFiltersByWidget(filterContext: IFilterContextDefinition | IFilterContext | ITempFilterContext | undefined, widget: IWidgetDefinition): IDashboardFilter[];
+export { filterContextToDashboardFiltersByWidget }
 
 /**
  * @alpha
@@ -6866,6 +7103,22 @@ export declare interface IAlertingDialogFiltersProps extends IAutomationDialogFi
     disableDateFilters: boolean;
 }
 
+/**
+ * Props of {@link AlertingDialogFormFieldGroup}.
+ *
+ * @alpha
+ */
+export declare interface IAlertingDialogFormFieldGroupProps {
+    /**
+     * The group heading in the label column — "When" (the condition) and "Do" (the action) in the default dialog.
+     */
+    label: ReactNode;
+    /**
+     * The field rows of the group — {@link AlertingDialogMeasure} and its siblings.
+     */
+    children: ReactNode;
+}
+
 /**
  * Props of the default alerting dialog's granularity field (anomaly detection).
  *
@@ -7055,6 +7308,51 @@ export declare interface IAlertingDialogSensitivityProps {
     closeOnParentScroll?: boolean;
 }
 
+/**
+ * Props of {@link AlertingDialogShell}.
+ *
+ * @alpha
+ */
+export declare interface IAlertingDialogShellProps extends Pick<IAlertingDialogProps, "onCancel" | "onDeleteSuccess" | "onDeleteError"> {
+    /**
+     * The dialog's single submit — `submit` of the caller's {@link useAlertSubmit} instance. Drives the
+     * footer's submit button and the Enter key on it. The shell does not own the submit hook, so a
+     * caller's own Enter handler or button can share the same instance. Create the hook instance only
+     * once the dialog context reports `isLoading: false`.
+     */
+    onSubmit: () => void;
+    /**
+     * `isSaving` of the same {@link useAlertSubmit} instance: disables submit and Delete and shows the
+     * footer's progress indicator.
+     */
+    isSaving: boolean;
+    /**
+     * Header and action-bar overrides — the Level 1 slot contract ({@link IAlertingDialogSlots.Header},
+     * {@link IAlertingDialogSlots.ActionBar}): each slot receives `{ Default, defaultProps }`, where
+     * `defaultProps` are the shell's live values (the header's `onCancel` and initial-focus `ref`; the
+     * action bar's `onSubmit`, `isSaving`, `onDelete`). Slot components need a stable reference identity —
+     * see {@link @gooddata/sdk-ui-kit#ISlotProps}. The body regions have no slot here: place their blocks
+     * ({@link AlertingDialogFilters} and siblings) as children instead.
+     */
+    slots?: Pick<IAlertingDialogSlots, "Header" | "ActionBar">;
+    /**
+     * Rendered first inside the dialog's scrollable content area, above `children`.
+     */
+    topContent?: ReactNode;
+    /**
+     * Rendered last inside the scrollable content area, below `children` and the dialog's warning and
+     * validation messages.
+     */
+    bottomContent?: ReactNode;
+    /**
+     * The body: the regions and fields, in the caller's order — {@link AlertingDialogFilters},
+     * {@link AlertingDialogFormFieldGroup} with the condition and action blocks, and so on. Not mounted
+     * while `useAlertingDialogContext().isLoading` is true (the shell shows its loading skeleton) or while
+     * the stale-filters confirmation step is shown.
+     */
+    children?: ReactNode;
+}
+
 /**
  * Section-level overrides of the default alerting dialog.
  *
@@ -7226,6 +7524,18 @@ export declare interface IAlertingManagementDialogContextValue {
     automationsInvalidationId?: number;
     isEmbedded: boolean;
     enableAccessibilityMode: boolean;
+    /**
+     * Alerts visible in the management dialog, scoped to the current dashboard context.
+     */
+    automations: IAutomationMetadataObject[];
+    /**
+     * True while the automation list is still loading.
+     *
+     * The automations load only — deliberately narrower than the scheduled-email management
+     * context's flag, which also folds in a widget-filters load that has no bearing on a
+     * management list.
+     */
+    isLoading: boolean;
     getWidgetByRef: (ref: ObjRef | undefined) => IWidget | undefined;
     getInsightByWidgetRef: (ref: ObjRef | undefined) => IInsight | undefined;
     pauseAlert(alert: IAutomationMetadataObject): Promise<IAutomationMetadataObject>;
@@ -9917,12 +10227,41 @@ export declare interface IDashboardCustomComponentProps {
      * @alpha
      */
     ScheduledEmailManagementDialogComponent?: CustomScheduledEmailManagementDialogComponent;
+    /**
+     * Specify component to decorate the data the scheduled email management dialog reads.
+     *
+     * Rendered between the connector-provided management dialog context and the resolved
+     * management dialog component; see `CustomScheduledEmailManagementDialogContextDecoratorComponent`
+     * for the contract and an example.
+     *
+     * @alpha
+     */
+    ScheduledEmailManagementDialogContextDecoratorComponent?: CustomScheduledEmailManagementDialogContextDecoratorComponent;
     /**
      * Specify component to use for rendering the alerting management dialog.
      *
      * @alpha
      */
     AlertingManagementDialogComponent?: CustomAlertingManagementDialogComponent;
+    /**
+     * Specify component to decorate the data the alerting management dialog reads.
+     *
+     * Rendered between the connector-provided management dialog context and the resolved
+     * management dialog component; see `CustomAlertingManagementDialogContextDecoratorComponent`
+     * for the contract and an example.
+     *
+     * @alpha
+     */
+    AlertingManagementDialogContextDecoratorComponent?: CustomAlertingManagementDialogContextDecoratorComponent;
+    /**
+     * Specify component to decorate the data the automation dialogs' shared context carries.
+     *
+     * Rendered once per dialog tree, directly inside each connector-provided automations context;
+     * see `CustomAutomationsContextDecoratorComponent` for the contract and an example.
+     *
+     * @alpha
+     */
+    AutomationsContextDecoratorComponent?: CustomAutomationsContextDecoratorComponent;
     /**
      * Specify component to use for rendering the alerting dialog.
      *
@@ -11259,9 +11598,10 @@ export declare interface IDashboardExtensionProps extends IDashboardEventing, ID
 
 /**
  * Supported dashboard filter type.
+ *
  * @public
  */
-export declare type IDashboardFilter = IAbsoluteDateFilter | IRelativeDateFilter | IPositiveAttributeFilter | INegativeAttributeFilter | IArbitraryAttributeFilter | IMatchAttributeFilter | IMeasureValueFilter;
+export declare type IDashboardFilter = IDashboardFilter_2;
 
 /**
  * This event is emitted after dashboard selection filters have been reset.
@@ -19013,59 +19353,132 @@ export declare interface IScheduledEmailDialogContextValue {
 }
 
 /**
- * Props of the default scheduled email dialog's filters region (the Filters tab content).
- *
- * @remarks
- * The region is bimodal: whenever `filtersByTab` is present with more than one tab, the by-tab
- * members (`filtersByTab` and the `*ByTab` parameter family) drive rendering and the flat
- * handlers are unused; otherwise the flat members drive it and the by-tab members are unused.
- * `defaultProps` always carries both families so a wrap stays faithful in either mode.
+ * Props of the scheduled-export dialog's dashboard-attachments field.
  *
  * @alpha
  */
-export declare interface IScheduledEmailDialogFiltersProps extends IAutomationDialogFiltersProps {
+export declare interface IScheduledEmailDialogDashboardAttachmentsProps {
     /**
-     * Whether the schedule stores its own filters instead of using the latest saved dashboard
-     * filters.
+     * The selected export formats.
      */
-    storeFilters: boolean;
+    selectedAttachments: DashboardAttachmentType[];
     /**
-     * Toggles filter (and parameter) persistence. The current filters must be passed back —
-     * flat mode as `(value, selectedFilters, undefined)`, by-tab mode as
-     * `(value, undefined, editedFiltersByTab)`; calling it with the value alone leaves the
-     * draft's export definitions out of sync with the toggle.
+     * Dashboard filters the export is scoped to; the control passes them back as the second
+     * argument of every {@link IScheduledEmailDialogDashboardAttachmentsProps.onDashboardAttachmentsChange}
+     * call.
      */
-    onStoreFiltersChange: (value: boolean, filters?: FilterContextItem[], filtersByTab?: Record<string, FilterContextItem[]>) => void;
+    dashboardFilters?: FilterContextItem[];
     /**
-     * Whether the schedule targets the whole dashboard (shows the store-filters checkbox)
-     * rather than a single widget.
+     * When true and at least one attachment is selected, the control shows the notice that
+     * exports do not reflect cross-filtering.
      */
-    isDashboardAutomation: boolean;
+    isCrossFiltering: boolean;
     /**
-     * Filters structured per dashboard tab; when present with more than one tab, the region
-     * renders in by-tab mode.
+     * Replaces the selected dashboard export formats. Called with the complete new selection and
+     * the current {@link IScheduledEmailDialogDashboardAttachmentsProps.dashboardFilters}.
      */
-    filtersByTab?: IAutomationFiltersTab[];
+    onDashboardAttachmentsChange: (formats: DashboardAttachmentType[], filters?: FilterContextItem[]) => void;
     /**
-     * Edited filter selection per tab.
+     * XLSX export settings shown in the attachment's settings editor.
      */
-    editedFiltersByTab?: Record<string, FilterContextItem[]>;
+    xlsxSettings: IExportDefinitionVisualizationObjectSettings;
     /**
-     * Replaces a tab's filter selection with the complete updated record.
+     * Sets the XLSX export settings.
      */
-    onFiltersByTabChange?: (filtersByTab: Record<string, FilterContextItem[]>) => void;
+    onXlsxSettingsChange: (settings: IExportDefinitionVisualizationObjectSettings) => void;
     /**
-     * Parameter chips per tab (by-tab mode).
+     * Whether the slide-based formats (PPTX, PDF slides) are offered; when false they are
+     * excluded from the add-attachment options.
      */
-    parametersByTab?: Record<string, IAutomationParameter[]>;
+    isSlidesExportEnabled: boolean;
     /**
-     * Addable workspace parameters per tab (by-tab mode).
+     * Export templates offered in the template picker of the slide-based formats.
      */
-    availableParametersByTab?: Record<string, IAutomationParameter[]>;
+    exportTemplates?: IExportTemplate[];
     /**
-     * Called when a parameter is added in a tab section (by-tab mode).
+     * The template chosen per slide-based format; undefined where the default template applies.
      */
-    onParameterAddByTab?: (tabId: string, ref: IdentifierRef) => void;
+    slidesTemplateIds?: {
+        PPTX?: string;
+        PDF_SLIDES?: string;
+        PDF?: string;
+    };
+    /**
+     * Sets the export template of one slide-based format.
+     */
+    onSlidesTemplateIdChange?: (templateId: string | undefined, format: "PPTX" | "PDF_SLIDES" | "PDF") => void;
+}
+
+/**
+ * Props of the scheduled-export dialog's evaluation-mode checkbox.
+ *
+ * @alpha
+ */
+export declare interface IScheduledEmailDialogEvaluationModeProps {
+    /**
+     * Whether the evaluation mode is SHARED.
+     */
+    isShared: boolean;
+    /**
+     * Switches between a shared and a per-recipient evaluation of the export.
+     */
+    onChange: (isShared: boolean) => void;
+}
+
+/**
+ * Props of the default scheduled email dialog's filters region (the Filters tab content).
+ *
+ * @remarks
+ * The region is bimodal: whenever `filtersByTab` is present with more than one tab, the by-tab
+ * members (`filtersByTab` and the `*ByTab` parameter family) drive rendering and the flat
+ * handlers are unused; otherwise the flat members drive it and the by-tab members are unused.
+ * `defaultProps` always carries both families so a wrap stays faithful in either mode.
+ *
+ * @alpha
+ */
+export declare interface IScheduledEmailDialogFiltersProps extends IAutomationDialogFiltersProps {
+    /**
+     * Whether the schedule stores its own filters instead of using the latest saved dashboard
+     * filters.
+     */
+    storeFilters: boolean;
+    /**
+     * Toggles filter (and parameter) persistence. The current filters must be passed back —
+     * flat mode as `(value, selectedFilters, undefined)`, by-tab mode as
+     * `(value, undefined, editedFiltersByTab)`; calling it with the value alone leaves the
+     * draft's export definitions out of sync with the toggle.
+     */
+    onStoreFiltersChange: (value: boolean, filters?: FilterContextItem[], filtersByTab?: Record<string, FilterContextItem[]>) => void;
+    /**
+     * Whether the schedule targets the whole dashboard (shows the store-filters checkbox)
+     * rather than a single widget.
+     */
+    isDashboardAutomation: boolean;
+    /**
+     * Filters structured per dashboard tab; when present with more than one tab, the region
+     * renders in by-tab mode.
+     */
+    filtersByTab?: IAutomationFiltersTab[];
+    /**
+     * Edited filter selection per tab.
+     */
+    editedFiltersByTab?: Record<string, FilterContextItem[]>;
+    /**
+     * Replaces a tab's filter selection with the complete updated record.
+     */
+    onFiltersByTabChange?: (filtersByTab: Record<string, FilterContextItem[]>) => void;
+    /**
+     * Parameter chips per tab (by-tab mode).
+     */
+    parametersByTab?: Record<string, IAutomationParameter[]>;
+    /**
+     * Addable workspace parameters per tab (by-tab mode).
+     */
+    availableParametersByTab?: Record<string, IAutomationParameter[]>;
+    /**
+     * Called when a parameter is added in a tab section (by-tab mode).
+     */
+    onParameterAddByTab?: (tabId: string, ref: IdentifierRef) => void;
     /**
      * Called when a parameter chip's value is edited in a tab section (by-tab mode).
      */
@@ -19096,6 +19509,22 @@ export declare interface IScheduledEmailDialogHeaderProps extends IAutomationDia
     onBack?: () => void;
 }
 
+/**
+ * Props of the scheduled-export dialog's message field.
+ *
+ * @alpha
+ */
+export declare interface IScheduledEmailDialogMessageProps {
+    /**
+     * The e-mail message text.
+     */
+    value: string;
+    /**
+     * Sets the e-mail message; `isValid` is the field's own length verdict.
+     */
+    onChange: (value: string, isValid: boolean) => void;
+}
+
 /**
  * @alpha
  */
@@ -19232,6 +19661,120 @@ export declare interface IScheduledEmailDialogRecipientsProps extends IAutomatio
     onKeyDownSubmit: (e: KeyboardEvent_2) => void;
 }
 
+/**
+ * Props of the scheduled-export dialog's recurrence field.
+ *
+ * @alpha
+ */
+export declare interface IScheduledEmailDialogRecurrenceProps {
+    /**
+     * First-run date the cron editor is anchored to.
+     */
+    startDate: Date;
+    /**
+     * The draft's cron expression.
+     */
+    cronExpression: string;
+    /**
+     * Human-readable description of the cron expression, when the draft carries one.
+     */
+    cronDescription?: string;
+    /**
+     * Display-only timezone label shown in the occurrence description.
+     */
+    timezone: string;
+    /**
+     * Date format used by the first-run date picker.
+     */
+    dateFormat: string;
+    /**
+     * Locale of the recurrence editor.
+     */
+    locale: string;
+    /**
+     * First day of the week in the date picker.
+     */
+    weekStart: WeekStart;
+    /**
+     * Whether the hourly recurrence option is offered.
+     */
+    allowHourlyRecurrence: boolean;
+    /**
+     * Hides GoodData-specific copy when white-labeled.
+     */
+    isWhiteLabeled: boolean;
+    /**
+     * Closes the recurrence dropdowns when the dialog body scrolls.
+     */
+    closeDropdownsOnParentScroll: boolean;
+    /**
+     * Sets the cron expression and first run; `isValid` is the recurrence form's own verdict.
+     */
+    onChange: (cronExpression: string, startDate: Date | null, isValid: boolean) => void;
+    /**
+     * Key-down handler; the dialog submits on Enter through it.
+     */
+    onKeyDownSubmit: (event: KeyboardEvent_2) => void;
+}
+
+/**
+ * Props of {@link ScheduledEmailDialogShell}.
+ *
+ * @alpha
+ */
+export declare interface IScheduledEmailDialogShellProps extends Pick<IScheduledEmailDialogProps, "onCancel" | "onBack" | "onDeleteSuccess" | "onDeleteError"> {
+    /**
+     * The dialog's single save — `handleSaveScheduledEmail` of the caller's
+     * {@link useSaveScheduledEmailToBackend} instance. Drives the footer's submit button, the Enter key on
+     * it, and the header's Enter-to-submit. (Not the `onSubmit` observer of {@link IScheduledEmailDialogProps};
+     * that one goes to the save hook.) The shell does not own the save hook, so the caller's own Enter
+     * handlers — {@link useScheduledEmailSubmitOnEnter} — share the same instance. Create the hook instance
+     * only once the dialog context reports `isLoading: false`.
+     */
+    onSubmit: () => void;
+    /**
+     * `isSavingScheduledEmail` of the same instance: disables submit and Delete and shows the footer's
+     * progress indicator.
+     */
+    isSaving: boolean;
+    /**
+     * `savingErrorMessage` of the same instance; shown as the body's error message, ahead of the form's
+     * validation message.
+     */
+    savingErrorMessage?: string;
+    /**
+     * Header, action-bar and Filters-tab overrides — the Level 1 slot contract
+     * ({@link IScheduledEmailDialogSlots.Header}, {@link IScheduledEmailDialogSlots.ActionBar},
+     * {@link IScheduledEmailDialogSlots.Filters}): each slot receives `{ Default, defaultProps }` with the
+     * shell's live values. Slot components need a stable reference identity — see
+     * {@link @gooddata/sdk-ui-kit#ISlotProps}. `Filters` is ignored when `filtersTabContent` is passed. The
+     * General-tab regions have no slot here: place their blocks ({@link ScheduledEmailDialogDestination} and
+     * siblings) as children instead.
+     */
+    slots?: Pick<IScheduledEmailDialogSlots, "Header" | "ActionBar" | "Filters">;
+    /**
+     * Rendered first inside the dialog's scrollable content area, above the selected tab's content.
+     */
+    topContent?: ReactNode;
+    /**
+     * Rendered last inside the scrollable content area, below the selected tab's content.
+     */
+    bottomContent?: ReactNode;
+    /**
+     * The General tab's content: the regions and fields, in the caller's order. Rendered only while the
+     * General tab is selected; not mounted while `useScheduledEmailDialogContext().isLoading` is true (the
+     * shell shows its loading skeleton — on scheduled email the ordinary path while a widget export's
+     * filters load) or while the stale-filters confirmation step is shown.
+     */
+    children?: ReactNode;
+    /**
+     * The Filters tab's content. Defaults to the dialog's filters region ({@link DefaultScheduledEmailDialogFilters}
+     * with {@link useScheduledEmailDialogFiltersProps}, or the `Filters` slot). Rendered only while the Filters
+     * tab is selected. An explicit `null` counts as provided and renders an empty Filters tab.
+     */
+    filtersTabContent?: ReactNode;
+}
+
 /**
  * Section-level overrides of the default scheduled email dialog.
  *
@@ -19304,6 +19847,34 @@ export declare interface IScheduledEmailDialogSlots {
     ActionBar?: ComponentType<ISlotProps<IAutomationDialogActionBarProps>>;
 }
 
+/**
+ * Props of the scheduled-export dialog's subject field.
+ *
+ * @alpha
+ */
+export declare interface IScheduledEmailDialogSubjectProps {
+    /**
+     * Dashboard title, used as the subject placeholder (truncated to the title max length).
+     */
+    dashboardTitle: string;
+    /**
+     * The export draft; the field renders `details.subject`.
+     */
+    editedAutomation: IAutomationMetadataObjectDefinition;
+    /**
+     * Disables submit-on-Enter while the dialog is not submittable.
+     */
+    isSubmitDisabled?: boolean;
+    /**
+     * Sets the e-mail subject; `isValid` is the field's own length verdict.
+     */
+    onChange: (value: string, isValid: boolean) => void;
+    /**
+     * Called on Enter when submit is not disabled.
+     */
+    onKeyDownSubmit: () => void;
+}
+
 /**
  * Props of the default scheduled email dialog's "Time zone" section (the export-content timezone
  * picker on the General tab; unrelated to the schedule cron timezone).
@@ -19331,6 +19902,80 @@ export declare interface IScheduledEmailDialogTimezoneProps {
     onTimezoneChange: (timezoneId: string | undefined) => void;
 }
 
+/**
+ * Props of the scheduled-export dialog's widget-attachments field.
+ *
+ * @alpha
+ */
+export declare interface IScheduledEmailDialogWidgetAttachmentsProps {
+    /**
+     * The selected export formats.
+     */
+    selectedAttachments: WidgetAttachmentType[];
+    /**
+     * Replaces the selected widget export formats with the complete new selection.
+     */
+    onWidgetAttachmentsChange: (formats: WidgetAttachmentType[]) => void;
+    /**
+     * XLSX export settings shown in the attachment's settings editor.
+     */
+    xlsxSettings: IExportDefinitionVisualizationObjectSettings;
+    /**
+     * Sets the XLSX export settings.
+     */
+    onXlsxSettingsChange: (settings: IExportDefinitionVisualizationObjectSettings) => void;
+    /**
+     * Tabular-PDF export settings shown in the attachment's settings editor.
+     */
+    pdfSettings: IExportDefinitionVisualizationObjectSettings;
+    /**
+     * Sets the tabular-PDF export settings.
+     */
+    onPdfSettingsChange: (settings: IExportDefinitionVisualizationObjectSettings) => void;
+    /**
+     * CSV export settings shown in the attachment's settings editor.
+     */
+    csvSettings: IExportDefinitionVisualizationObjectSettings;
+    /**
+     * Sets the CSV export settings.
+     */
+    onCsvSettingsChange: (settings: IExportDefinitionVisualizationObjectSettings) => void;
+    /**
+     * Raw-CSV export settings shown in the attachment's settings editor.
+     */
+    csvRawSettings: IExportDefinitionVisualizationObjectSettings;
+    /**
+     * Sets the raw-CSV export settings.
+     */
+    onCsvRawSettingsChange: (settings: IExportDefinitionVisualizationObjectSettings) => void;
+    /**
+     * Whether the slide-based formats (PPTX, PDF) are offered; when false they are excluded
+     * from the add-attachment options.
+     */
+    isSlidesExportEnabled: boolean;
+    /**
+     * When true, formats without an accessible rendering (PDF_TABULAR) are excluded from the
+     * add-attachment options.
+     */
+    isAccessibilityModeEnabled: boolean;
+    /**
+     * Export templates offered in the template picker of the slide-based formats.
+     */
+    exportTemplates?: IExportTemplate[];
+    /**
+     * The template chosen per slide-based format; undefined where the default template applies.
+     */
+    slidesTemplateIds?: {
+        PPTX?: string;
+        PDF_SLIDES?: string;
+        PDF?: string;
+    };
+    /**
+     * Sets the export template of one slide-based format.
+     */
+    onSlidesTemplateIdChange?: (templateId: string | undefined, format: "PPTX" | "PDF_SLIDES" | "PDF") => void;
+}
+
 /**
  * Sub-context for the scheduled-email management dialog.
  * The connector hydrates this from dashboard state.
@@ -20335,7 +20980,7 @@ export declare const isDashboardExportToPptPresentationResolved: (obj: unknown)
  *
  * @alpha
  */
-export declare function isDashboardFilter(obj: unknown): obj is IDashboardFilter;
+export declare const isDashboardFilter: typeof isDashboardFilter_2;
 
 /**
  * Tests whether the provided object is an instance of {@link DashboardFilterContextChanged}.
@@ -22972,6 +23617,47 @@ export declare interface IUseScheduledEmailDialogRecipientsPropsInput {
     onKeyDownSubmit: (event: KeyboardEvent_2) => void;
 }
 
+/**
+ * Inputs of {@link useScheduledEmailDialogRecurrenceProps} that come from the dialog rather than its state.
+ *
+ * @alpha
+ */
+export declare interface IUseScheduledEmailDialogRecurrencePropsInput {
+    /**
+     * Key-down handler of the recurrence inputs; the dialog submits on Enter through it.
+     */
+    onKeyDownSubmit: (event: KeyboardEvent_2) => void;
+}
+
+/**
+ * Inputs of {@link useScheduledEmailDialogSubjectProps} that come from the dialog rather than its state.
+ *
+ * @alpha
+ */
+export declare interface IUseScheduledEmailDialogSubjectPropsInput {
+    /**
+     * Called on Enter in the subject input when submit is not disabled.
+     */
+    onKeyDownSubmit: () => void;
+}
+
+/**
+ * Inputs of {@link useScheduledEmailSubmitOnEnter} — the dialog's single save, from one
+ * {@link useSaveScheduledEmailToBackend} instance.
+ *
+ * @alpha
+ */
+export declare interface IUseScheduledEmailSubmitOnEnterInput {
+    /**
+     * `handleSaveScheduledEmail` of the dialog's {@link useSaveScheduledEmailToBackend} instance.
+     */
+    onSubmit: () => void;
+    /**
+     * `isSavingScheduledEmail` of the same instance; Enter does nothing while a save is in flight.
+     */
+    isSaving: boolean;
+}
+
 /**
  * @internal
  */
@@ -23002,6 +23688,39 @@ export declare interface IUseWidgetSelectionResult {
     hasConfigPanelOpen: boolean;
 }
 
+/**
+ * What {@link useWorkspaceUsersSearch} returns.
+ *
+ * @alpha
+ */
+export declare interface IUseWorkspaceUsersSearchResult {
+    /**
+     * The current, not yet debounced, search string.
+     */
+    search: string;
+    /**
+     * The workspace users of the last settled query; undefined until the first query settles.
+     */
+    users: IWorkspaceUser[] | undefined;
+    /**
+     * The last query's error, if it failed.
+     */
+    usersError: GoodDataSdkError | undefined;
+    /**
+     * True while the search debounce window or a query is open.
+     */
+    isLoading: boolean;
+    /**
+     * Sets the search string; the query fires after a 300 ms debounce.
+     */
+    onSearch: (search: string) => void;
+    /**
+     * Starts the first fetch — nothing loads on mount until this is called (wire it to the
+     * control's open/focus). After an error it doubles as retry.
+     */
+    onActivate: () => void;
+}
+
 /**
  * Set of functions you can use to customize some aspects of the VisualizationSwitcher.
  *
@@ -25677,6 +26396,20 @@ export declare function ScheduledEmailDialogActionBar(props: IScheduledEmailDial
  */
 export declare const ScheduledEmailDialogContextProvider: Provider<IScheduledEmailDialogContextValue | undefined>;
 
+/**
+ * The scheduled-export dialog's dashboard-attachments field, connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogDashboardAttachments} with the props of
+ * {@link useScheduledEmailDialogDashboardAttachmentsProps}; every prop passed here replaces the
+ * hook's value for that prop wholesale. Renders nothing while
+ * `useScheduledEmailDialogContext().isLoading` is true and when the dialog context has a `widget`
+ * (a widget schedule renders {@link ScheduledEmailDialogWidgetAttachments} instead), the same
+ * visibility the default dialog gives the field.
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogDashboardAttachments(props: Partial<IScheduledEmailDialogDashboardAttachmentsProps>): ReactElement;
+
 /**
  * The scheduled-export dialog's destination region (the notification-channel select), connected to
  * the dialog's state.
@@ -25689,6 +26422,20 @@ export declare const ScheduledEmailDialogContextProvider: Provider<IScheduledEma
  */
 export declare function ScheduledEmailDialogDestination(overrides: Partial<IAutomationDialogDestinationProps>): JSX.Element;
 
+/**
+ * The scheduled-export dialog's evaluation-mode checkbox, connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogEvaluationMode} with the props of
+ * {@link useScheduledEmailDialogEvaluationModeProps}; every prop passed here replaces the hook's
+ * value for that prop wholesale. Renders nothing while
+ * `useScheduledEmailDialogContext().isLoading` is true and while
+ * `useAutomationsContext().features.enableAutomationEvaluationMode` is off, the same visibility the
+ * default dialog gives the field.
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogEvaluationMode(props: Partial<IScheduledEmailDialogEvaluationModeProps>): ReactElement;
+
 /**
  * The scheduled-export dialog's filters region (the filter and parameter chips, flat or per tab),
  * connected to the dialog's state.
@@ -25731,6 +26478,19 @@ export declare type ScheduledEmailDialogHeaderDefaultProps = IScheduledEmailDial
     ref?: Ref<HTMLInputElement>;
 };
 
+/**
+ * The scheduled-export dialog's message field, connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogMessage} with the props of
+ * {@link useScheduledEmailDialogMessageProps}; every prop passed here replaces the hook's value for
+ * that prop wholesale. Renders nothing while `useScheduledEmailDialogContext().isLoading` is true
+ * and for an in-platform notification channel (which has no e-mail message), the same visibility
+ * the default dialog gives the field.
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogMessage(props: Partial<IScheduledEmailDialogMessageProps>): ReactElement;
+
 /**
  * The scheduled-export dialog's recipients region, connected to the dialog's state.
  *
@@ -25745,6 +26505,91 @@ export declare type ScheduledEmailDialogHeaderDefaultProps = IScheduledEmailDial
  */
 export declare function ScheduledEmailDialogRecipients(props: Partial<IScheduledEmailDialogRecipientsProps>): JSX.Element;
 
+/**
+ * The scheduled-export dialog's recurrence field, connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogRecurrence} with the props of
+ * {@link useScheduledEmailDialogRecurrenceProps}; every prop passed here replaces the hook's value
+ * for that prop wholesale. Pass `onKeyDownSubmit` to submit on Enter from the recurrence inputs —
+ * the default dialog passes its save action; without it Enter does nothing here. Renders nothing
+ * while `useScheduledEmailDialogContext().isLoading` is true; otherwise ungated, unlike the other
+ * General-tab fields.
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogRecurrence(props: Partial<IScheduledEmailDialogRecurrenceProps>): ReactElement;
+
+/**
+ * The scheduled-export dialog's chrome, connected to the dialog's state: the modal overlay, the dialog
+ * frame with the header row (the back button and the title input) and the action bar, the General and
+ * Filters tabs, the scrollable content area around the selected tab's content, the body's error and
+ * validation messages, the stale-filters confirmation step shown before the dialog when the saved filters
+ * or schedule timezone no longer match the dashboard, and the delete confirmation reached from the
+ * action bar in edit mode. While `useScheduledEmailDialogContext().isLoading` is true — on scheduled
+ * email the ordinary path while a widget export's filters load — it renders the loading skeleton and
+ * none of its children.
+ *
+ * The default dialog is `<ScheduledEmailDialogShell>` around the region blocks and form; a custom
+ * `ScheduledEmailDialogComponent` that keeps this chrome and arranges the blocks differently renders the
+ * shell itself. The shell does not own the save: call {@link useSaveScheduledEmailToBackend} and pass its
+ * `handleSaveScheduledEmail`, `isSavingScheduledEmail` and `savingErrorMessage`; build Enter handlers for
+ * the blocks you place with {@link useScheduledEmailSubmitOnEnter} over the same `handleSaveScheduledEmail`.
+ * Call that hook only once `useScheduledEmailDialogContext().isLoading` is false — the state hooks throw
+ * while the dialog loads — and render the shell alone (any `onSubmit`, `isSaving: false`) until then, as
+ * the example does.
+ *
+ * Needs an ambient `IntlProvider`; inside a `Dashboard` the dashboard's provider covers it.
+ *
+ * @example
+ * ```tsx
+ * function MyScheduledEmailDialog(props: IScheduledEmailDialogProps) {
+ *     const { isLoading } = useScheduledEmailDialogContext();
+ *     // the state hooks throw while the dialog loads; the shell renders the loading skeleton
+ *     if (isLoading) {
+ *         return <ScheduledEmailDialogShell {...props} onSubmit={() => {}} isSaving={false} />;
+ *     }
+ *     return <MyScheduledEmailDialogBody {...props} />;
+ * }
+ *
+ * function MyScheduledEmailDialogBody(props: IScheduledEmailDialogProps) {
+ *     const { handleSaveScheduledEmail, isSavingScheduledEmail, savingErrorMessage } =
+ *         useSaveScheduledEmailToBackend(props);
+ *     const submitOnEnter = useScheduledEmailSubmitOnEnter({
+ *         onSubmit: handleSaveScheduledEmail,
+ *         isSaving: isSavingScheduledEmail,
+ *     });
+ *     return (
+ *         <ScheduledEmailDialogShell
+ *             {...props}
+ *             onSubmit={handleSaveScheduledEmail}
+ *             isSaving={isSavingScheduledEmail}
+ *             savingErrorMessage={savingErrorMessage}
+ *         >
+ *             <ScheduledEmailDialogDestination />
+ *             <ScheduledEmailDialogRecipients onKeyDownSubmit={submitOnEnter} />
+ *         </ScheduledEmailDialogShell>
+ *     );
+ * }
+ * ```
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogShell(props: IScheduledEmailDialogShellProps): ReactElement;
+
+/**
+ * The scheduled-export dialog's subject field, connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogSubject} with the props of
+ * {@link useScheduledEmailDialogSubjectProps}; every prop passed here replaces the hook's value for
+ * that prop wholesale. Pass `onKeyDownSubmit` to submit on Enter from the subject input — the
+ * default dialog passes its save action; without it Enter does nothing here. Renders nothing while
+ * `useScheduledEmailDialogContext().isLoading` is true and for an in-platform notification channel
+ * (which has no e-mail subject), the same visibility the default dialog gives the field.
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogSubject(props: Partial<IScheduledEmailDialogSubjectProps>): ReactElement;
+
 /**
  * The scheduled-export dialog's "Time zone" section (the export-content timezone picker), connected
  * to the dialog's state.
@@ -25767,10 +26612,40 @@ export declare function ScheduledEmailDialogTimezone(overrides: Partial<Schedule
 export declare type ScheduledEmailDialogTimezoneDefaultProps = IScheduledEmailDialogTimezoneProps;
 
 /**
+ * The scheduled-export dialog's widget-attachments field, connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogWidgetAttachments} with the props of
+ * {@link useScheduledEmailDialogWidgetAttachmentsProps}; every prop passed here replaces the hook's
+ * value for that prop wholesale. Renders nothing while `useScheduledEmailDialogContext().isLoading`
+ * is true and when the dialog context has no `widget` (a dashboard schedule renders
+ * {@link ScheduledEmailDialogDashboardAttachments} instead), the same visibility the default dialog
+ * gives the field.
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogWidgetAttachments(props: Partial<IScheduledEmailDialogWidgetAttachmentsProps>): ReactElement;
+
+/**
+ * Resolves the management dialog component from DashboardComponentsContext and mounts it inside
+ * the resolved context decorator — so a decorated management context is what the dialog (default
+ * or replacement) reads.
+ *
  * @internal
  */
 export declare function ScheduledEmailManagementDialog(props: IScheduledEmailManagementDialogProps): ReactElement;
 
+/**
+ * Provides the scheduled email management dialog context.
+ *
+ * The dashboard's connector mounts the original value. Exported so a context-decorator
+ * component (`CustomScheduledEmailManagementDialogContextDecoratorComponent`) can re-provide a decorated
+ * value read from `useScheduledEmailManagementDialogContext()`; it is not a way to run the management
+ * dialog outside a dashboard.
+ *
+ * @alpha
+ */
+export declare const ScheduledEmailManagementDialogContextProvider: Provider<IScheduledEmailManagementDialogContextValue | undefined>;
+
 /**
  * @internal
  */
@@ -27443,23 +28318,21 @@ export declare const selectExecutionResultLimitBreaksByRef: (ref: ObjRef | undef
 export declare const selectExecutionTimestamp: DashboardSelector<string | undefined>;
 
 /**
- * Returns the per-tab parameter overrides to send on dashboard tabular export, keyed by
- * tab `localIdentifier`. The shape matches the backend's `dashboardTabsParametersOverrides`
+ * Returns the per-tab parameter overrides to send on dashboard export, keyed by tab
+ * `localIdentifier`. The shape matches the backend's `dashboardTabsParametersOverrides`
  * field directly.
  *
  * @remarks
- * Scope rules:
- * - When `widgetIds` is empty/undefined (whole-dashboard export), every tab in scope contributes
- *   parameter entries with a `runtimeOverride`.
- * - When `widgetIds` is non-empty, each widget's owning tab contributes only entries with a
- *   `runtimeOverride` whose ref is referenced by the widget's insight metrics via the dashboard-wide
- *   metric → parameter dependency map. Multi-widget across distinct owning tabs yields one
- *   map entry per owning tab; entries for the same tab are unioned and deduplicated by ref.
+ * The request sends every `runtimeOverride` entry of each tab in scope; the query drops the
+ * parameters a widget's metrics do not use.
+ * - When `widgetIds` is empty/undefined (whole-dashboard export), every tab is in scope.
+ * - When `widgetIds` is non-empty, only the owning tabs of those widgets are in scope. Send only
+ *   these tabs. A non-empty map tells the backend that the map is complete, and the backend then
+ *   does not resolve pinned values for any tab.
  *
  * Returns `{}` (signalling "omit the field on the wire") when:
  * - `enableParameters` is off,
  * - the workspace catalog parameters are not loaded,
- * - (widget scope only) the `measureParameters` dependency map is not loaded,
  * - or no in-scope parameter has a `runtimeOverride`.
  *
  * @alpha
@@ -32200,6 +33073,15 @@ export declare function useScheduledEmailDialogActionBarProps({ onCancel, onSubm
  */
 export declare function useScheduledEmailDialogContext(): IScheduledEmailDialogContextValue;
 
+/**
+ * The exact props the default scheduled-email dialog renders its dashboard-attachments field with.
+ *
+ * Throws outside the scheduled-export dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useScheduledEmailDialogDashboardAttachmentsProps(): IScheduledEmailDialogDashboardAttachmentsProps;
+
 /**
  * The exact props the default scheduled-email dialog renders its destination region with.
  *
@@ -32209,6 +33091,15 @@ export declare function useScheduledEmailDialogContext(): IScheduledEmailDialogC
  */
 export declare function useScheduledEmailDialogDestinationProps(): IAutomationDialogDestinationProps;
 
+/**
+ * The exact props the default scheduled-email dialog renders its evaluation-mode checkbox with.
+ *
+ * Throws outside the scheduled-export dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useScheduledEmailDialogEvaluationModeProps(): IScheduledEmailDialogEvaluationModeProps;
+
 /**
  * The exact props the default scheduled-email dialog renders its filters region with.
  *
@@ -32227,6 +33118,15 @@ export declare function useScheduledEmailDialogFiltersProps(): IScheduledEmailDi
  */
 export declare function useScheduledEmailDialogHeaderProps({ onBack, onTitleKeyDown, ref }: IUseScheduledEmailDialogHeaderPropsInput): ScheduledEmailDialogHeaderDefaultProps;
 
+/**
+ * The exact props the default scheduled-email dialog renders its message field with.
+ *
+ * Throws outside the scheduled-export dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useScheduledEmailDialogMessageProps(): IScheduledEmailDialogMessageProps;
+
 /**
  * The exact props the default scheduled-email dialog renders its recipients region with.
  *
@@ -32236,6 +33136,24 @@ export declare function useScheduledEmailDialogHeaderProps({ onBack, onTitleKeyD
  */
 export declare function useScheduledEmailDialogRecipientsProps({ onKeyDownSubmit }: IUseScheduledEmailDialogRecipientsPropsInput): IScheduledEmailDialogRecipientsProps;
 
+/**
+ * The exact props the default scheduled-email dialog renders its recurrence field with.
+ *
+ * Throws outside the scheduled-export dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useScheduledEmailDialogRecurrenceProps({ onKeyDownSubmit }: IUseScheduledEmailDialogRecurrencePropsInput): IScheduledEmailDialogRecurrenceProps;
+
+/**
+ * The exact props the default scheduled-email dialog renders its subject field with.
+ *
+ * Throws outside the scheduled-export dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useScheduledEmailDialogSubjectProps({ onKeyDownSubmit }: IUseScheduledEmailDialogSubjectPropsInput): IScheduledEmailDialogSubjectProps;
+
 /**
  * The exact props the default scheduled-email dialog renders its "Time zone" section with.
  *
@@ -32245,6 +33163,15 @@ export declare function useScheduledEmailDialogRecipientsProps({ onKeyDownSubmit
  */
 export declare function useScheduledEmailDialogTimezoneProps(): ScheduledEmailDialogTimezoneDefaultProps;
 
+/**
+ * The exact props the default scheduled-email dialog renders its widget-attachments field with.
+ *
+ * Throws outside the scheduled-export dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useScheduledEmailDialogWidgetAttachmentsProps(): IScheduledEmailDialogWidgetAttachmentsProps;
+
 /**
  * Reads the scheduled-email management dialog context.
  *
@@ -32259,6 +33186,19 @@ export declare function useScheduledEmailDialogTimezoneProps(): ScheduledEmailDi
  */
 export declare function useScheduledEmailManagementDialogContext(): IScheduledEmailManagementDialogContextValue;
 
+/**
+ * The Enter-to-submit key handler the default scheduled-export dialog attaches to its title, recipients
+ * and recurrence inputs: calls `onSubmit` on Enter unless the submit button would be disabled — the same
+ * guard {@link useScheduledEmailDialogActionBarProps} puts on the button (form validity, a save in
+ * flight, execution-timestamp mode). Pass the result as `onTitleKeyDown` / `onKeyDownSubmit` to the
+ * header and recipients blocks so every Enter path shares the dialog's one save.
+ *
+ * Throws outside the scheduled-export dialog's state providers.
+ *
+ * @alpha
+ */
+export declare function useScheduledEmailSubmitOnEnter({ onSubmit, isSaving }: IUseScheduledEmailSubmitOnEnterInput): (event: KeyboardEvent_2) => void;
+
 /**
  * Reads the scheduled-export dialog's draft mutators.
  *
@@ -32404,6 +33344,23 @@ export declare function useWidgetFilters(widget: FilterableDashboardWidget | und
  */
 export declare function useWidgetSelection(widgetRef?: ObjRef): IUseWidgetSelectionResult;
 
+/**
+ * Debounced workspace-user search for a recipients control.
+ *
+ * Queries the first 50 matching workspace users, 300 ms debounced, lazily: no request is made
+ * until {@link IUseWorkspaceUsersSearchResult.onActivate} is called. Requires only the ambient
+ * `BackendProvider` and `WorkspaceProvider` from `@gooddata/sdk-ui` — it reads no automation
+ * context, so a custom recipients control can call it anywhere inside a `Dashboard` (or any
+ * backend/workspace scope). The default recipients select of both automation dialogs is built
+ * on it. Pass `enabled: false` to keep it inert (the default select does so when an external
+ * recipient override or a logged-user-only constraint removes server search).
+ *
+ * @alpha
+ */
+export declare function useWorkspaceUsersSearch({ enabled }: {
+    enabled: boolean;
+}): IUseWorkspaceUsersSearchResult;
+
 /**
  * @internal
  */