@gooddata/sdk-ui-dashboard 11.53.0-alpha.5 → 11.53.0-alpha.7

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

@@ -4,7 +4,7 @@ import { useCallback, useMemo, useRef, useState } from "react";
 import cx from "classnames";
 import { defineMessage, useIntl } from "react-intl";
 import { ValidationContextStore, createInvalidNode, useValidationContextValue } from "@gooddata/sdk-ui";
-import { Button, ConfirmDialogBase, ContentDivider, Hyperlink, Message, Overlay, OverlayController, OverlayControllerProvider, RecurrenceForm, ScrollablePanel, UiIcon, UiTabs, isEnterKey, useIdPrefixed, } from "@gooddata/sdk-ui-kit";
+import { Button, ConfirmDialogBase, ContentDivider, Hyperlink, Message, Overlay, OverlayController, OverlayControllerProvider, RecurrenceForm, ScrollablePanel, UiIcon, UiTabs, getTimezoneDisplayLabel, isEnterKey, useIdPrefixed, } from "@gooddata/sdk-ui-kit";
 import { DASHBOARD_DIALOG_OVERS_Z_INDEX } from "../../../constants/zIndex.js";
 import { IntlWrapper } from "../../../localization/IntlWrapper.js";
 import { useAutomationsContext } from "../../contexts/AutomationsContext.js";
@@ -29,6 +29,7 @@ import { ScheduledEmailDialogHeader } from "./components/Header/ScheduleEmailDia
 import { MessageForm } from "./components/MessageForm/MessageForm.js";
 import { RecipientsSelect } from "./components/RecipientsSelect/RecipientsSelect.js";
 import { ScheduledEmailDialogFilters } from "./components/ScheduledEmailDialogFilters.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";
@@ -44,6 +45,7 @@ function ScheduledEmailDialogFooter({ isWhiteLabeled, helpTextId, scheduledExpor
 export function ScheduledMailDialogRenderer({ onBack, onCancel, onDeleteSuccess, onDeleteError, onError, onSave, onSaveError, onSaveSuccess, onSubmit, onSuccess, slots, }) {
     const HeaderSlot = slots?.Header;
     const FiltersSlot = slots?.Filters;
+    const TimezoneSlot = slots?.Timezone;
     const intl = useIntl();
     const dialogTitleRef = useRef(null);
     const generalTabContentRef = useRef(null);
@@ -57,13 +59,14 @@ export function ScheduledMailDialogRenderer({ onBack, onCancel, onDeleteSuccess,
         setScheduledEmailToDelete(null);
     };
     const { locale, dashboardTitle, dateFormat, weekStart, maxAutomationsRecipients, allowHourlyRecurrence, isCrossFiltering, isExecutionTimestampMode, isSlidesExportEnabled, isAccessibilityModeEnabled, enableAutomationEvaluationMode, } = useDefaultScheduledEmailDialogData();
-    const { editedAutomation, originalAutomation, startDate } = useScheduledExportDraft();
-    const { onTitleChange, onRecurrenceChange, onEvaluationModeChange, onDestinationChange, onRecipientsChange, onSubjectChange, onMessageChange, onDashboardAttachmentsChange, onWidgetAttachmentsChange, onXlsxSettingsChange, onPdfSettingsChange, onCsvSettingsChange, onCsvRawSettingsChange, onSlidesTemplateIdChange, } = useScheduledExportActions();
+    const { editedAutomation, originalAutomation, startDate, isTimezoneFeatureEnabled, canSelectScheduleTimezone, scheduleTimezoneSelection, defaultResolvedTimezone, scheduleTimezoneIsStale, } = useScheduledExportDraft();
+    const { onTitleChange, onRecurrenceChange, onEvaluationModeChange, onDestinationChange, onRecipientsChange, onSubjectChange, onMessageChange, onDashboardAttachmentsChange, onWidgetAttachmentsChange, onXlsxSettingsChange, onPdfSettingsChange, onCsvSettingsChange, onCsvRawSettingsChange, onSlidesTemplateIdChange, onScheduleTimezoneChange, applyCurrentScheduleTimezone, } = useScheduledExportActions();
     const { defaultUser } = useScheduledExportData();
     const { selectedFilters, availableFilters, storeFilters, filtersByTab, editedFiltersByTab, onFiltersChange, onFiltersByTabChange, onApplyCurrentFilters, onStoreFiltersChange, automationIsValid, parametersEnabled, visibleParametersByTab, availableParametersByTab, flatTabId, onParameterAdd, onParameterChange, onParameterDelete, onParameterAddByTab, onParameterChangeByTab, onParameterDeleteByTab, applyLatest: applyLatestParameters, } = useScheduledExportFilters();
     const { selectedAttachments, xlsxSettings, pdfSettings, csvSettings, csvRawSettings, slidesTemplateIds } = useScheduledExportAttachments();
     const { isSubmitDisabled, validationErrorMessage, isParentValid, allowExternalRecipients, allowOnlyLoggedUserRecipients, } = useScheduledExportDialogValidity();
-    const [isApplyCurrentFiltersDialogOpen, setIsApplyCurrentFiltersDialogOpen] = useState(!automationIsValid);
+    // a stale schedule timezone repairs through the same consent dialog as stale filters
+    const [isApplyCurrentFiltersDialogOpen, setIsApplyCurrentFiltersDialogOpen] = useState(!automationIsValid || scheduleTimezoneIsStale);
     const { handleSaveScheduledEmail, isSavingScheduledEmail, savingErrorMessage } = useSaveScheduledEmailToBackend(editedAutomation, {
         onSuccess,
         onError,
@@ -88,6 +91,14 @@ export function ScheduledMailDialogRenderer({ onBack, onCancel, onDeleteSuccess,
             handleSaveScheduledEmail();
         }
     }, [submitDisabled, handleSaveScheduledEmail]);
+    // the exact props the default dialog renders the "Time zone" section with; also handed to the
+    // Timezone slot so a wrap keeps the default behavior
+    const timezoneDefaultProps = {
+        isWidget: !!widget,
+        selection: scheduleTimezoneSelection,
+        defaultResolvedTimezone,
+        onTimezoneChange: onScheduleTimezoneChange,
+    };
     const { secondaryTitle, secondaryTitleIcon } = useMemo(() => {
         if (widget) {
             return {
@@ -128,9 +139,14 @@ export function ScheduledMailDialogRenderer({ onBack, onCancel, onDeleteSuccess,
     // internally so it survives the General tab unmounting when the user switches to Filters.
     const tabContentHeight = useElementHeightSnapshot(generalTabContentRef, selectedTabId);
     if (isApplyCurrentFiltersDialogOpen) {
-        return (_jsx(ApplyCurrentFiltersConfirmDialog, { automationType: "schedule", onCancel: () => onCancel?.(), onEdit: () => {
-                onApplyCurrentFilters();
-                applyLatestParameters();
+        return (_jsx(ApplyCurrentFiltersConfirmDialog, { automationType: "schedule", filtersChanged: !automationIsValid, timezoneChanged: scheduleTimezoneIsStale, onCancel: () => onCancel?.(), onEdit: () => {
+                // each repair only fixes its own staleness: a timezone-only repair must not
+                // replace intentionally snapshotted, still-valid filters (and vice versa)
+                if (!automationIsValid) {
+                    onApplyCurrentFilters();
+                    applyLatestParameters();
+                }
+                applyCurrentScheduleTimezone();
                 setIsApplyCurrentFiltersDialogOpen(false);
             } }));
     }
@@ -206,10 +222,17 @@ export function ScheduledMailDialogRenderer({ onBack, onCancel, onDeleteSuccess,
                                                 : 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({
                                                         id: "dialogs.schedule.email.tabs.info",
                                                     }) })) : null, _jsx(RecurrenceForm, { startDate: startDate, cronExpression: editedAutomation.schedule?.cron ??
-                                                        getDefaultCronExpression(startDate), cronDescription: editedAutomation.schedule?.cronDescription, timezone: 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" }), _jsx(DestinationSelect, { notificationChannels: notificationChannels, selectedItemId: editedAutomation.notificationChannel, onChange: onDestinationChange, closeOnParentScroll: CLOSE_ON_PARENT_SCROLL, overlayPositionType: OVERLAY_POSITION_TYPE }), _jsx(ContentDivider, { className: "gd-divider-with-margin" }), _jsx(RecipientsSelect, { id: "schedule.email.recipients", loggedUser: defaultUser, value: editedAutomation.recipients ?? [], originalValue: originalAutomation.recipients || [], onChange: onRecipientsChange, allowEmptySelection: true, allowOnlyLoggedUserRecipients: allowOnlyLoggedUserRecipients, allowExternalRecipients: allowExternalRecipients, maxRecipients: maxAutomationsRecipients, notificationChannels: notificationChannels, notificationChannelId: editedAutomation.notificationChannel, onKeyDownSubmit: handleSubmitForm, externalRecipientOverride: externalRecipientOverride }), isInPlatformChannel ? null : (_jsxs(_Fragment, { children: [
+                                                        getDefaultCronExpression(startDate), cronDescription: editedAutomation.schedule?.cronDescription, timezone: 
+                                                    // display-only prop; with the timezone feature on,
+                                                    // show the friendly label used by the time zone
+                                                    // picker instead of the raw IANA ID
+                                                    isTimezoneFeatureEnabled
+                                                        ? 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" }), _jsx(DestinationSelect, { notificationChannels: notificationChannels, selectedItemId: editedAutomation.notificationChannel, onChange: onDestinationChange, closeOnParentScroll: CLOSE_ON_PARENT_SCROLL, overlayPositionType: OVERLAY_POSITION_TYPE }), _jsx(ContentDivider, { className: "gd-divider-with-margin" }), _jsx(RecipientsSelect, { id: "schedule.email.recipients", loggedUser: defaultUser, value: editedAutomation.recipients ?? [], originalValue: originalAutomation.recipients || [], onChange: onRecipientsChange, allowEmptySelection: true, allowOnlyLoggedUserRecipients: allowOnlyLoggedUserRecipients, allowExternalRecipients: allowExternalRecipients, maxRecipients: maxAutomationsRecipients, notificationChannels: notificationChannels, notificationChannelId: editedAutomation.notificationChannel, onKeyDownSubmit: handleSubmitForm, externalRecipientOverride: externalRecipientOverride }), 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 })), 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: 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", {
                                                         "gd-notifications-channels-dialog-error-scrollable": true,
                                                     }), children: errorMessage })) : null, getInvalidDatapoints()
                                                     .filter((invalidDatapoint) => invalidDatapoint.severity === "error")

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

@@ -0,0 +1,15 @@
+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.
+ *
+ * The default implementation of the dialog's `Timezone` slot; its props are the slot contract
+ * (see {@link IScheduledEmailDialogTimezoneProps}).
+ *
+ * @internal
+ */
+export declare function ScheduleTimezoneSelect({ isWidget, selection, defaultResolvedTimezone, onTimezoneChange }: IScheduledEmailDialogTimezoneProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ScheduleTimezoneSelect.d.ts.map

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

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

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

@@ -0,0 +1,58 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { FormattedMessage, useIntl } from "react-intl";
+import { TimezoneSelect, getCurrentTimeByTimezoneId, getTimezoneDisplayLabel, useIdPrefixed, } from "@gooddata/sdk-ui-kit";
+/**
+ * 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.
+ *
+ * The default implementation of the dialog's `Timezone` slot; its props are the slot contract
+ * (see {@link IScheduledEmailDialogTimezoneProps}).
+ *
+ * @internal
+ */
+export function ScheduleTimezoneSelect({ isWidget, selection, defaultResolvedTimezone, onTimezoneChange, }) {
+    const intl = useIntl();
+    const selectId = useIdPrefixed("schedule-timezone");
+    const currentTimeId = useIdPrefixed("schedule-timezone-current-time");
+    const usageNoteId = useIdPrefixed("schedule-timezone-note");
+    const isDefaultSelected = selection.id === undefined;
+    const currentTimezoneId = selection.id ?? defaultResolvedTimezone;
+    const currentTime = currentTimezoneId ? getCurrentTimeByTimezoneId(currentTimezoneId) : "";
+    // "Now: 14:45" preview of the current time in the effective selection; the Default option
+    // additionally prints out the concrete timezone it resolves to right now.
+    const currentTimeCaption = currentTime
+        ? isDefaultSelected
+            ? intl.formatMessage({ id: "dialogs.automation.timezone.defaultNow" }, { timezone: getTimezoneDisplayLabel(currentTimezoneId), time: currentTime })
+            : intl.formatMessage({ id: "dialogs.automation.timezone.now" }, { time: currentTime })
+        : null;
+    // the current-time caption and the usage note describe the trigger for assistive tech
+    const describedBy = [currentTimeCaption ? currentTimeId : undefined, usageNoteId]
+        .filter(Boolean)
+        .join(" ");
+    return (_jsxs("div", { className: "gd-input-component gd-schedule-timezone-field s-gd-schedule-timezone", children: [
+            _jsx("label", { htmlFor: selectId, className: "gd-label", children: _jsx(FormattedMessage, { id: "dialogs.schedule.email.timezone" }) }), _jsxs("div", { className: "gd-schedule-timezone-field__content", children: [
+                    _jsxs("div", { className: "gd-schedule-timezone-field__row", children: [
+                            _jsx(TimezoneSelect, { value: selection.id, onChange: onTimezoneChange, id: selectId, ariaDescribedBy: describedBy, showTooltip: true, specialItems: isWidget
+                                    ? []
+                                    : [
+                                        {
+                                            id: undefined,
+                                            label: intl.formatMessage({
+                                                id: "dialogs.automation.timezone.default",
+                                            }),
+                                            tooltip: intl.formatMessage({
+                                                id: "dialogs.automation.timezone.default.tooltip",
+                                            }),
+                                        },
+                                    ], searchPlaceholder: intl.formatMessage({
+                                    id: "dialogs.automation.timezone.select.searchPlaceholder",
+                                }), ariaLabel: intl.formatMessage({ id: "dialogs.schedule.email.timezone" }), noMatchLabel: intl.formatMessage({
+                                    id: "dialogs.automation.timezone.select.noMatch",
+                                }) }), currentTimeCaption ? (_jsx("div", { id: currentTimeId, className: "gd-schedule-timezone-field__current-time s-gd-schedule-timezone-current-time", children: currentTimeCaption })) : null] }), _jsx("div", { id: usageNoteId, className: "gd-schedule-timezone-field__message s-gd-schedule-timezone-note", children: _jsx(FormattedMessage, { id: "dialogs.automation.timezone.usage" }) })
+                ] })
+        ] }));
+}

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/hooks/useExportTimezones.d.ts

@@ -0,0 +1,52 @@
+import { type IScheduleTimezoneSelection } from "../../types.js";
+/**
+ * Export-content timezone inputs for scheduled export definitions (unrelated to the schedule
+ * cron timezone). What gets baked into a NEW schedule — and what the Default option means —
+ * differs by schedule kind, because of what the backend can derive at run time:
+ *
+ * - Dashboard schedules: the backend loads the stored dashboard, so only values it cannot derive
+ *   (view-mode override, browser resolution) are baked; Default resolves through the persisted
+ *   dashboard configuration to the workspace/organization setting.
+ * - Widget schedules: the backend service has ONLY the workspace/organization settings available
+ *   (it does not load the dashboard object), so anything dashboard-scoped — the stored dashboard
+ *   configuration, the view-mode override, or the browser resolution — must be baked into the
+ *   definition. Default then means just the workspace/organization setting.
+ *
+ * The store-derived inputs arrive via {@link useAutomationsContext}, filled by the connectors
+ * layer — the scheduledEmail tree must not read the dashboard store itself.
+ */
+export declare function useExportTimezones(isWidgetSchedule: boolean): {
+    /**
+     * The enableDashboardTimezone feature flag; timezone-related presentation changes in the
+     * dialog are gated by it.
+     */
+    isTimezoneFeatureEnabled: boolean;
+    /**
+     * Whether the schedule may define its own export timezone (the "Time zone" section renders
+     * a dropdown): the feature is enabled and the dashboard allows the view-mode timezone
+     * override. False also for dashboards that only show the timezone info (showTimezoneInfo
+     * without the override) — the schedule dialog then has no timezone section.
+     */
+    canSelectScheduleTimezone: boolean;
+    workspaceTimezone: string | undefined;
+    effectiveTimezone: string | undefined;
+    /**
+     * Timezone to bake into a NEW schedule's export definitions; undefined means nothing is baked
+     * and the backend derives the timezone at run time.
+     */
+    exportTimezoneId: string | undefined;
+    /**
+     * Initial dropdown selection for a new schedule: dashboard schedules start at the Default
+     * option unless an override/browser resolution must be baked; widget schedules always start
+     * at a concrete resolved timezone (there is no Default for them).
+     */
+    initialSelection: IScheduleTimezoneSelection;
+    /**
+     * Concrete timezone the Default option currently resolves to, for display purposes: the
+     * resolution the backend derives at run time for this schedule kind. The session-only
+     * view-mode override is deliberately excluded — a schedule left at Default never sees it
+     * (the override is instead baked as an explicit timezone via `exportTimezoneId`).
+     */
+    defaultResolvedTimezone: string | undefined;
+};
+//# sourceMappingURL=useExportTimezones.d.ts.map

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/hooks/useExportTimezones.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExportTimezones.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/hooks/useExportTimezones.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AAEjE;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,gBAAgB,EAAE,OAAO,GAAG;IAC3D;;;OAGG;IACH,wBAAwB,EAAE,OAAO,CAAC;IAClC;;;;;OAKG;IACH,yBAAyB,EAAE,OAAO,CAAC;IACnC,iBAAiB,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,iBAAiB,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC;;;OAGG;IACH,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC;;;;OAIG;IACH,gBAAgB,EAAE,0BAA0B,CAAC;IAC7C;;;;;OAKG;IACH,uBAAuB,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/C,CAsCA"}

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

@@ -0,0 +1,46 @@
+// (C) 2026 GoodData Corporation
+import { resolveTimezoneId } from "@gooddata/sdk-model";
+import { useAutomationsContext } from "../../../contexts/AutomationsContext.js";
+/**
+ * Export-content timezone inputs for scheduled export definitions (unrelated to the schedule
+ * cron timezone). What gets baked into a NEW schedule — and what the Default option means —
+ * differs by schedule kind, because of what the backend can derive at run time:
+ *
+ * - Dashboard schedules: the backend loads the stored dashboard, so only values it cannot derive
+ *   (view-mode override, browser resolution) are baked; Default resolves through the persisted
+ *   dashboard configuration to the workspace/organization setting.
+ * - Widget schedules: the backend service has ONLY the workspace/organization settings available
+ *   (it does not load the dashboard object), so anything dashboard-scoped — the stored dashboard
+ *   configuration, the view-mode override, or the browser resolution — must be baked into the
+ *   definition. Default then means just the workspace/organization setting.
+ *
+ * The store-derived inputs arrive via {@link useAutomationsContext}, filled by the connectors
+ * layer — the scheduledEmail tree must not read the dashboard store itself.
+ */
+export function useExportTimezones(isWidgetSchedule) {
+    const { exportTimezones } = useAutomationsContext();
+    const { isTimezoneFeatureEnabled = false, allowUserOverrideInViewMode = false, configuredTimezoneId = undefined, workspaceTimezone = undefined, effectiveTimezone = undefined, scheduledExportTimezone: explicitTimezone = undefined, } = exportTimezones ?? {};
+    const canSelectScheduleTimezone = isTimezoneFeatureEnabled && allowUserOverrideInViewMode;
+    const initialSelection = isWidgetSchedule
+        ? effectiveTimezone
+            ? { id: effectiveTimezone, shouldSave: true }
+            : { id: workspaceTimezone, shouldSave: false }
+        : explicitTimezone
+            ? { id: explicitTimezone, shouldSave: true }
+            : { id: undefined, shouldSave: false };
+    const exportTimezoneId = initialSelection.shouldSave ? initialSelection.id : undefined;
+    const defaultResolvedTimezone = isWidgetSchedule
+        ? workspaceTimezone
+        : configuredTimezoneId
+            ? resolveTimezoneId(configuredTimezoneId)
+            : workspaceTimezone;
+    return {
+        isTimezoneFeatureEnabled,
+        canSelectScheduleTimezone,
+        workspaceTimezone,
+        effectiveTimezone,
+        exportTimezoneId,
+        initialSelection,
+        defaultResolvedTimezone,
+    };
+}

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/hooks/useScheduleTimezone.d.ts

@@ -0,0 +1,47 @@
+import { type Dispatch, type SetStateAction } from "react";
+import { type IAutomationMetadataObject, type IAutomationMetadataObjectDefinition, type IWidget } from "@gooddata/sdk-model";
+import { type IScheduleTimezoneSelection } from "../../types.js";
+export interface IUseScheduleTimezoneProps {
+    scheduledExportToEdit?: IAutomationMetadataObject;
+    widget?: IWidget;
+    setEditedAutomation: Dispatch<SetStateAction<IAutomationMetadataObjectDefinition>>;
+}
+/**
+ * Owns the "Time zone" section state of the scheduled-email dialog.
+ *
+ * The selection (see {@link IScheduleTimezoneSelection}) decides what is baked into the export
+ * definitions: backend-derivable values are displayed but not saved, everything else stores the
+ * concrete timezone.
+ * Widget schedules always show a concrete resolved timezone (no Default option); dashboard
+ * schedules offer the Default option. The cron `schedule.timezone` is a different concept (when
+ * the schedule fires) and is never touched here.
+ */
+export declare function useScheduleTimezone({ scheduledExportToEdit, widget, setEditedAutomation }: IUseScheduleTimezoneProps): {
+    isTimezoneFeatureEnabled: boolean;
+    canSelectScheduleTimezone: boolean;
+    scheduleTimezoneSelection: IScheduleTimezoneSelection;
+    /**
+     * Concrete timezone the dashboard-schedule Default option currently resolves to
+     * (display only).
+     */
+    defaultResolvedTimezone: string | undefined;
+    onScheduleTimezoneChange: (timezoneId: string | undefined) => void;
+    /**
+     * True when the edited schedule cannot behave correctly as stored (widget schedule
+     * missing a dashboard-scoped timezone); feeds the apply-current-state confirmation.
+     */
+    scheduleTimezoneIsStale: boolean;
+    applyCurrentScheduleTimezone: () => void;
+    /**
+     * Live value for export definitions created after the dialog opened (attachment changes).
+     * Active when the section is interactive, and also when an edited schedule carries a
+     * stored timezone while the section is hidden — new definitions must then inherit the
+     * stored value instead of the store-derived default.
+     */
+    scheduleTimezone: {
+        active: boolean;
+        timezoneId: string | undefined;
+    };
+};
+export type ScheduleTimezoneState = ReturnType<typeof useScheduleTimezone>;
+//# sourceMappingURL=useScheduleTimezone.d.ts.map

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/hooks/useScheduleTimezone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useScheduleTimezone.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/hooks/useScheduleTimezone.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,cAAc,EAAyB,MAAM,OAAO,CAAC;AAElF,OAAO,EACH,KAAK,yBAAyB,EAC9B,KAAK,mCAAmC,EACxC,KAAK,OAAO,EACf,MAAM,qBAAqB,CAAC;AAM7B,OAAO,EAAE,KAAK,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AAIjE,MAAM,WAAW,yBAAyB;IACtC,qBAAqB,CAAC,EAAE,yBAAyB,CAAC;IAClD,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,mBAAmB,EAAE,QAAQ,CAAC,cAAc,CAAC,mCAAmC,CAAC,CAAC,CAAC;CACtF;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,EAChC,qBAAqB,EACrB,MAAM,EACN,mBAAmB,EACtB,EAAE,yBAAyB;;;;IAiEpB;;;OAGG;;;IAGH;;;OAGG;;;IAGH;;;;;OAKG;;;;;EAMV;AAED,MAAM,MAAM,qBAAqB,GAAG,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

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

@@ -0,0 +1,90 @@
+// (C) 2026 GoodData Corporation
+import { useCallback, useState } from "react";
+import { getExportDefinitionsTimezone, withExportDefinitionsTimezone, } from "../../state/exportDefinitions.js";
+import { useExportTimezones } from "./useExportTimezones.js";
+/**
+ * Owns the "Time zone" section state of the scheduled-email dialog.
+ *
+ * The selection (see {@link IScheduleTimezoneSelection}) decides what is baked into the export
+ * definitions: backend-derivable values are displayed but not saved, everything else stores the
+ * concrete timezone.
+ * Widget schedules always show a concrete resolved timezone (no Default option); dashboard
+ * schedules offer the Default option. The cron `schedule.timezone` is a different concept (when
+ * the schedule fires) and is never touched here.
+ */
+export function useScheduleTimezone({ scheduledExportToEdit, widget, setEditedAutomation, }) {
+    const isWidget = !!widget;
+    const { isTimezoneFeatureEnabled, canSelectScheduleTimezone, initialSelection, defaultResolvedTimezone } = useExportTimezones(isWidget);
+    const storedTimezoneId = getExportDefinitionsTimezone(scheduledExportToEdit);
+    const [selection, setSelection] = useState(() => {
+        if (!scheduledExportToEdit) {
+            return initialSelection;
+        }
+        if (storedTimezoneId) {
+            return { id: storedTimezoneId, shouldSave: true };
+        }
+        // an edited schedule without a stored timezone: widget schedules still present the
+        // currently resolved timezone (they have no Default), dashboard schedules sit at Default
+        return isWidget ? initialSelection : { id: undefined, shouldSave: false };
+    });
+    // A widget schedule must carry any dashboard-scoped timezone in its definitions (the backend
+    // cannot derive it). An edited widget schedule without a stored timezone while a
+    // dashboard-scoped one is effective is therefore structurally stale — same category as
+    // filters that no longer exist on the dashboard — and is repaired through the
+    // apply-current-state confirmation flow, never silently. Deliberately not gated by the
+    // section's visibility: the repair matters even when the dashboard forbids the view-mode
+    // override and the dialog shows no Time zone section.
+    const scheduleTimezoneIsStale = isTimezoneFeatureEnabled &&
+        isWidget &&
+        !!scheduledExportToEdit &&
+        !storedTimezoneId &&
+        initialSelection.shouldSave &&
+        !!initialSelection.id;
+    // Both handlers are published on the actions context, so they hold their identity across
+    // draft edits; they depend on the selection's primitive fields because `initialSelection`
+    // is rebuilt on every render.
+    const { id: initialSelectionId, shouldSave: initialSelectionShouldSave } = initialSelection;
+    const applyCurrentScheduleTimezone = useCallback(() => {
+        if (!scheduleTimezoneIsStale) {
+            return;
+        }
+        setSelection({ id: initialSelectionId, shouldSave: initialSelectionShouldSave });
+        setEditedAutomation((s) => withExportDefinitionsTimezone(s, initialSelectionId));
+    }, [scheduleTimezoneIsStale, initialSelectionId, initialSelectionShouldSave, setEditedAutomation]);
+    const onScheduleTimezoneChange = useCallback((timezoneId) => {
+        const nextSelection = timezoneId === undefined
+            ? { id: undefined, shouldSave: false }
+            : { id: timezoneId, shouldSave: true };
+        setSelection(nextSelection);
+        if (canSelectScheduleTimezone) {
+            setEditedAutomation((s) => withExportDefinitionsTimezone(s, nextSelection.id));
+        }
+    }, [canSelectScheduleTimezone, setEditedAutomation]);
+    return {
+        isTimezoneFeatureEnabled,
+        canSelectScheduleTimezone,
+        scheduleTimezoneSelection: selection,
+        /**
+         * Concrete timezone the dashboard-schedule Default option currently resolves to
+         * (display only).
+         */
+        defaultResolvedTimezone,
+        onScheduleTimezoneChange,
+        /**
+         * True when the edited schedule cannot behave correctly as stored (widget schedule
+         * missing a dashboard-scoped timezone); feeds the apply-current-state confirmation.
+         */
+        scheduleTimezoneIsStale,
+        applyCurrentScheduleTimezone,
+        /**
+         * Live value for export definitions created after the dialog opened (attachment changes).
+         * Active when the section is interactive, and also when an edited schedule carries a
+         * stored timezone while the section is hidden — new definitions must then inherit the
+         * stored value instead of the store-derived default.
+         */
+        scheduleTimezone: {
+            active: canSelectScheduleTimezone || !!storedTimezoneId,
+            timezoneId: selection.shouldSave ? selection.id : undefined,
+        },
+    };
+}

package/esm/presentation/automations/scheduledEmail/state/ScheduledEmailDialogStateProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ScheduledEmailDialogStateProvider.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/state/ScheduledEmailDialogStateProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAW,MAAM,OAAO,CAAC;AAyBhD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iCAAiC,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,2CAQtF"}
+{"version":3,"file":"ScheduledEmailDialogStateProvider.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/state/ScheduledEmailDialogStateProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAW,MAAM,OAAO,CAAC;AA0BhD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iCAAiC,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,2CAQtF"}

package/esm/presentation/automations/scheduledEmail/state/ScheduledEmailDialogStateProvider.js

@@ -4,6 +4,7 @@ import { useMemo } from "react";
 import { useAutomationsContext } from "../../contexts/AutomationsContext.js";
 import { useScheduledEmailDialogContext } from "../../contexts/ScheduledEmailDialogContext.js";
 import { useAutomationFiltersSelect } from "../../shared/automationFilters/useAutomationFiltersSelect.js";
+import { useScheduleTimezone } from "../DefaultScheduledEmailDialog/hooks/useScheduleTimezone.js";
 import { getDefaultPdfPageSize } from "../utils/pdfPageSize.js";
 import { ScheduledExportActionsContextProvider, } from "./ScheduledExportActionsContext.js";
 import { ScheduledExportDataContextProvider, } from "./ScheduledExportDataContext.js";
@@ -65,6 +66,11 @@ function LoadedScheduledEmailDialogState({ children }) {
         parametersByTabForNewAutomation,
         defaultPdfPageSize,
     });
+    const scheduleTimezoneState = useScheduleTimezone({
+        scheduledExportToEdit,
+        widget,
+        setEditedAutomation: formState.setEditedAutomation,
+    });
     const exportSettings = useScheduledEmailExportSettings({
         editedAutomation: formState.editedAutomation,
         setEditedAutomation: formState.setEditedAutomation,
@@ -76,6 +82,7 @@ function LoadedScheduledEmailDialogState({ children }) {
         effectiveWidgetFilters,
         effectiveWidgetFiltersWithInsight,
         defaultPdfPageSize,
+        scheduleTimezone: scheduleTimezoneState.scheduleTimezone,
     });
     const filtersModel = useScheduledEmailFiltersModel({
         setEditedAutomation: formState.setEditedAutomation,
@@ -103,6 +110,11 @@ function LoadedScheduledEmailDialogState({ children }) {
         isTitleValid: formState.isTitleValid,
         isSubjectValid: formState.isSubjectValid,
         isOnMessageValid: formState.isOnMessageValid,
+        isTimezoneFeatureEnabled: scheduleTimezoneState.isTimezoneFeatureEnabled,
+        canSelectScheduleTimezone: scheduleTimezoneState.canSelectScheduleTimezone,
+        scheduleTimezoneSelection: scheduleTimezoneState.scheduleTimezoneSelection,
+        defaultResolvedTimezone: scheduleTimezoneState.defaultResolvedTimezone,
+        scheduleTimezoneIsStale: scheduleTimezoneState.scheduleTimezoneIsStale,
     }), [
         formState.editedAutomation,
         formState.originalAutomation,
@@ -111,6 +123,11 @@ function LoadedScheduledEmailDialogState({ children }) {
         formState.isTitleValid,
         formState.isSubjectValid,
         formState.isOnMessageValid,
+        scheduleTimezoneState.isTimezoneFeatureEnabled,
+        scheduleTimezoneState.canSelectScheduleTimezone,
+        scheduleTimezoneState.scheduleTimezoneSelection,
+        scheduleTimezoneState.defaultResolvedTimezone,
+        scheduleTimezoneState.scheduleTimezoneIsStale,
     ]);
     const actions = useMemo(() => ({
         setEditedAutomation: formState.setEditedAutomation,
@@ -128,6 +145,8 @@ function LoadedScheduledEmailDialogState({ children }) {
         onCsvSettingsChange: exportSettings.onCsvSettingsChange,
         onCsvRawSettingsChange: exportSettings.onCsvRawSettingsChange,
         onSlidesTemplateIdChange: exportSettings.onSlidesTemplateIdChange,
+        onScheduleTimezoneChange: scheduleTimezoneState.onScheduleTimezoneChange,
+        applyCurrentScheduleTimezone: scheduleTimezoneState.applyCurrentScheduleTimezone,
     }), [
         formState.setEditedAutomation,
         formState.onTitleChange,
@@ -144,6 +163,8 @@ function LoadedScheduledEmailDialogState({ children }) {
         exportSettings.onCsvSettingsChange,
         exportSettings.onCsvRawSettingsChange,
         exportSettings.onSlidesTemplateIdChange,
+        scheduleTimezoneState.onScheduleTimezoneChange,
+        scheduleTimezoneState.applyCurrentScheduleTimezone,
     ]);
     const data = useMemo(() => ({ defaultUser: formState.defaultUser, defaultRecipient: formState.defaultRecipient }), [formState.defaultUser, formState.defaultRecipient]);
     return (_jsx(ScheduledExportDraftContextProvider, { value: draft, children: _jsx(ScheduledExportActionsContextProvider, { value: actions, children: _jsx(ScheduledExportDataContextProvider, { value: data, children: _jsx(ScheduledExportFiltersContextProvider, { value: filtersModel, children: children }) }) }) }));

package/esm/presentation/automations/scheduledEmail/state/ScheduledExportActionsContext.d.ts

@@ -1,3 +1,4 @@
+import { type useScheduleTimezone } from "../DefaultScheduledEmailDialog/hooks/useScheduleTimezone.js";
 import { type useScheduledEmailExportSettings } from "./useScheduledEmailExportSettings.js";
 import { type useScheduledEmailFormState } from "./useScheduledEmailFormState.js";
 /**
@@ -12,7 +13,7 @@ import { type useScheduledEmailFormState } from "./useScheduledEmailFormState.js
  *
  * @internal
  */
-export type IScheduledExportActionsContextValue = Pick<ReturnType<typeof useScheduledEmailFormState>, "setEditedAutomation" | "onTitleChange" | "onRecurrenceChange" | "onEvaluationModeChange" | "onDestinationChange" | "onRecipientsChange" | "onSubjectChange" | "onMessageChange"> & Pick<ReturnType<typeof useScheduledEmailExportSettings>, "onDashboardAttachmentsChange" | "onWidgetAttachmentsChange" | "onXlsxSettingsChange" | "onPdfSettingsChange" | "onCsvSettingsChange" | "onCsvRawSettingsChange" | "onSlidesTemplateIdChange">;
+export type IScheduledExportActionsContextValue = Pick<ReturnType<typeof useScheduledEmailFormState>, "setEditedAutomation" | "onTitleChange" | "onRecurrenceChange" | "onEvaluationModeChange" | "onDestinationChange" | "onRecipientsChange" | "onSubjectChange" | "onMessageChange"> & Pick<ReturnType<typeof useScheduledEmailExportSettings>, "onDashboardAttachmentsChange" | "onWidgetAttachmentsChange" | "onXlsxSettingsChange" | "onPdfSettingsChange" | "onCsvSettingsChange" | "onCsvRawSettingsChange" | "onSlidesTemplateIdChange"> & Pick<ReturnType<typeof useScheduleTimezone>, "onScheduleTimezoneChange" | "applyCurrentScheduleTimezone">;
 export declare const ScheduledExportActionsContextProvider: import("react").Provider<IScheduledExportActionsContextValue | undefined>;
 /**
  * Reads the scheduled-export dialog's draft mutators.

package/esm/presentation/automations/scheduledEmail/state/ScheduledExportActionsContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ScheduledExportActionsContext.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/state/ScheduledExportActionsContext.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,+BAA+B,EAAE,MAAM,sCAAsC,CAAC;AAC5F,OAAO,EAAE,KAAK,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AAElF;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,mCAAmC,GAAG,IAAI,CAClD,UAAU,CAAC,OAAO,0BAA0B,CAAC,EAC3C,qBAAqB,GACrB,eAAe,GACf,oBAAoB,GACpB,wBAAwB,GACxB,qBAAqB,GACrB,oBAAoB,GACpB,iBAAiB,GACjB,iBAAiB,CACtB,GACG,IAAI,CACA,UAAU,CAAC,OAAO,+BAA+B,CAAC,EAChD,8BAA8B,GAC9B,2BAA2B,GAC3B,sBAAsB,GACtB,qBAAqB,GACrB,qBAAqB,GACrB,wBAAwB,GACxB,0BAA0B,CAC/B,CAAC;AAON,eAAO,MAAM,qCAAqC,2EAAyC,CAAC;AAE5F;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,IAAI,mCAAmC,CAK/E"}
+{"version":3,"file":"ScheduledExportActionsContext.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/state/ScheduledExportActionsContext.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,6DAA6D,CAAC;AAGvG,OAAO,EAAE,KAAK,+BAA+B,EAAE,MAAM,sCAAsC,CAAC;AAC5F,OAAO,EAAE,KAAK,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AAElF;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,mCAAmC,GAAG,IAAI,CAClD,UAAU,CAAC,OAAO,0BAA0B,CAAC,EAC3C,qBAAqB,GACrB,eAAe,GACf,oBAAoB,GACpB,wBAAwB,GACxB,qBAAqB,GACrB,oBAAoB,GACpB,iBAAiB,GACjB,iBAAiB,CACtB,GACG,IAAI,CACA,UAAU,CAAC,OAAO,+BAA+B,CAAC,EAChD,8BAA8B,GAC9B,2BAA2B,GAC3B,sBAAsB,GACtB,qBAAqB,GACrB,qBAAqB,GACrB,wBAAwB,GACxB,0BAA0B,CAC/B,GACD,IAAI,CAAC,UAAU,CAAC,OAAO,mBAAmB,CAAC,EAAE,0BAA0B,GAAG,8BAA8B,CAAC,CAAC;AAO9G,eAAO,MAAM,qCAAqC,2EAAyC,CAAC;AAE5F;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,IAAI,mCAAmC,CAK/E"}

package/esm/presentation/automations/scheduledEmail/state/ScheduledExportDraftContext.d.ts

@@ -1,3 +1,4 @@
+import { type useScheduleTimezone } from "../DefaultScheduledEmailDialog/hooks/useScheduleTimezone.js";
 import { type useScheduledEmailFormState } from "./useScheduledEmailFormState.js";
 /**
  * The scheduled-export dialog's edit draft: the automation being edited, the baseline it is
@@ -5,11 +6,13 @@ import { type useScheduledEmailFormState } from "./useScheduledEmailFormState.js
  * flags the form fields report back.
  *
  * Changes on every keystroke; consumers re-render by design. The shape is derived from
- * `useScheduledEmailFormState`, which owns these values.
+ * `useScheduledEmailFormState`, which owns these values, and `useScheduleTimezone`, which owns the
+ * "Time zone" section's view state (a timezone pick also edits the draft's export definitions, so
+ * the selection changes together with the draft).
  *
  * @internal
  */
-export type IScheduledExportDraftContextValue = Pick<ReturnType<typeof useScheduledEmailFormState>, "editedAutomation" | "originalAutomation" | "startDate" | "isCronValid" | "isTitleValid" | "isSubjectValid" | "isOnMessageValid">;
+export type IScheduledExportDraftContextValue = Pick<ReturnType<typeof useScheduledEmailFormState>, "editedAutomation" | "originalAutomation" | "startDate" | "isCronValid" | "isTitleValid" | "isSubjectValid" | "isOnMessageValid"> & Pick<ReturnType<typeof useScheduleTimezone>, "isTimezoneFeatureEnabled" | "canSelectScheduleTimezone" | "scheduleTimezoneSelection" | "defaultResolvedTimezone" | "scheduleTimezoneIsStale">;
 export declare const ScheduledExportDraftContextProvider: import("react").Provider<IScheduledExportDraftContextValue | undefined>;
 /**
  * Reads the scheduled-export dialog's edit draft.

package/esm/presentation/automations/scheduledEmail/state/ScheduledExportDraftContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ScheduledExportDraftContext.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/state/ScheduledExportDraftContext.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AAElF;;;;;;;;;GASG;AACH,MAAM,MAAM,iCAAiC,GAAG,IAAI,CAChD,UAAU,CAAC,OAAO,0BAA0B,CAAC,EAC3C,kBAAkB,GAClB,oBAAoB,GACpB,WAAW,GACX,aAAa,GACb,cAAc,GACd,gBAAgB,GAChB,kBAAkB,CACvB,CAAC;AAKF,eAAO,MAAM,mCAAmC,yEAAuC,CAAC;AAExF;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,IAAI,iCAAiC,CAK3E"}
+{"version":3,"file":"ScheduledExportDraftContext.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/state/ScheduledExportDraftContext.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,6DAA6D,CAAC;AAGvG,OAAO,EAAE,KAAK,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AAElF;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,iCAAiC,GAAG,IAAI,CAChD,UAAU,CAAC,OAAO,0BAA0B,CAAC,EAC3C,kBAAkB,GAClB,oBAAoB,GACpB,WAAW,GACX,aAAa,GACb,cAAc,GACd,gBAAgB,GAChB,kBAAkB,CACvB,GACG,IAAI,CACA,UAAU,CAAC,OAAO,mBAAmB,CAAC,EACpC,0BAA0B,GAC1B,2BAA2B,GAC3B,2BAA2B,GAC3B,yBAAyB,GACzB,yBAAyB,CAC9B,CAAC;AAKN,eAAO,MAAM,mCAAmC,yEAAuC,CAAC;AAExF;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,IAAI,iCAAiC,CAK3E"}

package/esm/presentation/automations/scheduledEmail/state/exportDefinitions.d.ts

@@ -5,15 +5,26 @@ import { type DashboardAttachmentType, type FilterContextItem, type IAutomationM
  * a rebuild from zero definitions — see `latestParametersWireRef`.
  */
 export declare function withRebuiltExportDefinitions(automation: IAutomationMetadataObjectDefinition, exportDefinitions: NonNullable<IAutomationMetadataObjectDefinition["exportDefinitions"]>, parametersByTab: Record<string, IDashboardExportParameter[]> | undefined): IAutomationMetadataObjectDefinition;
-export declare function newDashboardExportDefinitionMetadataObjectDefinition({ dashboardId, dashboardTitle, dashboardFilters, filtersByTab, format, templateId }: {
+/**
+ * Applies the export-content timezone to every export definition of the automation. Undefined
+ * removes the timezone so the backend derives it at run time from the stored dashboard.
+ */
+export declare function withExportDefinitionsTimezone(automation: IAutomationMetadataObjectDefinition, timezoneId: string | undefined): IAutomationMetadataObjectDefinition;
+/**
+ * The export-content timezone stored with the automation, read from its export definitions.
+ * All definitions of one automation carry the same value, so the first one is authoritative.
+ */
+export declare function getExportDefinitionsTimezone(automation: IAutomationMetadataObjectDefinition | undefined): string | undefined;
+export declare function newDashboardExportDefinitionMetadataObjectDefinition({ dashboardId, dashboardTitle, dashboardFilters, filtersByTab, format, templateId, timezoneId }: {
     dashboardId: string;
     dashboardTitle: string;
     dashboardFilters?: FilterContextItem[];
     filtersByTab?: Record<string, FilterContextItem[]>;
     format: DashboardAttachmentType;
     templateId?: string;
+    timezoneId?: string;
 }): IExportDefinitionMetadataObjectDefinition;
-export declare function newWidgetExportDefinitionMetadataObjectDefinition({ insight, widget, dashboardId, format, widgetFilters, widgetFiltersWithInsight, dashboardFilters, defaultPdfPageSize, defaultCsvDelimiter }: {
+export declare function newWidgetExportDefinitionMetadataObjectDefinition({ insight, widget, dashboardId, format, widgetFilters, widgetFiltersWithInsight, dashboardFilters, defaultPdfPageSize, defaultCsvDelimiter, timezoneId }: {
     insight: IInsight;
     widget: IWidget;
     dashboardId: string;
@@ -23,5 +34,11 @@ export declare function newWidgetExportDefinitionMetadataObjectDefinition({ insi
     dashboardFilters?: FilterContextItem[];
     defaultPdfPageSize?: IExportDefinitionVisualizationObjectSettings["pageSize"];
     defaultCsvDelimiter?: string;
+    /**
+     * Effective dashboard timezone baked into the definition. Unlike dashboard export definitions,
+     * widget exports always carry it when defined — the backend does not load the dashboard object
+     * for widget exports, so it has no access to the dashboard's timezone configuration.
+     */
+    timezoneId?: string;
 }): IExportDefinitionMetadataObjectDefinition;
 //# sourceMappingURL=exportDefinitions.d.ts.map

package/esm/presentation/automations/scheduledEmail/state/exportDefinitions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exportDefinitions.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/state/exportDefinitions.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EACtB,KAAK,mCAAmC,EACxC,KAAK,yBAAyB,EAC9B,KAAK,yCAAyC,EAC9C,KAAK,4CAA4C,EACjD,KAAK,OAAO,EACZ,KAAK,QAAQ,EACb,KAAK,OAAO,EACZ,KAAK,oBAAoB,EAE5B,MAAM,qBAAqB,CAAC;AAI7B;;;;GAIG;AACH,wBAAgB,4BAA4B,CACxC,UAAU,EAAE,mCAAmC,EAC/C,iBAAiB,EAAE,WAAW,CAAC,mCAAmC,CAAC,mBAAmB,CAAC,CAAC,EACxF,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,yBAAyB,EAAE,CAAC,GAAG,SAAS,GACzE,mCAAmC,CAGrC;AAED,wBAAgB,oDAAoD,CAAC,EACjE,WAAW,EACX,cAAc,EACd,gBAAgB,EAChB,YAAY,EACZ,MAAM,EACN,UAAU,EACb,EAAE;IACC,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,CAAC,EAAE,iBAAiB,EAAE,CAAC;IACvC,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAAC;IACnD,MAAM,EAAE,uBAAuB,CAAC;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB,GAAG,yCAAyC,CAyB5C;AAED,wBAAgB,iDAAiD,CAAC,EAC9D,OAAO,EACP,MAAM,EACN,WAAW,EACX,MAAM,EACN,aAAa,EACb,wBAAwB,EACxB,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,EACtB,EAAE;IACC,OAAO,EAAE,QAAQ,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,oBAAoB,CAAC;IAC7B,aAAa,CAAC,EAAE,OAAO,EAAE,CAAC;IAC1B,wBAAwB,CAAC,EAAE,OAAO,EAAE,CAAC;IACrC,gBAAgB,CAAC,EAAE,iBAAiB,EAAE,CAAC;IACvC,kBAAkB,CAAC,EAAE,4CAA4C,CAAC,UAAU,CAAC,CAAC;IAC9E,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAChC,GAAG,yCAAyC,CAiE5C"}
+{"version":3,"file":"exportDefinitions.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/state/exportDefinitions.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EACtB,KAAK,mCAAmC,EACxC,KAAK,yBAAyB,EAC9B,KAAK,yCAAyC,EAC9C,KAAK,4CAA4C,EACjD,KAAK,OAAO,EACZ,KAAK,QAAQ,EACb,KAAK,OAAO,EACZ,KAAK,oBAAoB,EAE5B,MAAM,qBAAqB,CAAC;AAI7B;;;;GAIG;AACH,wBAAgB,4BAA4B,CACxC,UAAU,EAAE,mCAAmC,EAC/C,iBAAiB,EAAE,WAAW,CAAC,mCAAmC,CAAC,mBAAmB,CAAC,CAAC,EACxF,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,yBAAyB,EAAE,CAAC,GAAG,SAAS,GACzE,mCAAmC,CAGrC;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,CACzC,UAAU,EAAE,mCAAmC,EAC/C,UAAU,EAAE,MAAM,GAAG,SAAS,GAC/B,mCAAmC,CAkBrC;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CACxC,UAAU,EAAE,mCAAmC,GAAG,SAAS,GAC5D,MAAM,GAAG,SAAS,CAEpB;AAED,wBAAgB,oDAAoD,CAAC,EACjE,WAAW,EACX,cAAc,EACd,gBAAgB,EAChB,YAAY,EACZ,MAAM,EACN,UAAU,EACV,UAAU,EACb,EAAE;IACC,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,CAAC,EAAE,iBAAiB,EAAE,CAAC;IACvC,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAAC;IACnD,MAAM,EAAE,uBAAuB,CAAC;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB,GAAG,yCAAyC,CA0B5C;AAED,wBAAgB,iDAAiD,CAAC,EAC9D,OAAO,EACP,MAAM,EACN,WAAW,EACX,MAAM,EACN,aAAa,EACb,wBAAwB,EACxB,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,EACnB,UAAU,EACb,EAAE;IACC,OAAO,EAAE,QAAQ,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,oBAAoB,CAAC;IAC7B,aAAa,CAAC,EAAE,OAAO,EAAE,CAAC;IAC1B,wBAAwB,CAAC,EAAE,OAAO,EAAE,CAAC;IACrC,gBAAgB,CAAC,EAAE,iBAAiB,EAAE,CAAC;IACvC,kBAAkB,CAAC,EAAE,4CAA4C,CAAC,UAAU,CAAC,CAAC;IAC9E,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB,GAAG,yCAAyC,CAkE5C"}