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

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/DefaultScheduledEmailDialog.js

@@ -10,12 +10,13 @@ import { IntlWrapper } from "../../../localization/IntlWrapper.js";
 import { useAutomationsContext } from "../../contexts/AutomationsContext.js";
 import { useScheduledEmailDialogContext } from "../../contexts/ScheduledEmailDialogContext.js";
 import { ApplyCurrentFiltersConfirmDialog } from "../../shared/automationFilters/components/ApplyLatestFiltersConfirmDialog.js";
-import { AutomationDialogActionBar, AutomationDialogFooterLeft, } from "../../shared/slots/AutomationDialogActionBar.js";
+import { AutomationDialogFooterLeft, DefaultAutomationDialogActionBar, } from "../../shared/slots/DefaultAutomationDialogActionBar.js";
 import { DeleteScheduleConfirmDialog } from "../DefaultScheduledEmailManagementDialog/components/DeleteScheduleConfirmDialog.js";
 import { useScheduleEmailDialogAccessibility } from "../hooks/useScheduleEmailDialogAccessibility.js";
 import { useScheduledExportActions } from "../state/ScheduledExportActionsContext.js";
 import { useScheduledExportDraft } from "../state/ScheduledExportDraftContext.js";
 import { useScheduledExportFilters } from "../state/ScheduledExportFiltersContext.js";
+import { useSaveScheduledEmailToBackend } from "../state/useSaveScheduledEmailToBackend.js";
 import { useScheduledEmailDialogActionBarProps, useScheduledEmailDialogDestinationProps, useScheduledEmailDialogFiltersProps, useScheduledEmailDialogHeaderProps, useScheduledEmailDialogRecipientsProps, useScheduledEmailDialogTimezoneProps, } from "../state/useScheduledEmailDialogRegionProps.js";
 import { useScheduledExportAttachments } from "../state/useScheduledExportAttachments.js";
 import { useScheduledExportDialogValidity } from "../state/useScheduledExportDialogValidity.js";
@@ -23,18 +24,17 @@ import { getDefaultCronExpression } from "../utils/cron.js";
 import { TIMEZONE_DEFAULT } from "../utils/timezone.js";
 import { DashboardAttachments } from "./components/Attachments/DashboardAttachments.js";
 import { WidgetAttachments } from "./components/Attachments/WidgetAttachments.js";
+import { DefaultScheduledEmailDialogDestination } from "./components/DefaultScheduledEmailDialogDestination.js";
+import { DefaultScheduledEmailDialogFilters } from "./components/DefaultScheduledEmailDialogFilters.js";
+import { DefaultScheduledEmailDialogHeader } from "./components/DefaultScheduledEmailDialogHeader.js";
+import { DefaultScheduledEmailDialogRecipients } from "./components/DefaultScheduledEmailDialogRecipients.js";
+import { DefaultScheduledEmailDialogTimezone } from "./components/DefaultScheduledEmailDialogTimezone.js";
 import { EvaluationModeCheckbox } from "./components/EvaluationModeCheckbox/EvaluationModeCheckbox.js";
-import { ScheduledEmailDialogHeader } from "./components/Header/ScheduleEmailDialogHeader.js";
 import { MessageForm } from "./components/MessageForm/MessageForm.js";
-import { ScheduledEmailDialogDestination } from "./components/ScheduledEmailDialogDestination.js";
-import { ScheduledEmailDialogFilters } from "./components/ScheduledEmailDialogFilters.js";
-import { ScheduledEmailDialogRecipients } from "./components/ScheduledEmailDialogRecipients.js";
-import { ScheduleTimezoneSelect } from "./components/ScheduleTimezoneSelect/ScheduleTimezoneSelect.js";
 import { SubjectForm } from "./components/SubjectForm/SubjectForm.js";
 import { SCHEDULED_EMAIL_DIALOG_ID } from "./constants.js";
 import { DefaultLoadingScheduledEmailDialog } from "./DefaultLoadingScheduledEmailDialog.js";
 import { useElementHeightSnapshot } from "./hooks/useElementHeightSnapshot.js";
-import { useSaveScheduledEmailToBackend } from "./hooks/useSaveScheduledEmailToBackend.js";
 const CLOSE_ON_PARENT_SCROLL = true;
 const overlayController = OverlayController.getInstance(DASHBOARD_DIALOG_OVERS_Z_INDEX);
 export function ScheduledMailDialogRenderer({ onBack, onCancel, onDeleteSuccess, onDeleteError, onError, onSave, onSaveError, onSaveSuccess, onSubmit, onSuccess, slots, topContent, bottomContent, }) {
@@ -140,9 +140,9 @@ export function ScheduledMailDialogRenderer({ onBack, onCancel, onDeleteSuccess,
                             }, showProgressIndicator: actionBarDefaultProps.isSaving, returnFocusTo: returnFocusTo, returnFocusAfterClose: false, footerLeftRenderer: ActionBarSlot
                                 ? undefined
                                 : () => (_jsx(AutomationDialogFooterLeft, { helpLinkText: actionBarDefaultProps.helpLinkText, helpLinkHref: actionBarDefaultProps.helpLinkHref, deleteButtonText: actionBarDefaultProps.deleteButtonText, onDelete: actionBarDefaultProps.onDelete, isDeleteDisabled: actionBarDefaultProps.isSaving })), footerRenderer: ActionBarSlot
-                                ? () => (_jsx(ActionBarSlot, { Default: AutomationDialogActionBar, defaultProps: actionBarDefaultProps }))
+                                ? () => (_jsx(ActionBarSlot, { Default: DefaultAutomationDialogActionBar, defaultProps: actionBarDefaultProps }))
                                 : undefined, isSubmitDisabled: actionBarDefaultProps.isSubmitDisabled, submitButtonTooltipText: actionBarDefaultProps.submitButtonTooltipText, initialFocus: dialogTitleRef, submitOnEnterKey: false, onCancel: onCancel, onSubmit: actionBarDefaultProps.onSubmit, headline: undefined, headerLeftButtonRenderer: () => {
-                                return HeaderSlot ? (_jsx(HeaderSlot, { Default: ScheduledEmailDialogHeader, defaultProps: headerDefaultProps })) : (_jsx(ScheduledEmailDialogHeader, { ...headerDefaultProps }));
+                                return HeaderSlot ? (_jsx(HeaderSlot, { Default: DefaultScheduledEmailDialogHeader, defaultProps: headerDefaultProps })) : (_jsx(DefaultScheduledEmailDialogHeader, { ...headerDefaultProps }));
                             }, children: [
                                 _jsx("h2", { className: "sr-only", id: titleElementId, children: intl.formatMessage({ id: "dialogs.schedule.email.accessibilityTitle" }) }), tabs.length > 1 ? (_jsx(UiTabs, { tabs: tabs, selectedTabId: selectedTabId, onTabSelect: handleTabSelect, size: "medium", accessibilityConfig: {
                                         role: "tablist",
@@ -155,7 +155,7 @@ export function ScheduledMailDialogRenderer({ onBack, onCancel, onDeleteSuccess,
                                         "gd-notification-channel-dialog-with-tabs": tabs.length > 1,
                                     }), children: [topContent, _jsx("div", { className: "gd-divider-with-margin" }), selectedTabId === "filters" ? (_jsx("div", { ref: filtersTabContentRef, className: "gd-schedule-dialog-tab-content", style: tabContentHeight
                                                 ? { minHeight: `${tabContentHeight}px` }
-                                                : undefined, children: FiltersSlot ? (_jsx(FiltersSlot, { Default: ScheduledEmailDialogFilters, defaultProps: filtersDefaultProps })) : (_jsx(ScheduledEmailDialogFilters, { ...filtersDefaultProps })) })) : (_jsxs("div", { ref: generalTabContentRef, className: "gd-schedule-dialog-tab-content", children: [!widget && tabIds.length > 1 ? (_jsx(Message, { type: "progress", className: "gd-schedule-dialog-tab-content-info", children: intl.formatMessage({
+                                                : undefined, children: FiltersSlot ? (_jsx(FiltersSlot, { Default: DefaultScheduledEmailDialogFilters, defaultProps: filtersDefaultProps })) : (_jsx(DefaultScheduledEmailDialogFilters, { ...filtersDefaultProps })) })) : (_jsxs("div", { ref: generalTabContentRef, className: "gd-schedule-dialog-tab-content", children: [!widget && tabIds.length > 1 ? (_jsx(Message, { type: "progress", className: "gd-schedule-dialog-tab-content-info", children: intl.formatMessage({
                                                         id: "dialogs.schedule.email.tabs.info",
                                                     }) })) : null, _jsx(RecurrenceForm, { startDate: startDate, cronExpression: editedAutomation.schedule?.cron ??
                                                         getDefaultCronExpression(startDate), cronDescription: editedAutomation.schedule?.cronDescription, timezone: 
@@ -166,9 +166,9 @@ export function ScheduledMailDialogRenderer({ onBack, onCancel, onDeleteSuccess,
                                                         ? getTimezoneDisplayLabel(editedAutomation.schedule?.timezone ??
                                                             TIMEZONE_DEFAULT.identifier)
                                                         : (editedAutomation.schedule?.timezone ??
-                                                            TIMEZONE_DEFAULT.identifier), dateFormat: dateFormat ?? "MM/dd/yyyy", locale: locale, weekStart: weekStart, onChange: onRecurrenceChange, allowHourlyRecurrence: allowHourlyRecurrence, isWhiteLabeled: isWhiteLabeled, closeDropdownsOnParentScroll: CLOSE_ON_PARENT_SCROLL, onKeyDownSubmit: handleSubmitForm }), _jsx(ContentDivider, { className: "gd-divider-with-margin" }), DestinationSlot ? (_jsx(DestinationSlot, { Default: ScheduledEmailDialogDestination, defaultProps: destinationDefaultProps })) : (_jsx(ScheduledEmailDialogDestination, { ...destinationDefaultProps })), _jsx(ContentDivider, { className: "gd-divider-with-margin" }), RecipientsSlot ? (_jsx(RecipientsSlot, { Default: ScheduledEmailDialogRecipients, defaultProps: recipientsDefaultProps })) : (_jsx(ScheduledEmailDialogRecipients, { ...recipientsDefaultProps })), isInPlatformChannel ? null : (_jsxs(_Fragment, { children: [
+                                                            TIMEZONE_DEFAULT.identifier), dateFormat: dateFormat ?? "MM/dd/yyyy", locale: locale, weekStart: weekStart, onChange: onRecurrenceChange, allowHourlyRecurrence: allowHourlyRecurrence, isWhiteLabeled: isWhiteLabeled, closeDropdownsOnParentScroll: CLOSE_ON_PARENT_SCROLL, onKeyDownSubmit: handleSubmitForm }), _jsx(ContentDivider, { className: "gd-divider-with-margin" }), DestinationSlot ? (_jsx(DestinationSlot, { Default: DefaultScheduledEmailDialogDestination, defaultProps: destinationDefaultProps })) : (_jsx(DefaultScheduledEmailDialogDestination, { ...destinationDefaultProps })), _jsx(ContentDivider, { className: "gd-divider-with-margin" }), RecipientsSlot ? (_jsx(RecipientsSlot, { Default: DefaultScheduledEmailDialogRecipients, defaultProps: recipientsDefaultProps })) : (_jsx(DefaultScheduledEmailDialogRecipients, { ...recipientsDefaultProps })), isInPlatformChannel ? null : (_jsxs(_Fragment, { children: [
                                                         _jsx(SubjectForm, { dashboardTitle: dashboardTitle, editedAutomation: editedAutomation, onChange: onSubjectChange, onKeyDownSubmit: handleSaveScheduledEmail, isSubmitDisabled: isSubmitDisabled }), _jsx(MessageForm, { onChange: onMessageChange, value: editedAutomation.details?.message ?? "" })
-                                                    ] })), widget ? (_jsx(WidgetAttachments, { selectedAttachments: selectedAttachments, onWidgetAttachmentsChange: onWidgetAttachmentsChange, xlsxSettings: xlsxSettings, pdfSettings: pdfSettings, onXlsxSettingsChange: onXlsxSettingsChange, onPdfSettingsChange: onPdfSettingsChange, csvSettings: csvSettings, onCsvSettingsChange: onCsvSettingsChange, csvRawSettings: csvRawSettings, onCsvRawSettingsChange: onCsvRawSettingsChange, isSlidesExportEnabled: isSlidesExportEnabled, isAccessibilityModeEnabled: isAccessibilityModeEnabled, exportTemplates: exportTemplates, slidesTemplateIds: slidesTemplateIds, onSlidesTemplateIdChange: onSlidesTemplateIdChange })) : (_jsx(DashboardAttachments, { selectedAttachments: selectedAttachments, dashboardFilters: dashboardFilters, isCrossFiltering: isCrossFiltering, onDashboardAttachmentsChange: onDashboardAttachmentsChange, xlsxSettings: xlsxSettings, onXlsxSettingsChange: onXlsxSettingsChange, isSlidesExportEnabled: isSlidesExportEnabled, exportTemplates: exportTemplates, slidesTemplateIds: slidesTemplateIds, onSlidesTemplateIdChange: onSlidesTemplateIdChange })), canSelectScheduleTimezone ? (TimezoneSlot ? (_jsx(TimezoneSlot, { Default: ScheduleTimezoneSelect, defaultProps: timezoneDefaultProps })) : (_jsx(ScheduleTimezoneSelect, { ...timezoneDefaultProps }))) : null, enableAutomationEvaluationMode ? (_jsx(EvaluationModeCheckbox, { isShared: editedAutomation.evaluationMode === "SHARED", onChange: onEvaluationModeChange })) : null, errorMessage ? (_jsx(Message, { type: "error", className: cx("gd-notifications-channels-dialog-error", {
+                                                    ] })), widget ? (_jsx(WidgetAttachments, { selectedAttachments: selectedAttachments, onWidgetAttachmentsChange: onWidgetAttachmentsChange, xlsxSettings: xlsxSettings, pdfSettings: pdfSettings, onXlsxSettingsChange: onXlsxSettingsChange, onPdfSettingsChange: onPdfSettingsChange, csvSettings: csvSettings, onCsvSettingsChange: onCsvSettingsChange, csvRawSettings: csvRawSettings, onCsvRawSettingsChange: onCsvRawSettingsChange, isSlidesExportEnabled: isSlidesExportEnabled, isAccessibilityModeEnabled: isAccessibilityModeEnabled, exportTemplates: exportTemplates, slidesTemplateIds: slidesTemplateIds, onSlidesTemplateIdChange: onSlidesTemplateIdChange })) : (_jsx(DashboardAttachments, { selectedAttachments: selectedAttachments, dashboardFilters: dashboardFilters, isCrossFiltering: isCrossFiltering, onDashboardAttachmentsChange: onDashboardAttachmentsChange, xlsxSettings: xlsxSettings, onXlsxSettingsChange: onXlsxSettingsChange, isSlidesExportEnabled: isSlidesExportEnabled, exportTemplates: exportTemplates, slidesTemplateIds: slidesTemplateIds, onSlidesTemplateIdChange: onSlidesTemplateIdChange })), canSelectScheduleTimezone ? (TimezoneSlot ? (_jsx(TimezoneSlot, { Default: DefaultScheduledEmailDialogTimezone, defaultProps: timezoneDefaultProps })) : (_jsx(DefaultScheduledEmailDialogTimezone, { ...timezoneDefaultProps }))) : null, enableAutomationEvaluationMode ? (_jsx(EvaluationModeCheckbox, { isShared: editedAutomation.evaluationMode === "SHARED", onChange: onEvaluationModeChange })) : null, errorMessage ? (_jsx(Message, { type: "error", className: cx("gd-notifications-channels-dialog-error", {
                                                         "gd-notifications-channels-dialog-error-scrollable": true,
                                                     }), children: errorMessage })) : null, getInvalidDatapoints()
                                                     .filter((invalidDatapoint) => invalidDatapoint.severity === "error")
@@ -195,6 +195,15 @@ export function ScheduledMailDialogRenderer({ onBack, onCancel, onDeleteSuccess,
  * 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}.

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogDestination.d.ts

@@ -0,0 +1,11 @@
+import { type IAutomationDialogDestinationProps } from "../../../shared/slots/types.js";
+/**
+ * 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): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=DefaultScheduledEmailDialogDestination.d.ts.map

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogDestination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultScheduledEmailDialogDestination.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogDestination.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,iCAAiC,EAAE,MAAM,gCAAgC,CAAC;AAOxF;;;;;;;GAOG;AACH,wBAAgB,sCAAsC,CAAC,EACnD,oBAAoB,EACpB,6BAA6B,EAC7B,QAAQ,EACX,EAAE,iCAAiC,2CAUnC"}

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogDestination.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { DestinationSelect } from "./DestinationSelect/DestinationSelect.js";
+const OVERLAY_POSITION_TYPE = "sameAsTarget";
+const CLOSE_ON_PARENT_SCROLL = true;
+/**
+ * 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 function DefaultScheduledEmailDialogDestination({ notificationChannels, selectedNotificationChannelId, onChange, }) {
+    return (_jsx(DestinationSelect, { notificationChannels: notificationChannels, selectedItemId: selectedNotificationChannelId, onChange: onChange, closeOnParentScroll: CLOSE_ON_PARENT_SCROLL, overlayPositionType: OVERLAY_POSITION_TYPE }));
+}

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogFilters.d.ts

@@ -0,0 +1,12 @@
+import { type IScheduledEmailDialogFiltersProps } from "../../types.js";
+/**
+ * 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): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=DefaultScheduledEmailDialogFilters.d.ts.map

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogFilters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultScheduledEmailDialogFilters.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogFilters.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,iCAAiC,EAAE,MAAM,gBAAgB,CAAC;AAIxE;;;;;;;;GAQG;AACH,wBAAgB,kCAAkC,CAAC,KAAK,EAAE,iCAAiC,2CAS1F"}

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogFilters.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { AutomationFiltersSelect } from "../../../shared/automationFilters/components/AutomationFiltersSelect.js";
+const OVERLAY_POSITION_TYPE = "sameAsTarget";
+/**
+ * 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 function DefaultScheduledEmailDialogFilters(props) {
+    return (_jsx(AutomationFiltersSelect, { ...props, overlayPositionType: OVERLAY_POSITION_TYPE, hideTitle: true, showAllFilters: true }));
+}

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogHeader.d.ts

@@ -0,0 +1,11 @@
+import { type IScheduledEmailDialogHeaderProps } from "../../types.js";
+/**
+ * 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: import("react").ForwardRefExoticComponent<IScheduledEmailDialogHeaderProps & import("react").RefAttributes<HTMLInputElement>>;
+//# sourceMappingURL=DefaultScheduledEmailDialogHeader.d.ts.map

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogHeader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultScheduledEmailDialogHeader.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogHeader.tsx"],"names":[],"mappings":"AAcA,OAAO,EAAE,KAAK,gCAAgC,EAAE,MAAM,gBAAgB,CAAC;AAEvE;;;;;;;GAOG;AACH,eAAO,MAAM,iCAAiC,+HA4I5C,CAAC"}

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/components/{Header/ScheduleEmailDialogHeader.js → DefaultScheduledEmailDialogHeader.js}

@@ -5,8 +5,16 @@ import cx from "classnames";
 import { useIntl } from "react-intl";
 import { createInvalidDatapoint, createInvalidNode, useValidationContextValue } from "@gooddata/sdk-ui";
 import { Bubble, BubbleHoverTrigger, Button, IconError, useIdPrefixed } from "@gooddata/sdk-ui-kit";
-import { MAX_AUTOMATION_TITLE_LENGTH, isAutomationTitleValid, } from "../../../../shared/utils/automationTitle.js";
-export const ScheduledEmailDialogHeader = forwardRef((props, ref) => {
+import { MAX_AUTOMATION_TITLE_LENGTH, isAutomationTitleValid, } from "../../../shared/utils/automationTitle.js";
+/**
+ * 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 const DefaultScheduledEmailDialogHeader = forwardRef((props, ref) => {
     const { title, placeholder, secondaryTitle, secondaryTitleIcon, isSecondaryTitleVisible, onChange, onBack, onTitleKeyDown, } = props;
     const { formatMessage } = useIntl();
     const validationContextValue = useValidationContextValue(createInvalidNode({ id: "ScheduleEmailDialogHeader" }));
@@ -59,4 +67,4 @@ export const ScheduledEmailDialogHeader = forwardRef((props, ref) => {
                             ] })) : null] }) })
         ] }));
 });
-ScheduledEmailDialogHeader.displayName = "ScheduledEmailDialogHeader";
+DefaultScheduledEmailDialogHeader.displayName = "DefaultScheduledEmailDialogHeader";

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogRecipients.d.ts

@@ -0,0 +1,11 @@
+import { type IScheduledEmailDialogRecipientsProps } from "../../types.js";
+/**
+ * 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): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=DefaultScheduledEmailDialogRecipients.d.ts.map

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogRecipients.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultScheduledEmailDialogRecipients.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogRecipients.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,oCAAoC,EAAE,MAAM,gBAAgB,CAAC;AAI3E;;;;;;;GAOG;AACH,wBAAgB,qCAAqC,CAAC,KAAK,EAAE,oCAAoC,2CAEhG"}

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogRecipients.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { RecipientsSelect } from "./RecipientsSelect/RecipientsSelect.js";
+/**
+ * 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 function DefaultScheduledEmailDialogRecipients(props) {
+    return _jsx(RecipientsSelect, { id: "schedule.email.recipients", ...props });
+}

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogTimezone.d.ts

@@ -0,0 +1,17 @@
+import { type IScheduledEmailDialogTimezoneProps } from "../../types.js";
+/**
+ * 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): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=DefaultScheduledEmailDialogTimezone.d.ts.map

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogTimezone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultScheduledEmailDialogTimezone.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogTimezone.tsx"],"names":[],"mappings":"AAWA,OAAO,EAAE,KAAK,kCAAkC,EAAE,MAAM,gBAAgB,CAAC;AAEzE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mCAAmC,CAAC,EAChD,QAAQ,EACR,SAAS,EACT,uBAAuB,EACvB,gBAAgB,EACnB,EAAE,kCAAkC,2CAiFpC"}

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/components/{ScheduleTimezoneSelect/ScheduleTimezoneSelect.js → DefaultScheduledEmailDialogTimezone.js}

@@ -9,12 +9,14 @@ import { TimezoneSelect, getCurrentTimeByTimezoneId, getTimezoneDisplayLabel, us
  * derives the persisted dashboard/settings timezone at run time); widget schedules always show
  * a concrete timezone.
  *
- * The default implementation of the dialog's `Timezone` slot; its props are the slot contract
- * (see {@link IScheduledEmailDialogTimezoneProps}).
+ * 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`.
  *
- * @internal
+ * @alpha
  */
-export function ScheduleTimezoneSelect({ isWidget, selection, defaultResolvedTimezone, onTimezoneChange, }) {
+export function DefaultScheduledEmailDialogTimezone({ isWidget, selection, defaultResolvedTimezone, onTimezoneChange, }) {
     const intl = useIntl();
     const selectId = useIdPrefixed("schedule-timezone");
     const currentTimeId = useIdPrefixed("schedule-timezone-current-time");

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogActionBar.d.ts

@@ -0,0 +1,36 @@
+import { type IAutomationDialogActionBarProps } from "../../shared/slots/types.js";
+import { type IUseScheduledEmailDialogActionBarPropsInput } from "../state/useScheduledEmailDialogRegionProps.js";
+/**
+ * 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 type IScheduledEmailDialogActionBarBlockProps = IUseScheduledEmailDialogActionBarPropsInput & Partial<IAutomationDialogActionBarProps>;
+/**
+ * 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): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ScheduledEmailDialogActionBar.d.ts.map

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogActionBar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScheduledEmailDialogActionBar.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogActionBar.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,+BAA+B,EAAE,MAAM,6BAA6B,CAAC;AACnF,OAAO,EACH,KAAK,2CAA2C,EAEnD,MAAM,gDAAgD,CAAC;AAIxD;;;;;;;GAOG;AACH,MAAM,MAAM,wCAAwC,GAAG,2CAA2C,GAC9F,OAAO,CAAC,+BAA+B,CAAC,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,wCAAwC,2CAM5F"}

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogActionBar.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { DefaultAutomationDialogActionBar } from "../../shared/slots/DefaultAutomationDialogActionBar.js";
+import { useScheduledEmailDialogActionBarProps, } from "../state/useScheduledEmailDialogRegionProps.js";
+import { WhenScheduledEmailDialogLoaded } from "./WhenScheduledEmailDialogLoaded.js";
+/**
+ * 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 function ScheduledEmailDialogActionBar(props) {
+    return (_jsx(WhenScheduledEmailDialogLoaded, { children: _jsx(ConnectedScheduledEmailDialogActionBar, { ...props }) }));
+}
+function ConnectedScheduledEmailDialogActionBar({ onCancel, onSubmit, isSaving, onDelete, ...overrides }) {
+    const defaultProps = useScheduledEmailDialogActionBarProps({ onCancel, onSubmit, isSaving, onDelete });
+    return _jsx(DefaultAutomationDialogActionBar, { ...defaultProps, ...overrides });
+}

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogDestination.d.ts

@@ -0,0 +1,13 @@
+import { type IAutomationDialogDestinationProps } from "../../shared/slots/types.js";
+/**
+ * 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>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ScheduledEmailDialogDestination.d.ts.map

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogDestination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScheduledEmailDialogDestination.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogDestination.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,iCAAiC,EAAE,MAAM,6BAA6B,CAAC;AAMrF;;;;;;;;;GASG;AACH,wBAAgB,+BAA+B,CAAC,SAAS,EAAE,OAAO,CAAC,iCAAiC,CAAC,2CAMpG"}

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogDestination.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { DefaultScheduledEmailDialogDestination } from "../DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogDestination.js";
+import { useScheduledEmailDialogDestinationProps } from "../state/useScheduledEmailDialogRegionProps.js";
+import { WhenScheduledEmailDialogLoaded } from "./WhenScheduledEmailDialogLoaded.js";
+/**
+ * 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 function ScheduledEmailDialogDestination(overrides) {
+    return (_jsx(WhenScheduledEmailDialogLoaded, { children: _jsx(ConnectedScheduledEmailDialogDestination, { ...overrides }) }));
+}
+function ConnectedScheduledEmailDialogDestination(overrides) {
+    const defaultProps = useScheduledEmailDialogDestinationProps();
+    return _jsx(DefaultScheduledEmailDialogDestination, { ...defaultProps, ...overrides });
+}

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogFilters.d.ts

@@ -0,0 +1,17 @@
+import { type IScheduledEmailDialogFiltersProps } from "../types.js";
+/**
+ * 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>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ScheduledEmailDialogFilters.d.ts.map

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogFilters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScheduledEmailDialogFilters.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogFilters.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,iCAAiC,EAAE,MAAM,aAAa,CAAC;AAIrE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,OAAO,CAAC,iCAAiC,CAAC,2CAMhG"}

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogFilters.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { DefaultScheduledEmailDialogFilters } from "../DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogFilters.js";
+import { useScheduledEmailDialogFiltersProps } from "../state/useScheduledEmailDialogRegionProps.js";
+import { WhenScheduledEmailDialogLoaded } from "./WhenScheduledEmailDialogLoaded.js";
+/**
+ * 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 function ScheduledEmailDialogFilters(overrides) {
+    return (_jsx(WhenScheduledEmailDialogLoaded, { children: _jsx(ConnectedScheduledEmailDialogFilters, { ...overrides }) }));
+}
+function ConnectedScheduledEmailDialogFilters(overrides) {
+    const defaultProps = useScheduledEmailDialogFiltersProps();
+    return _jsx(DefaultScheduledEmailDialogFilters, { ...defaultProps, ...overrides });
+}

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogHeader.d.ts

@@ -0,0 +1,17 @@
+import { type IScheduledEmailDialogHeaderProps } from "../types.js";
+/**
+ * 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: import("react").ForwardRefExoticComponent<Partial<IScheduledEmailDialogHeaderProps> & import("react").RefAttributes<HTMLInputElement>>;
+//# sourceMappingURL=ScheduledEmailDialogHeader.d.ts.map

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogHeader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScheduledEmailDialogHeader.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogHeader.tsx"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,gCAAgC,EAAE,MAAM,aAAa,CAAC;AAMpE;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,0BAA0B,wIASrC,CAAC"}

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogHeader.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { forwardRef } from "react";
+import { DefaultScheduledEmailDialogHeader } from "../DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogHeader.js";
+import { useScheduledEmailDialogHeaderProps } from "../state/useScheduledEmailDialogRegionProps.js";
+import { WhenScheduledEmailDialogLoaded } from "./WhenScheduledEmailDialogLoaded.js";
+const noop = () => { };
+/**
+ * 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 const ScheduledEmailDialogHeader = forwardRef(function ScheduledEmailDialogHeader(props, ref) {
+    return (_jsx(WhenScheduledEmailDialogLoaded, { children: _jsx(ConnectedScheduledEmailDialogHeader, { ...props, ref: ref }) }));
+});
+const ConnectedScheduledEmailDialogHeader = forwardRef(function ConnectedScheduledEmailDialogHeader({ onBack, onTitleKeyDown, ...overrides }, ref) {
+    const defaultProps = useScheduledEmailDialogHeaderProps({
+        onBack,
+        onTitleKeyDown: onTitleKeyDown ?? noop,
+        ref,
+    });
+    return _jsx(DefaultScheduledEmailDialogHeader, { ...defaultProps, ...overrides });
+});

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogRecipients.d.ts

@@ -0,0 +1,15 @@
+import { type IScheduledEmailDialogRecipientsProps } from "../types.js";
+/**
+ * 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>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ScheduledEmailDialogRecipients.d.ts.map

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogRecipients.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScheduledEmailDialogRecipients.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogRecipients.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,oCAAoC,EAAE,MAAM,aAAa,CAAC;AAMxE;;;;;;;;;;;GAWG;AACH,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,OAAO,CAAC,oCAAoC,CAAC,2CAMlG"}

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogRecipients.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { DefaultScheduledEmailDialogRecipients } from "../DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogRecipients.js";
+import { useScheduledEmailDialogRecipientsProps } from "../state/useScheduledEmailDialogRegionProps.js";
+import { WhenScheduledEmailDialogLoaded } from "./WhenScheduledEmailDialogLoaded.js";
+const noop = () => { };
+/**
+ * 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 function ScheduledEmailDialogRecipients(props) {
+    return (_jsx(WhenScheduledEmailDialogLoaded, { children: _jsx(ConnectedScheduledEmailDialogRecipients, { ...props }) }));
+}
+function ConnectedScheduledEmailDialogRecipients({ onKeyDownSubmit, ...overrides }) {
+    const defaultProps = useScheduledEmailDialogRecipientsProps({ onKeyDownSubmit: onKeyDownSubmit ?? noop });
+    return _jsx(DefaultScheduledEmailDialogRecipients, { ...defaultProps, ...overrides });
+}

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogTimezone.d.ts

@@ -0,0 +1,15 @@
+import { type ScheduledEmailDialogTimezoneDefaultProps } from "../types.js";
+/**
+ * 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>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ScheduledEmailDialogTimezone.d.ts.map

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogTimezone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScheduledEmailDialogTimezone.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogTimezone.tsx"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,wCAAwC,EAAE,MAAM,aAAa,CAAC;AAI5E;;;;;;;;;;;GAWG;AACH,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,OAAO,CAAC,wCAAwC,CAAC,2CAMxG"}