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

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"}

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

@@ -0,0 +1,26 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { DefaultScheduledEmailDialogTimezone } from "../DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogTimezone.js";
+import { useScheduledExportDraft } from "../state/ScheduledExportDraftContext.js";
+import { useScheduledEmailDialogTimezoneProps } from "../state/useScheduledEmailDialogRegionProps.js";
+import { WhenScheduledEmailDialogLoaded } from "./WhenScheduledEmailDialogLoaded.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 function ScheduledEmailDialogTimezone(overrides) {
+    return (_jsx(WhenScheduledEmailDialogLoaded, { children: _jsx(ConnectedScheduledEmailDialogTimezone, { ...overrides }) }));
+}
+function ConnectedScheduledEmailDialogTimezone(overrides) {
+    const { canSelectScheduleTimezone } = useScheduledExportDraft();
+    const defaultProps = useScheduledEmailDialogTimezoneProps();
+    return canSelectScheduleTimezone ? (_jsx(DefaultScheduledEmailDialogTimezone, { ...defaultProps, ...overrides })) : null;
+}

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

@@ -0,0 +1,14 @@
+import { type ReactNode } from "react";
+/**
+ * Renders its children only once the scheduled-export dialog's data has loaded — the state accessors
+ * throw while `useScheduledEmailDialogContext().isLoading` is true, because the state providers mount
+ * only then. Every connected scheduled-email block goes through it. On scheduled email this state is
+ * on the ordinary path — a widget export renders while its filters load — so a shell sees its blocks
+ * appear once loading ends.
+ *
+ * @internal
+ */
+export declare function WhenScheduledEmailDialogLoaded({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=WhenScheduledEmailDialogLoaded.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WhenScheduledEmailDialogLoaded.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/blocks/WhenScheduledEmailDialogLoaded.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAIvC;;;;;;;;GAQG;AACH,wBAAgB,8BAA8B,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,kDAGnF"}

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

@@ -0,0 +1,15 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useScheduledEmailDialogContext } from "../../contexts/ScheduledEmailDialogContext.js";
+/**
+ * Renders its children only once the scheduled-export dialog's data has loaded — the state accessors
+ * throw while `useScheduledEmailDialogContext().isLoading` is true, because the state providers mount
+ * only then. Every connected scheduled-email block goes through it. On scheduled email this state is
+ * on the ordinary path — a widget export renders while its filters load — so a shell sees its blocks
+ * appear once loading ends.
+ *
+ * @internal
+ */
+export function WhenScheduledEmailDialogLoaded({ children }) {
+    const { isLoading } = useScheduledEmailDialogContext();
+    return isLoading ? null : _jsx(_Fragment, { children: children });
+}

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

@@ -1,4 +1,4 @@
-import { type IScheduleTimezoneSelection } from "../../types.js";
+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 —

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

@@ -0,0 +1 @@
+{"version":3,"file":"useExportTimezones.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/hooks/useExportTimezones.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,0BAA0B,EAAE,MAAM,aAAa,CAAC;AAE9D;;;;;;;;;;;;;;;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 → hooks}/useExportTimezones.js

@@ -1,6 +1,6 @@
 // (C) 2026 GoodData Corporation
 import { resolveTimezoneId } from "@gooddata/sdk-model";
-import { useAutomationsContext } from "../../../contexts/AutomationsContext.js";
+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 —

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

@@ -1,6 +1,6 @@
 import { type Dispatch, type SetStateAction } from "react";
 import { type IAutomationMetadataObject, type IAutomationMetadataObjectDefinition, type IWidget } from "@gooddata/sdk-model";
-import { type IScheduleTimezoneState } from "../../state/types.js";
+import { type IScheduleTimezoneState } from "../state/types.js";
 export interface IUseScheduleTimezoneProps {
     scheduledExportToEdit?: IAutomationMetadataObject;
     widget?: IWidget;

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

@@ -0,0 +1 @@
+{"version":3,"file":"useScheduleTimezone.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/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;AAG7B,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAKhE,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,GAAG,sBAAsB,CA0EpD"}

package/esm/presentation/automations/scheduledEmail/{DefaultScheduledEmailDialog/hooks → hooks}/useScheduleTimezone.js

@@ -1,6 +1,6 @@
 // (C) 2026 GoodData Corporation
 import { useCallback, useState } from "react";
-import { getExportDefinitionsTimezone, withExportDefinitionsTimezone, } from "../../state/exportDefinitions.js";
+import { getExportDefinitionsTimezone, withExportDefinitionsTimezone } from "../state/exportDefinitions.js";
 import { useExportTimezones } from "./useExportTimezones.js";
 /**
  * Owns the "Time zone" section state of the scheduled-email dialog.

package/esm/presentation/automations/scheduledEmail/hooks/useScheduleValidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useScheduleValidation.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/hooks/useScheduleValidation.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,KAAK,mCAAmC,EAI3C,MAAM,qBAAqB,CAAC;AAI7B,eAAO,MAAM,qBAAqB;;CAsBjC,CAAC"}

package/esm/presentation/automations/scheduledEmail/{DefaultScheduledEmailDialog/hooks → hooks}/useScheduleValidation.js

@@ -1,6 +1,6 @@
 // (C) 2024-2026 GoodData Corporation
 import { isExportDefinitionDashboardRequestPayload, isExportDefinitionVisualizationObjectRequestPayload, } from "@gooddata/sdk-model";
-import { useAutomationsContext } from "../../../contexts/AutomationsContext.js";
+import { useAutomationsContext } from "../../contexts/AutomationsContext.js";
 export const useScheduleValidation = (schedule) => {
     const { widgetExistsByRef } = useAutomationsContext();
     const isDashboardSchedule = schedule.exportDefinitions?.some((exportDefinition) => isExportDefinitionDashboardRequestPayload(exportDefinition.requestPayload));

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

@@ -4,7 +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 { useScheduleTimezone } from "../hooks/useScheduleTimezone.js";
 import { getDefaultPdfPageSize } from "../utils/pdfPageSize.js";
 import { ScheduledExportActionsContextProvider } from "./ScheduledExportActionsContext.js";
 import { ScheduledExportDataContextProvider } from "./ScheduledExportDataContext.js";

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

@@ -8,7 +8,7 @@ export declare const ScheduledExportActionsContextProvider: import("react").Prov
  * `ScheduledEmailDialogComponent` must check that flag before calling this. That state is on the
  * ordinary path here: a widget export renders while its filters load.
  *
- * @internal
+ * @alpha
  */
 export declare function useScheduledExportActions(): IScheduledExportActionsContextValue;
 //# sourceMappingURL=ScheduledExportActionsContext.d.ts.map

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

@@ -12,7 +12,7 @@ export const ScheduledExportActionsContextProvider = ScheduledExportActionsConte
  * `ScheduledEmailDialogComponent` must check that flag before calling this. That state is on the
  * ordinary path here: a widget export renders while its filters load.
  *
- * @internal
+ * @alpha
  */
 export function useScheduledExportActions() {
     return (useContext(ScheduledExportActionsContext) ??

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

@@ -8,7 +8,7 @@ export declare const ScheduledExportDataContextProvider: import("react").Provide
  * `ScheduledEmailDialogComponent` must check that flag before calling this. That state is on the
  * ordinary path here: a widget export renders while its filters load.
  *
- * @internal
+ * @alpha
  */
 export declare function useScheduledExportData(): IScheduledExportDataContextValue;
 //# sourceMappingURL=ScheduledExportDataContext.d.ts.map

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

@@ -12,7 +12,7 @@ export const ScheduledExportDataContextProvider = ScheduledExportDataContext.Pro
  * `ScheduledEmailDialogComponent` must check that flag before calling this. That state is on the
  * ordinary path here: a widget export renders while its filters load.
  *
- * @internal
+ * @alpha
  */
 export function useScheduledExportData() {
     return (useContext(ScheduledExportDataContext) ??

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

@@ -8,7 +8,7 @@ export declare const ScheduledExportDraftContextProvider: import("react").Provid
  * `ScheduledEmailDialogComponent` must check that flag before calling this. That state is on the
  * ordinary path here: a widget export renders while its filters load.
  *
- * @internal
+ * @alpha
  */
 export declare function useScheduledExportDraft(): IScheduledExportDraftContextValue;
 //# sourceMappingURL=ScheduledExportDraftContext.d.ts.map

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

@@ -12,7 +12,7 @@ export const ScheduledExportDraftContextProvider = ScheduledExportDraftContext.P
  * `ScheduledEmailDialogComponent` must check that flag before calling this. That state is on the
  * ordinary path here: a widget export renders while its filters load.
  *
- * @internal
+ * @alpha
  */
 export function useScheduledExportDraft() {
     return (useContext(ScheduledExportDraftContext) ??

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

@@ -8,7 +8,7 @@ export declare const ScheduledExportFiltersContextProvider: import("react").Prov
  * `ScheduledEmailDialogComponent` must check that flag before calling this. That state is on the
  * ordinary path here: a widget export renders while its filters load.
  *
- * @internal
+ * @alpha
  */
 export declare function useScheduledExportFilters(): IScheduledExportFiltersContextValue;
 //# sourceMappingURL=ScheduledExportFiltersContext.d.ts.map

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

@@ -12,7 +12,7 @@ export const ScheduledExportFiltersContextProvider = ScheduledExportFiltersConte
  * `ScheduledEmailDialogComponent` must check that flag before calling this. That state is on the
  * ordinary path here: a widget export renders while its filters load.
  *
- * @internal
+ * @alpha
  */
 export function useScheduledExportFilters() {
     return (useContext(ScheduledExportFiltersContext) ??